@m5kdev/backend 0.1.0 → 0.1.2

package/dist/src/modules/ai/ai.repository.d.ts

@@ -0,0 +1,424 @@
+import type { InferInsertModel, InferSelectModel } from "drizzle-orm";
+import type { LibSQLDatabase } from "drizzle-orm/libsql";
+import type { ServerResultAsync } from "#modules/base/base.dto";
+import { BaseTableRepository } from "#modules/base/base.repository";
+declare const schema: {
+    chats: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+        name: "chats";
+        schema: undefined;
+        columns: {
+            id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "id";
+                tableName: "chats";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: true;
+                isAutoincrement: false;
+                hasRuntimeDefault: true;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            userId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "user_id";
+                tableName: "chats";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            title: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "title";
+                tableName: "chats";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            type: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "type";
+                tableName: "chats";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            conversation: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "conversation";
+                tableName: "chats";
+                dataType: "json";
+                columnType: "SQLiteTextJson";
+                data: unknown;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "created_at";
+                tableName: "chats";
+                dataType: "date";
+                columnType: "SQLiteTimestamp";
+                data: Date;
+                driverParam: number;
+                notNull: false;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: true;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            updatedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "updated_at";
+                tableName: "chats";
+                dataType: "date";
+                columnType: "SQLiteTimestamp";
+                data: Date;
+                driverParam: number;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: true;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+        };
+        dialect: "sqlite";
+    }>;
+    aiUsage: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+        name: "ai_usage";
+        schema: undefined;
+        columns: {
+            id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "id";
+                tableName: "ai_usage";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: true;
+                isAutoincrement: false;
+                hasRuntimeDefault: true;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            userId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "user_id";
+                tableName: "ai_usage";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            teamId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "team_id";
+                tableName: "ai_usage";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            organizationId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "organization_id";
+                tableName: "ai_usage";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            feature: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "feature";
+                tableName: "ai_usage";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            provider: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "provider";
+                tableName: "ai_usage";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            model: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "model";
+                tableName: "ai_usage";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            inputTokens: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "input_tokens";
+                tableName: "ai_usage";
+                dataType: "number";
+                columnType: "SQLiteInteger";
+                data: number;
+                driverParam: number;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            outputTokens: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "output_tokens";
+                tableName: "ai_usage";
+                dataType: "number";
+                columnType: "SQLiteInteger";
+                data: number;
+                driverParam: number;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            totalTokens: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "total_tokens";
+                tableName: "ai_usage";
+                dataType: "number";
+                columnType: "SQLiteInteger";
+                data: number;
+                driverParam: number;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            cost: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "cost";
+                tableName: "ai_usage";
+                dataType: "number";
+                columnType: "SQLiteReal";
+                data: number;
+                driverParam: number;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            traceId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "trace_id";
+                tableName: "ai_usage";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "created_at";
+                tableName: "ai_usage";
+                dataType: "date";
+                columnType: "SQLiteTimestamp";
+                data: Date;
+                driverParam: number;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: true;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            metadata: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "metadata";
+                tableName: "ai_usage";
+                dataType: "json";
+                columnType: "SQLiteTextJson";
+                data: unknown;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+        };
+        dialect: "sqlite";
+    }>;
+};
+type Schema = typeof schema;
+type Orm = LibSQLDatabase<Schema>;
+export type AiUsageRow = InferSelectModel<Schema["aiUsage"]>;
+export type AiUsageInsert = InferInsertModel<Schema["aiUsage"]>;
+export interface CreateAiUsageInput {
+    userId?: string;
+    teamId?: string;
+    organizationId?: string;
+    feature: string;
+    provider: string;
+    model: string;
+    inputTokens?: number;
+    outputTokens?: number;
+    totalTokens?: number;
+    cost?: number;
+    traceId?: string;
+    metadata?: unknown;
+}
+export declare class AiUsageRepository extends BaseTableRepository<Orm, Schema, Record<string, never>, Schema["aiUsage"]> {
+    getUsage(userId: string): ServerResultAsync<Pick<AiUsageRow, "inputTokens" | "outputTokens" | "totalTokens" | "cost">>;
+}
+export {};
+//# sourceMappingURL=ai.repository.d.ts.map

package/dist/src/modules/ai/ai.repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai.repository.d.ts","sourceRoot":"","sources":["../../../../src/modules/ai/ai.repository.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEtE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAGzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AAEpE,QAAA,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAY,CAAC;AACzB,KAAK,MAAM,GAAG,OAAO,MAAM,CAAC;AAC5B,KAAK,GAAG,GAAG,cAAc,CAAC,MAAM,CAAC,CAAC;AAElC,MAAM,MAAM,UAAU,GAAG,gBAAgB,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC;AAC7D,MAAM,MAAM,aAAa,GAAG,gBAAgB,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC;AAEhE,MAAM,WAAW,kBAAkB;IACjC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,qBAAa,iBAAkB,SAAQ,mBAAmB,CACxD,GAAG,EACH,MAAM,EACN,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,EACrB,MAAM,CAAC,SAAS,CAAC,CAClB;IACC,QAAQ,CACN,MAAM,EAAE,MAAM,GACb,iBAAiB,CAAC,IAAI,CAAC,UAAU,EAAE,aAAa,GAAG,cAAc,GAAG,aAAa,GAAG,MAAM,CAAC,CAAC;CAchG"}

package/dist/src/modules/ai/ai.repository.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AiUsageRepository = void 0;
+const tslib_1 = require("tslib");
+const drizzle_orm_1 = require("drizzle-orm");
+const neverthrow_1 = require("neverthrow");
+const ai = tslib_1.__importStar(require("#modules/ai/ai.db"));
+const base_repository_1 = require("#modules/base/base.repository");
+const schema = { ...ai };
+class AiUsageRepository extends base_repository_1.BaseTableRepository {
+    getUsage(userId) {
+        return this.throwableAsync(async () => {
+            const [usage] = await this.orm
+                .select({
+                inputTokens: (0, drizzle_orm_1.sql) `SUM(${this.table.inputTokens})`,
+                outputTokens: (0, drizzle_orm_1.sql) `SUM(${this.table.outputTokens})`,
+                totalTokens: (0, drizzle_orm_1.sql) `SUM(${this.table.totalTokens})`,
+                cost: (0, drizzle_orm_1.sql) `SUM(${this.table.cost})`,
+            })
+                .from(this.table)
+                .where((0, drizzle_orm_1.eq)(this.table.userId, userId));
+            return (0, neverthrow_1.ok)(usage);
+        });
+    }
+}
+exports.AiUsageRepository = AiUsageRepository;

package/dist/src/modules/ai/ai.router.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ai.router.d.ts.map

package/dist/src/modules/ai/ai.router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai.router.d.ts","sourceRoot":"","sources":["../../../../src/modules/ai/ai.router.ts"],"names":[],"mappings":""}

package/dist/src/modules/ai/ai.router.js

@@ -0,0 +1,132 @@
+"use strict";
+// import { openai } from "@ai-sdk/openai";
+// import { open}
+// import { withTracing } from "@posthog/ai";
+// import {
+//   appendClientMessage,
+//   appendResponseMessages,
+//   type Message,
+//   streamText,
+//   type Tool,
+// } from "ai";
+// import bodyParser from "body-parser";
+// import { and, eq } from "drizzle-orm";
+// import express, { type Response, type Router } from "express";
+// import { v4 as uuidv4 } from "uuid";
+// import type { AuthRequest, createAuthMiddleware } from "../auth/auth.middleware";
+// import { type Orm, schema } from "../db";
+// import { logger } from "../logger";
+// import { posthogClient } from "../posthog";
+Object.defineProperty(exports, "__esModule", { value: true });
+// export type Tooling = Record<
+//   string,
+//   {
+//     getMesseges: (chatId: string) => Promise<Message[]>;
+//     getTools: (chatId: string) => Promise<
+//       Record<
+//         string,
+//         {
+//           tool: Tool;
+//           handler?: (
+//             chatId: string,
+//             args: unknown,
+//             user: NonNullable<AuthRequest["user"]>
+//           ) => Promise<void>;
+//         }
+//       >
+//     >;
+//   }
+// >;
+// export function tracedOpenAiModel(
+//   model: Parameters<typeof openai>[0],
+//   clientOptions: Parameters<typeof withTracing>[2]
+// ) {
+//   return withTracing(openai(model), posthogClient, clientOptions);
+// }
+// async function getRouteSettings(id: string, name: string, settings: Tooling) {
+//   const entity = settings[name as keyof typeof settings];
+//   if (!entity) return { tools: {}, entityMesseges: [], entityTools: {} };
+//   const entityTools = await entity.getTools(id);
+//   const entityMesseges = await entity.getMesseges(id);
+//   const tools = Object.entries(entityTools).reduce<
+//     Record<string, (typeof entityTools)[keyof typeof entityTools]["tool"]>
+//   >((acc, [key, value]) => {
+//     acc[key] = value.tool as (typeof entityTools)[keyof typeof entityTools]["tool"];
+//     return acc;
+//   }, {});
+//   return { tools, entityMesseges, entityTools };
+// }
+// export function createAiRouter(
+//   orm: Orm,
+//   authMiddleware: ReturnType<typeof createAuthMiddleware>,
+//   settings: Tooling
+// ) {
+//   const aiRouter: Router = express.Router();
+//   aiRouter.use(bodyParser.json());
+//   aiRouter.post("/completion/:name", authMiddleware, async (req: AuthRequest, res: Response) => {
+//     try {
+//       const { id, message } = req.body as {
+//         id: string;
+//         message: Message;
+//       };
+//       logger.info(req.body, "body");
+//       const { name } = req.params;
+//       const user = req.user!;
+//       logger.info(message, "Received message:");
+//       const { tools, entityMesseges, entityTools } = await getRouteSettings(id, name, settings);
+//       const [chat] = await orm
+//         .select()
+//         .from(schema.chats)
+//         .where(and(eq(schema.chats.id, id), eq(schema.chats.userId, user.id)));
+//       if (!chat) throw new Error("Chat not found");
+//       const messages = appendClientMessage({
+//         messages: (chat.conversation || []) as Message[],
+//         message,
+//       });
+//       // Process any tool invocations in the message
+//       const toolInvocation = message?.parts?.find((p) => p.type === "tool-invocation");
+//       if (toolInvocation) {
+//         logger.info(toolInvocation, "Processing tool invocation:");
+//         const tool =
+//           entityTools[toolInvocation.toolInvocation.toolName as keyof typeof entityTools];
+//         if (tool?.handler) {
+//           const result = await tool.handler(id, toolInvocation.toolInvocation.args, user);
+//           logger.info({ result }, "Tool handler result:");
+//         }
+//       }
+//       logger.info([...entityMesseges, ...messages], "Processed messages");
+//       const result = streamText({
+//         model: tracedOpenAiModel("gpt-4o", {
+//           posthogDistinctId: user.id,
+//           posthogProperties: { conversation_id: id, paid: true },
+//           posthogPrivacyMode: false,
+//         }),
+//         experimental_generateMessageId: uuidv4,
+//         messages: [...entityMesseges, ...messages],
+//         async onFinish({ response }) {
+//           logger.info(response, "Final response:");
+//           try {
+//             await orm
+//               .update(schema.chats)
+//               .set({
+//                 conversation: appendResponseMessages({
+//                   messages,
+//                   responseMessages: response.messages,
+//                 }),
+//               })
+//               .where(eq(schema.chats.id, id));
+//           } catch (error) {
+//             logger.error("Error in onFinish handler:", error);
+//           }
+//         },
+//         tools,
+//       });
+//       result.consumeStream();
+//       result.pipeDataStreamToResponse(res);
+//     } catch (error) {
+//       logger.error(error, "Error in ai handler");
+//       res.status(500).send({ error: "Internal Server Error" });
+//     }
+//   });
+//   return aiRouter;
+// }