@voscarmv/aimessagestore 1.0.3

package/src/schema.ts

@@ -0,0 +1,10 @@
+import { boolean, bigint, timestamp, text, pgTable, varchar } from "drizzle-orm/pg-core";
+
+export const messages = pgTable("messages", {
+  id: bigint({ mode: 'number' }).primaryKey().generatedAlwaysAsIdentity(),
+  user_id: varchar({ length: 255 }).notNull(),
+  message: text().notNull(),
+  queued: boolean().notNull(),
+  created_at: timestamp('created_at').notNull().defaultNow(),
+  updated_at: timestamp('updated_at').notNull().defaultNow()
+});

package/src/server.ts

@@ -0,0 +1,121 @@
+import express, { type Request, type Response, type Express } from "express";
+import { type CorsOptions } from "cors";
+import { drizzle, NodePgDatabase } from "drizzle-orm/node-postgres";
+import { messages } from './schema.js';
+import { migrate } from 'drizzle-orm/node-postgres/migrator';
+import cors from "cors";
+import helmet from "helmet";
+import morgan from "morgan";
+import { and, asc, eq, sql } from "drizzle-orm";
+
+export interface StoreBackend {
+    migrate: () => void;
+    listen: () => void;
+};
+
+export type MessageStoreBackendParams = {
+    dbUrl: string,
+    port: number,
+    corsOpts?: CorsOptions,
+};
+
+export class AiMessageStoreBackend implements StoreBackend {
+    #db: NodePgDatabase<Record<string, never>>;
+    #app: Express;
+    #port: number;
+    constructor(params: MessageStoreBackendParams) {
+        this.#db = drizzle(params.dbUrl);
+        this.#app = express();
+        if (params.corsOpts) {
+            this.#app.use(cors(params.corsOpts));
+        } else {
+            this.#app.use(cors());
+        }
+        this.#app.use(helmet());
+        this.#app.use(morgan("combined"));
+        this.#app.use(express.json());
+        this.#port = params.port;
+        type CreateMessageBody = {
+            user_id: string;
+            queued: boolean;
+            msgs: string[];
+        };
+        this.#app.post(
+            "/messages",
+            async (req: Request<{}, {}, CreateMessageBody>, res: Response) => {
+                try {
+                    const { user_id, queued, msgs } = req.body;
+                    const response: { message: string }[] = await this.#db
+                        .insert(messages)
+                        .values(msgs.map((msg) => (
+                            {
+                                user_id,
+                                queued,
+                                message: msg
+                            }
+                        )))
+                        .returning({ message: messages.message });
+                    res.json(response.map(item => item.message));
+                } catch (err) {
+                    res.status(500).json({ error: String(err) });
+                }
+            }
+        );
+        this.#app.get(
+            "/messages/:user_id",
+            async (req: Request<{ user_id: string }>, res: Response) => {
+                try {
+                    const response: { message: string }[] = await this.#db
+                        .select({ message: messages.message })
+                        .from(messages)
+                        .where(eq(messages.user_id, req.params.user_id))
+                        .orderBy(asc(messages.updated_at), asc(messages.id));
+                    res.json(response.map(item => item.message));
+                } catch (err) {
+                    res.status(500).json({ error: String(err) });
+                }
+            }
+        );
+        this.#app.get(
+            "/messages/:user_id/queued",
+            async (req: Request<{ user_id: string }>, res: Response) => {
+                try {
+                    const response: { message: string }[] = await this.#db
+                        .select({ message: messages.message })
+                        .from(messages)
+                        .where(
+                            and(
+                                eq(messages.queued, true),
+                                eq(messages.user_id, req.params.user_id)
+                            ));
+                    res.json(response.map(item => item.message));
+                } catch (err) {
+                    res.status(500).json({ error: String(err) });
+                }
+            }
+        );
+        this.#app.put(
+            "/messages/:user_id/unqueue",
+            async (req: Request<{ user_id: string }>, res: Response) => {
+                try {
+                    const response: { message: string }[] = await this.#db
+                        .update(messages)
+                        .set({ queued: false, updated_at: sql`now()` })
+                        .where(eq(messages.user_id, req.params.user_id))
+                        .returning({ message: messages.message });
+                    res.json(response.map(item => item.message));
+                } catch (err) {
+                    res.status(500).json({ error: String(err) });
+                }
+            }
+        );
+    }
+    async migrate() {
+        await migrate(this.#db, { migrationsFolder: './dist/drizzle' });
+        return;
+    }
+    listen() {
+        this.#app.listen(this.#port);
+        return;
+    }
+}

package/tsconfig.json

@@ -0,0 +1,45 @@
+{
+  // Visit https://aka.ms/tsconfig to read more about this file
+  "compilerOptions": {
+    // File Layout
+    "rootDir": "./src",
+    "outDir": "./dist",
+
+    // Environment Settings
+    // See also https://aka.ms/tsconfig/module
+    "module": "nodenext",
+    "target": "esnext",
+    "types": [],
+    // For nodejs:
+    // "lib": ["esnext"],
+    // "types": ["node"],
+    // and npm install -D @types/node
+
+    // Other Outputs
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true,
+
+    // Stricter Typechecking Options
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+
+    // Style Options
+    // "noImplicitReturns": true,
+    // "noImplicitOverride": true,
+    // "noUnusedLocals": true,
+    // "noUnusedParameters": true,
+    // "noFallthroughCasesInSwitch": true,
+    // "noPropertyAccessFromIndexSignature": true,
+
+    // Recommended Options
+    "strict": true,
+    "jsx": "react-jsx",
+    "verbatimModuleSyntax": true,
+    "isolatedModules": true,
+    "noUncheckedSideEffectImports": true,
+    "moduleDetection": "force",
+    "skipLibCheck": true,
+  },
+  "include": ["src"]
+}