Add Drizzle ORM with shared db package (#10)

apps/planner/app/lib/db.ts

@@ -1,23 +1,10 @@
-import postgres from "postgres";
+import { createDb, type Database } from "@trails-cool/db";
 
-const connectionString =
-  process.env.DATABASE_URL ?? "postgres://trails:trails@localhost:5432/trails";
+let _db: Database | null = null;
 
-export const sql = postgres(connectionString);
-
-export async function initDb() {
-  await sql`
-    CREATE SCHEMA IF NOT EXISTS planner
-  `;
-  await sql`
-    CREATE TABLE IF NOT EXISTS planner.sessions (
-      id TEXT PRIMARY KEY,
-      yjs_state BYTEA,
-      callback_url TEXT,
-      callback_token TEXT,
-      created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-      last_activity TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-      closed BOOLEAN NOT NULL DEFAULT FALSE
-    )
-  `;
+export function getDb(): Database {
+  if (!_db) {
+    _db = createDb();
+  }
+  return _db;
 }

apps/planner/app/lib/sessions.ts

@@ -1,16 +1,11 @@
 import { randomUUID } from "node:crypto";
 import * as Y from "yjs";
+import { eq, and, desc, lt } from "drizzle-orm";
 import { getOrCreateDoc, deleteDoc } from "./yjs-server";
-import { sql } from "./db";
+import { getDb } from "./db";
+import { sessions } from "@trails-cool/db/schema/planner";
 
-export interface SessionMetadata {
-  id: string;
-  createdAt: Date;
-  lastActivity: Date;
-  callbackUrl?: string;
-  callbackToken?: string;
-  closed: boolean;
-}
+export type SessionMetadata = typeof sessions.$inferSelect;
 
 export async function createSession(options?: {
   callbackUrl?: string;
@@ -19,52 +14,60 @@ export async function createSession(options?: {
   const id = randomUUID();
   const doc = getOrCreateDoc(id);
 
-  const [row] = await sql`
-    INSERT INTO planner.sessions (id, yjs_state, callback_url, callback_token)
-    VALUES (${id}, ${Buffer.from(Y.encodeStateAsUpdate(doc))}, ${options?.callbackUrl ?? null}, ${options?.callbackToken ?? null})
-    RETURNING id, created_at, last_activity, callback_url, callback_token, closed
-  `;
+  const [row] = await getDb()
+    .insert(sessions)
+    .values({
+      id,
+      yjsState: Buffer.from(Y.encodeStateAsUpdate(doc)),
+      callbackUrl: options?.callbackUrl,
+      callbackToken: options?.callbackToken,
+    })
+    .returning();
 
-  return mapRow(row);
+  return row!;
 }
 
 export async function getSession(id: string): Promise<SessionMetadata | undefined> {
-  const [row] = await sql`
-    SELECT id, created_at, last_activity, callback_url, callback_token, closed
-    FROM planner.sessions
-    WHERE id = ${id} AND closed = FALSE
-  `;
-  return row ? mapRow(row) : undefined;
+  const [row] = await getDb()
+    .select()
+    .from(sessions)
+    .where(and(eq(sessions.id, id), eq(sessions.closed, false)));
+
+  return row;
 }
 
 export async function touchSession(id: string): Promise<void> {
-  await sql`
-    UPDATE planner.sessions SET last_activity = NOW() WHERE id = ${id}
-  `;
+  await getDb()
+    .update(sessions)
+    .set({ lastActivity: new Date() })
+    .where(eq(sessions.id, id));
 }
 
 export async function saveSessionState(id: string): Promise<void> {
   const doc = getOrCreateDoc(id);
   const state = Y.encodeStateAsUpdate(doc);
-  await sql`
-    UPDATE planner.sessions
-    SET yjs_state = ${Buffer.from(state)}, last_activity = NOW()
-    WHERE id = ${id}
-  `;
+  await getDb()
+    .update(sessions)
+    .set({ yjsState: Buffer.from(state), lastActivity: new Date() })
+    .where(eq(sessions.id, id));
 }
 
 export async function loadSessionState(id: string): Promise<Uint8Array | null> {
-  const [row] = await sql`
-    SELECT yjs_state FROM planner.sessions WHERE id = ${id}
-  `;
-  return row?.yjs_state ? new Uint8Array(row.yjs_state) : null;
+  const [row] = await getDb()
+    .select({ yjsState: sessions.yjsState })
+    .from(sessions)
+    .where(eq(sessions.id, id));
+
+  return row?.yjsState ? new Uint8Array(row.yjsState) : null;
 }
 
 export async function closeSession(id: string): Promise<boolean> {
-  const result = await sql`
-    UPDATE planner.sessions SET closed = TRUE WHERE id = ${id} AND closed = FALSE
-    RETURNING id
-  `;
+  const result = await getDb()
+    .update(sessions)
+    .set({ closed: true })
+    .where(and(eq(sessions.id, id), eq(sessions.closed, false)))
+    .returning({ id: sessions.id });
+
   deleteDoc(id);
   return result.length > 0;
 }
@@ -88,35 +91,22 @@ export function initializeSessionWithWaypoints(
 }
 
 export async function listSessions(): Promise<SessionMetadata[]> {
-  const rows = await sql`
-    SELECT id, created_at, last_activity, callback_url, callback_token, closed
-    FROM planner.sessions
-    WHERE closed = FALSE
-    ORDER BY last_activity DESC
-  `;
-  return rows.map(mapRow);
+  return getDb()
+    .select()
+    .from(sessions)
+    .where(eq(sessions.closed, false))
+    .orderBy(desc(sessions.lastActivity));
 }
 
 export async function expireSessions(maxAgeDays: number = 7): Promise<number> {
-  const result = await sql`
-    DELETE FROM planner.sessions
-    WHERE last_activity < NOW() - INTERVAL '1 day' * ${maxAgeDays}
-    RETURNING id
-  `;
+  const cutoff = new Date(Date.now() - maxAgeDays * 24 * 60 * 60 * 1000);
+  const result = await getDb()
+    .delete(sessions)
+    .where(lt(sessions.lastActivity, cutoff))
+    .returning({ id: sessions.id });
+
   for (const row of result) {
     deleteDoc(row.id);
   }
   return result.length;
 }
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function mapRow(row: any): SessionMetadata {
-  return {
-    id: row.id as string,
-    createdAt: row.created_at as Date,
-    lastActivity: row.last_activity as Date,
-    callbackUrl: (row.callback_url as string) ?? undefined,
-    callbackToken: (row.callback_token as string) ?? undefined,
-    closed: row.closed as boolean,
-  };
-}

apps/planner/package.json

@@ -13,13 +13,14 @@
   "dependencies": {
     "@react-router/node": "catalog:",
     "@react-router/serve": "catalog:",
+    "@trails-cool/db": "workspace:*",
     "@trails-cool/gpx": "workspace:*",
     "@trails-cool/i18n": "workspace:*",
     "@trails-cool/map": "workspace:*",
     "@trails-cool/types": "workspace:*",
     "@trails-cool/ui": "workspace:*",
+    "drizzle-orm": "catalog:",
     "isbot": "^5.1.0",
-    "postgres": "^3.4.8",
     "react": "catalog:",
     "react-dom": "catalog:",
     "react-router": "catalog:",