super simple search endpoint on channel: find all products that contain query string

Author: hmbanan666

sdk/core.ts

@@ -106,6 +106,19 @@ export class MainAPI {
     );
   }
 
+  public async searchInChannel(
+    channelId: string,
+    query: string,
+    externalConfig?: NextFetchRequestConfig,
+  ) {
+    return this.coreRequest<ProductVariant[] | null>(
+      `channel/${channelId}/search/${query}`,
+      'GET',
+      undefined,
+      externalConfig,
+    );
+  }
+
   public async getAllMedia(externalConfig?: NextFetchRequestConfig) {
     return this.coreRequest<Media[]>(
       'media/list',

sdk/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@next-orders/api-sdk",
-  "version": "0.2.22",
+  "version": "0.2.23",
   "description": "TS Lib: Easy ability to make requests to Main API via NPM package. 100% typed.",
   "scripts": {
     "build": "tsup",

src/channel/channel.controller.ts

@@ -26,6 +26,20 @@ export class ChannelController {
     return channels;
   }
 
+  @Public()
+  @Get(':id/search/:query')
+  async searchInChannel(
+    @Param('id') id: string,
+    @Param('query') query: string,
+  ) {
+    const found = await this.service.searchInChannel(id, query);
+    if (!found) {
+      throw new NotFoundException();
+    }
+
+    return found;
+  }
+
   @Public()
   @Get(':id')
   async findChannelById(@Param('id') id: string) {

src/channel/channel.module.ts

@@ -2,9 +2,10 @@ import { Module } from '@nestjs/common';
 import { PrismaService } from '@/db/prisma.service';
 import { ChannelController } from '@/channel/channel.controller';
 import { ChannelService } from '@/channel/channel.service';
+import { ProductVariantService } from '@/product-variant/product-variant.service';
 
 @Module({
   controllers: [ChannelController],
-  providers: [ChannelService, PrismaService],
+  providers: [ChannelService, ProductVariantService, PrismaService],
 })
 export class ChannelModule {}

src/channel/channel.service.ts

@@ -1,12 +1,16 @@
 import { Injectable } from '@nestjs/common';
 import { createId } from '@paralleldrive/cuid2';
 import { PrismaService } from '@/db/prisma.service';
-import { Channel } from '@api-sdk';
+import { Channel, MenuCategory } from '@api-sdk';
 import { CreateChannelDto } from '@/channel/dto/create-channel.dto';
+import { ProductVariantService } from '@/product-variant/product-variant.service';
 
 @Injectable()
 export class ChannelService {
-  constructor(private readonly prisma: PrismaService) {}
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly productVariant: ProductVariantService,
+  ) {}
 
   async findAllChannels(): Promise<Channel[] | null> {
     return this.prisma.channel.findMany({
@@ -57,4 +61,39 @@ export class ChannelService {
       },
     });
   }
+
+  async searchInChannel(channelId: string, query: string) {
+    if (query.length < 2) {
+      return null;
+    }
+
+    const [channel, foundProducts] = await Promise.all([
+      this.findChannelById(channelId),
+      this.productVariant.findProductVariantByName(query),
+    ]);
+
+    if (!foundProducts) {
+      return null;
+    }
+
+    const menus = channel?.menus;
+    if (!menus) {
+      return null;
+    }
+
+    // Get all possible categories for this channel
+    const categories: MenuCategory[] = [];
+    for (const menu of menus) {
+      for (const category of menu.categories) {
+        categories.push(category);
+      }
+    }
+
+    // Filter only in this categories
+    foundProducts.filter((product) =>
+      categories.some((value) => value.id === product.category.id),
+    );
+
+    return foundProducts;
+  }
 }

src/product-variant/product-variant.service.ts

@@ -48,6 +48,31 @@ export class ProductVariantService {
     return product;
   }
 
+  async findProductVariantByName(
+    name: string,
+  ): Promise<ProductVariant[] | null> {
+    const product = await this.prisma.productVariant.findMany({
+      where: {
+        name: {
+          contains: name,
+        },
+      },
+      include: {
+        category: true,
+        media: {
+          include: {
+            media: true,
+          },
+        },
+      },
+    });
+    if (!product) {
+      return null;
+    }
+
+    return product;
+  }
+
   async findProductVariantById(id: string): Promise<ProductVariant | null> {
     const product = await this.prisma.productVariant.findUnique({
       where: { id },