Merge pull request #996 from andrew-bierman/feat/cf-vectorize-initial

packages/shared-types/README.md

@@ -0,0 +1 @@
+# shared-types

packages/shared-types/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@packrat/shared-types",
+  "version": "0.0.1",
+  "source": "src/index.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "private": true,
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "NODE_OPTIONS=--max_old_space_size=4096 tsc",
+    "build:and:install": "yarn build && yarn",
+    "postinstall": "yarn build",
+    "clean": "rm -rf dist && rm -rf node_modules"
+  },
+  "keywords": [],
+  "license": "ISC",
+  "devDependencies": {
+    "typescript": "^5.5.3"
+  }
+}

packages/shared-types/src/index.ts

@@ -0,0 +1 @@
+export * from './packAndItemVisibilityFilter';

packages/shared-types/src/packAndItemVisibilityFilter.ts

@@ -0,0 +1,5 @@
+export enum PackAndItemVisibilityFilter {
+  PUBLIC = 'PUBLIC',
+  PRIVATE = 'PRIVATE',
+  ALL = 'ALL',
+}

packages/shared-types/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "lib": ["es6", "DOM"],
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "isolatedModules": true,
+    "moduleResolution": "node",
+    "preserveWatchOutput": true,
+    "skipLibCheck": true,
+    "allowJs": true,
+    "strict": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true,
+    "sourceMap": true,
+    "declarationMap": true
+  },
+  "exclude": ["node_modules"],
+  "include": ["src"]
+}

packages/validations/package.json

@@ -16,6 +16,7 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
+    "@packrat/shared-types": "*",
     "@types/express": "^4.17.17",
     "@types/node": "^20.14.2",
     "express": "^4.19.2",

packages/validations/src/validations/itemRoutesValidator.ts

@@ -1,3 +1,4 @@
+import { PackAndItemVisibilityFilter } from '@packrat/shared-types';
 import { z } from 'zod';
 
 export const getItemByName = z.object({
@@ -67,3 +68,11 @@ export const getItemsGlobally = z.object({
   limit: z.number(),
   page: z.number(),
 });
+
+export const getSimilarItems = z.object({
+  id: z.string(),
+  limit: z.number(),
+  visibility: z
+    .nativeEnum(PackAndItemVisibilityFilter)
+    .default(PackAndItemVisibilityFilter.ALL),
+});

packages/validations/src/validations/packRoutesValidator.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { PackAndItemVisibilityFilter } from '@packrat/shared-types';
 
 export const getPacks = z.object({
   ownerId: z.string(),
@@ -43,3 +44,11 @@ export const duplicatePublicPack = z.object({
   ownerId: z.string(),
   items: z.array(z.string()),
 });
+
+export const getSimilarPacks = z.object({
+  id: z.string(),
+  limit: z.number(),
+  visibility: z
+    .nativeEnum(PackAndItemVisibilityFilter)
+    .default(PackAndItemVisibilityFilter.ALL),
+});

server/package.json

@@ -37,11 +37,13 @@
   "author": "Andrew Bierman",
   "license": "ISC",
   "dependencies": {
+    "@cloudflare/ai": "^1.2.2",
     "@elysiajs/trpc": "^0.7.0",
     "@hono/node-server": "^1.11.0",
     "@hono/trpc-server": "^0.1.1",
     "@instructor-ai/instructor": "^1.3.0",
     "@libsql/client": "^0.4.0-pre.5",
+    "@packrat/shared-types": "*",
     "@packrat/validations": "*",
     "@paralleldrive/cuid2": "^2.2.2",
     "@prisma/client": "^5.7.0",
@@ -93,6 +95,7 @@
     "nodemon": "^3.0.1",
     "openai": "4.25.0",
     "osmtogeojson": "^3.0.0-beta.5",
+    "p-queue": "^8.0.1",
     "passport": "^0.6.0",
     "passport-google-oauth20": "^2.0.0",
     "passport-local": "^1.0.0",

server/src/controllers/item/addItem.ts

@@ -38,6 +38,7 @@ export function addItemRoute() {
       packId,
       type,
       ownerId,
+      opts.ctx.executionCtx,
     );
     return result;
   });

server/src/controllers/item/addItemGlobal.ts

@@ -39,6 +39,7 @@ export function addItemGlobalRoute() {
         unit,
         type,
         ownerId,
+        opts.ctx.executionCtx,
       );
       return item;
     });

server/src/controllers/item/deleteGlobalItem.ts

@@ -24,6 +24,6 @@ export function deleteGlobalItemRoute() {
     )
     .mutation(async (opts) => {
       const { itemId } = opts.input;
-      return await deleteGlobalItemService(itemId);
+      return await deleteGlobalItemService(itemId, opts.ctx.executionCtx);
     });
 }

server/src/controllers/item/deleteItem.ts

@@ -17,6 +17,6 @@ export function deleteItemRoute() {
     .input(validator.deleteItem)
     .mutation(async (opts) => {
       const { itemId, packId } = opts.input;
-      return await deleteItemService(itemId, packId);
+      return await deleteItemService(itemId, opts.ctx.executionCtx, packId);
     });
 }

server/src/controllers/item/editGlobalItemAsDuplicate.ts

@@ -49,6 +49,7 @@ export function editGlobalItemAsDuplicateRoute() {
         quantity,
         unit,
         type,
+        opts.ctx.executionCtx,
       );
       return item;
     });

server/src/controllers/item/editItem.ts

@@ -21,7 +21,15 @@ export function editItemRoute() {
       throw new Error('Invalid item type');
     }
 
-    const item = await editItemService(id, name, weight, unit, quantity, type);
+    const item = await editItemService(
+      opts.ctx.executionCtx,
+      id,
+      name,
+      weight,
+      unit,
+      quantity,
+      type,
+    );
     return item;
   });
 }

server/src/controllers/item/getSimilarItems.ts

@@ -0,0 +1,18 @@
+import { getSimilarItemsService } from '../../services/item/getSimilarItemsService';
+import { protectedProcedure } from '../../trpc';
+import * as validator from '@packrat/validations';
+
+export function getSimilarItemsRoute() {
+  return protectedProcedure
+    .input(validator.getSimilarItems)
+    .query(async (opts) => {
+      const { id, limit, visibility } = opts.input;
+
+      if (limit < 1) {
+        throw new Error('limit must be greater than 0');
+      }
+
+      const items = await getSimilarItemsService(id, limit, visibility);
+      return items;
+    });
+}

server/src/controllers/item/index.ts

@@ -9,3 +9,4 @@ export * from './getItemById';
 export * from './editGlobalItemAsDuplicate';
 export * from './getItemsGlobally';
 export * from './searchItemsByName';
+export * from './getSimilarItems';

server/src/controllers/pack/addPack.ts

@@ -15,7 +15,12 @@ export const addPack = async (c) => {
 export function addPackRoute() {
   return protectedProcedure.input(validator.addPack).mutation(async (opts) => {
     const { name, owner_id, is_public } = opts.input;
-    const pack = await addPackService(name, owner_id, is_public);
+    const pack = await addPackService(
+      name,
+      owner_id,
+      is_public,
+      opts.ctx.executionCtx,
+    );
     return pack;
   });
 }

server/src/controllers/pack/deletePack.ts

@@ -17,7 +17,7 @@ export function deletePackRoute() {
     .input(validator.deletePack)
     .mutation(async (opts) => {
       const { packId } = opts.input;
-      await deletePackService(packId);
+      await deletePackService(packId, opts.ctx.executionCtx);
       return { msg: 'pack was deleted successfully' };
     });
 }

server/src/controllers/pack/duplicatePublicPack.ts

@@ -20,7 +20,12 @@ export function duplicatePublicPackRoute() {
     .input(validator.duplicatePublicPack)
     .mutation(async (opts) => {
       const { packId, ownerId, items } = opts.input;
-      const result = await duplicatePublicPackService(packId, ownerId, items);
+      const result = await duplicatePublicPackService(
+        packId,
+        ownerId,
+        items,
+        opts.ctx.executionCtx,
+      );
       return result;
     });
 }

server/src/controllers/pack/editPack.ts

@@ -15,7 +15,7 @@ export const editPack = async (c) => {
 export function editPackRoute() {
   return protectedProcedure.input(validator.editPack).mutation(async (opts) => {
     const packData = opts.input;
-    const pack = await editPackService(packData);
+    const pack = await editPackService(packData, opts.ctx.executionCtx);
     return pack;
   });
 }

server/src/controllers/pack/getSimilarPacks.ts

@@ -0,0 +1,16 @@
+import { protectedProcedure } from '../../trpc';
+import { getSimilarPacksService } from '../../services/pack/pack.service';
+import { getSimilarPacks } from '@packrat/validations';
+
+export function getSimilarPacksRoute() {
+  return protectedProcedure.input(getSimilarPacks).query(async (opts) => {
+    const { id, limit, visibility } = opts.input;
+
+    if (limit < 1) {
+      throw new Error('limit must be greater than 0');
+    }
+
+    const packs = await getSimilarPacksService(id, limit, visibility);
+    return packs;
+  });
+}

server/src/controllers/pack/index.ts

@@ -6,3 +6,4 @@ export * from './duplicatePublicPack';
 export * from './getPackById';
 export * from './getPublicPacks';
 export * from './scorePack';
+export * from './getSimilarPacks';

server/src/index.ts

@@ -7,15 +7,20 @@ import { securityHeaders } from './middleware/securityHeaders';
 import { enforceHttps } from './middleware/enforceHttps';
 import router from './routes';
 import { CORS_METHODS } from './config';
+import { Ai } from '@cloudflare/ai';
 import { httpDBContext } from './trpc/httpDBContext';
 
 interface Bindings {
   [key: string]: any;
   DB: IDBDatabase;
+  VECTOR_INDEX: VectorizeIndex;
+  AI: Ai;
   JWT_VERIFICATION_KEY: string;
   APP_URL: string;
   CORS_ORIGIN: string;
   MAPBOX_ACCESS_TOKEN: string;
+  CLOUDFLARE_ACCOUNT_ID: string;
+  VECTORIZE_API_KEY: string;
 }
 
 const TRPC_API_ENDPOINT = '/api/trpc';

server/src/integrations/ai/client.ts

@@ -0,0 +1,79 @@
+import { Ai } from "@cloudflare/ai";
+
+class AiClient {
+  private static _instance: AiClient | null = null;
+  private apiKey: string;
+  private accountId: string;
+  private readonly MODEL_NAME: string = '@cf/baai/bge-base-en-v1.5';
+  private readonly EXECUTE_AI_MODEL_URL: string;
+
+  private constructor(apiKey: string, accountId: string) {
+    this.apiKey = apiKey;
+    this.accountId = accountId;
+    this.EXECUTE_AI_MODEL_URL = `https://api.cloudflare.com/client/v4/accounts/${this.accountId}/ai/run/${this.MODEL_NAME}`;
+  }
+
+  public static get instance(): AiClient {
+    if (!AiClient._instance) {
+      throw new Error('AiClient instance not initialized.');
+    }
+    return AiClient._instance;
+  }
+
+  public static async init({
+    apiKey,
+    accountId,
+  }: {
+    apiKey: string;
+    accountId: string;
+  }): Promise<void> {
+    if (!AiClient._instance) {
+      AiClient._instance = new AiClient(apiKey, accountId);
+    }
+  }
+
+  public async run(text: string) {
+    const response = await fetch(this.EXECUTE_AI_MODEL_URL, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${this.apiKey}`,
+      },
+      body: JSON.stringify({ text }),
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(
+        `Failed to get embedding: ${response.statusText} - ${errorText}`,
+      );
+    }
+
+    return await response.json();
+  }
+
+  public static async getEmbedding(content: string): Promise<number[]> {
+    const {
+      result: { data },
+    } = await AiClient.instance.run(content);
+    return data[0];
+  }
+
+  // Commented out using AI client and temporalily use REST API instead
+  // public static async init(cfAi): Promise<void> {
+  //   if (!AiClient._instance) {
+  //     AiClient._instance = new Ai(cfAi);
+  //   }
+  // }
+
+  // public static async getEmbedding(content: string): Promise<number[]> {
+  //   const { data } = await AiClient.instance.run('@cf/baai/bge-base-en-v1.5', { text: [content] });
+  //   return data[0];
+  // }
+}
+
+export { AiClient };
+
+export interface Env {
+  AI: any;
+}

server/src/queue/client.ts

@@ -0,0 +1,25 @@
+import PQueue from 'p-queue';
+
+interface QueueTask<T> {
+  (): Promise<T>;
+}
+
+export class Queue {
+  private static instance: Queue;
+  private queue: PQueue;
+
+  private constructor(concurrency: number = 1) {
+    this.queue = new PQueue({ concurrency });
+  }
+
+  static getInstance(concurrency: number = 1): Queue {
+    if (!Queue.instance) {
+      Queue.instance = new Queue(concurrency);
+    }
+    return Queue.instance;
+  }
+
+  async addTask<T>(task: QueueTask<T>): Promise<T> {
+    return this.queue.add(task);
+  }
+}