feat: migrate from PocketBase to PostgreSQL with Drizzle ORM

- Add @project-e/db package with Drizzle schema and migrations - Replace PocketBase client with PostgreSQL-based database client - Migrate auth from custom to NextAuth.js - Add Docker Compose with PostgreSQL container - Update worker to use new database client - Remove PocketBase-specific files and migrations - Add drizzle config and initial migration
2026-07-24 07:08:29 -04:00
parent 6c438eab32
commit 73335484f8
42 changed files with 2895 additions and 2796 deletions
@@ -0,0 +1,154 @@
+import { and, eq } from 'drizzle-orm';
+import { db, records, sql } from '@project-e/db';
+
+export const collectionNames = [
+  'domains', 'tags', 'projects', 'project_settings', 'milestones',
+  'milestone_dependencies', 'milestone_templates', 'milestone_history', 'tasks',
+  'task_subtasks', 'task_dependencies', 'task_attachments', 'task_time_entries',
+  'time_entries', 'habits', 'habit_logs', 'habit_skip_days', 'notes', 'note_links',
+  'note_task_links', 'report_templates', 'reports', 'canvases', 'canvas_cards',
+  'agents', 'agent_activity', 'webhooks', 'webhook_deliveries', 'agent_tasks',
+  'notifications', 'error_logs', 'queue_jobs',
+] as const;
+
+type RecordData = Record<string, any>;
+type ListOptions = { filter?: string; sort?: string };
+
+function serialize(record: typeof records.$inferSelect): RecordData {
+  return {
+    ...record.data,
+    id: record.id,
+    created: record.createdAt.toISOString(),
+    updated: record.updatedAt.toISOString(),
+    collectionName: record.collection,
+  };
+}
+
+function valueFor(record: RecordData, field: string): unknown {
+  if (field === 'id' || field === 'created' || field === 'updated') return record[field];
+  return record[field];
+}
+
+function parseValue(raw: string): unknown {
+  const value = raw.trim();
+  if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+    return value.slice(1, -1).replace(/\\"/g, '"');
+  }
+  if (value === 'true') return true;
+  if (value === 'false') return false;
+  if (value === 'null') return null;
+  const number = Number(value);
+  return Number.isNaN(number) ? value : number;
+}
+
+function matchesFilter(record: RecordData, filter?: string): boolean {
+  if (!filter) return true;
+
+  return filter.split('||').some((orPart) => orPart.split('&&').every((term) => {
+    const match = term.trim().match(/^([a-zA-Z_][\w]*)\s*(=|!=|<=|>=|<|>)\s*(.+)$/);
+    if (!match) return false;
+    const [, field, operator, rawExpected] = match;
+    const actual = valueFor(record, field);
+    const expected = parseValue(rawExpected);
+
+    switch (operator) {
+      case '=': return actual === expected;
+      case '!=': return actual !== expected;
+      case '<': return String(actual ?? '') < String(expected ?? '');
+      case '<=': return String(actual ?? '') <= String(expected ?? '');
+      case '>': return String(actual ?? '') > String(expected ?? '');
+      case '>=': return String(actual ?? '') >= String(expected ?? '');
+      default: return false;
+    }
+  }));
+}
+
+function sortRecords(items: RecordData[], sort?: string): RecordData[] {
+  if (!sort) return items;
+  const descending = sort.startsWith('-');
+  const field = descending ? sort.slice(1) : sort;
+  return [...items].sort((a, b) => {
+    const left = valueFor(a, field);
+    const right = valueFor(b, field);
+    const comparison = String(left ?? '').localeCompare(String(right ?? ''), undefined, { numeric: true });
+    return descending ? -comparison : comparison;
+  });
+}
+
+function cleanData(data: RecordData): RecordData {
+  const { id: _id, created: _created, updated: _updated, collectionId: _collectionId, collectionName: _collectionName, ...clean } = data;
+  return clean;
+}
+
+async function notify(action: 'create' | 'update' | 'delete', collection: string, record: RecordData) {
+  await sql`select pg_notify('project_e_events', ${JSON.stringify({ type: action, collection, record })})`;
+}
+
+class CollectionRepository {
+  constructor(private readonly collectionName: string) {}
+
+  async getOne(id: string): Promise<RecordData> {
+    const [record] = await db.select().from(records).where(and(eq(records.id, id), eq(records.collection, this.collectionName))).limit(1);
+    if (!record) throw new Error(`Record ${id} not found in ${this.collectionName}`);
+    return serialize(record);
+  }
+
+  async getFullList(options: ListOptions = {}): Promise<RecordData[]> {
+    const rows = await db.select().from(records).where(eq(records.collection, this.collectionName));
+    return sortRecords(rows.map(serialize).filter((record) => matchesFilter(record, options.filter)), options.sort);
+  }
+
+  async getList(page = 1, perPage = 50, options: ListOptions = {}) {
+    const items = await this.getFullList(options);
+    const totalItems = items.length;
+    const totalPages = Math.max(1, Math.ceil(totalItems / perPage));
+    return {
+      items: items.slice((page - 1) * perPage, page * perPage),
+      page,
+      perPage,
+      totalItems,
+      totalPages,
+    };
+  }
+
+  async create(data: RecordData): Promise<RecordData> {
+    const [record] = await db.insert(records).values({ collection: this.collectionName, data: cleanData(data) }).returning();
+    const result = serialize(record);
+    await notify('create', this.collectionName, result);
+    return result;
+  }
+
+  async update(id: string, data: RecordData): Promise<RecordData> {
+    const existing = await this.getOne(id);
+    const [record] = await db.update(records)
+      .set({ data: cleanData({ ...existing, ...data }), updatedAt: new Date() })
+      .where(and(eq(records.id, id), eq(records.collection, this.collectionName)))
+      .returning();
+    if (!record) throw new Error(`Record ${id} not found in ${this.collectionName}`);
+    const result = serialize(record);
+    await notify('update', this.collectionName, result);
+    return result;
+  }
+
+  async delete(id: string): Promise<boolean> {
+    const existing = await this.getOne(id);
+    await db.delete(records).where(and(eq(records.id, id), eq(records.collection, this.collectionName)));
+    await notify('delete', this.collectionName, existing);
+    return true;
+  }
+}
+
+export function createDatabaseClient() {
+  return {
+    collection(name: string) {
+      if (!collectionNames.includes(name as (typeof collectionNames)[number])) {
+        throw new Error(`Unknown collection: ${name}`);
+      }
+      return new CollectionRepository(name);
+    },
+  };
+}
+
+export function createAdminClient() {
+  return createDatabaseClient();
+}