@effectstream/db 0.100.10 → 0.100.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effectstream/db",
-  "version": "0.100.10",
+  "version": "0.100.12",
   "license": "MIT",
   "homepage": "https://effectstream.github.io/docs/",
   "repository": {
@@ -21,11 +21,11 @@
     "./version": "./migrations/system-version.ts"
   },
   "dependencies": {
-    "@effectstream/coroutine": "0.100.10",
-    "@effectstream/log": "0.100.10",
-    "@effectstream/runtime": "0.100.10",
-    "@effectstream/sync": "0.100.10",
-    "@effectstream/utils": "0.100.10",
+    "@effectstream/coroutine": "0.100.12",
+    "@effectstream/log": "0.100.12",
+    "@effectstream/runtime": "0.100.12",
+    "@effectstream/sync": "0.100.12",
+    "@effectstream/utils": "0.100.12",
     "@electric-sql/pglite": "^0.3.14",
     "@pgtyped/runtime": "2.4.2",
     "@pgtyped/parser": "2.4.2",

package/scripts/pgtyped-update.ts

@@ -1,119 +1,150 @@
 #!/usr/bin/env bun
 /**
- * Runs database startup and pgtyped generation concurrently
+ * Starts PGLite, applies system + user migrations, runs pgtyped codegen.
  */
 
 import { spawn } from "node:child_process";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
+import { resolve } from "node:path";
+import { existsSync } from "node:fs";
 
-const __dirname = dirname(import.meta.url?.startsWith("file:") ? fileURLToPath(import.meta.url) : import.meta.url.replace("file://", ""));
-
-interface ProcessInfo {
-  name: string;
-  command: string;
-  args: string[];
-  wait: boolean;
-}
+import pg from "pg";
+import { startPglite, type PgliteHandle } from "./start-pglite.ts";
+import { waitForDb } from "./wait-for-db.ts";
+import { applyMigrations } from "./apply-migrations.ts";
+import { getConnection } from "../src/pg-connection.ts";
+import { getMigrations } from "../migrations/system-version.ts";
 
 function createPrefix(name: string): string {
-  const colors = {
-    "db:up": "\x1b[36m", // cyan
-    "pgtyped:internal": "\x1b[33m", // yellow
+  const colors: Record<string, string> = {
+    "db:up": "\x1b[36m",
+    "user-migrations": "\x1b[35m",
+    "pgtyped": "\x1b[33m",
   };
   const reset = "\x1b[0m";
-  const color = colors[name as keyof typeof colors] || "\x1b[37m"; // white
+  const color = colors[name] || "\x1b[37m";
   return `${color}[${name}]${reset} `;
 }
 
-async function runProcess(processInfo: ProcessInfo): Promise<void> {
-  const prefix = createPrefix(processInfo.name);
+export interface UserMigration {
+  name: string;
+  sql: string;
+}
 
-  console.log(`${prefix}Starting...`);
+export interface PgtypedUpdateOptions {
+  userMigrations?: UserMigration[];
+  pgtypedConfigPath?: string;
+  pgtypedBin?: string;
+}
+
+async function resolveUserMigrations(): Promise<UserMigration[]> {
+  const candidates = [
+    resolve(process.cwd(), "migration-order.ts"),
+    resolve(process.cwd(), "src/migration-order.ts"),
+  ];
 
-  const child = spawn(processInfo.command, processInfo.args, {
-    stdio: ["inherit", "pipe", "pipe"],
-    shell: processInfo.command === "npx",
+  const migrationFile = candidates.find((p) => existsSync(p));
+  if (!migrationFile) return [];
+
+  const mod = await import(migrationFile);
+  return mod.migrationTable ?? [];
+}
+
+async function applyUserMigrations(migrations: UserMigration[]): Promise<void> {
+  const prefix = createPrefix("user-migrations");
+
+  if (migrations.length === 0) {
+    console.log(`${prefix}No user migrations to apply, skipping`);
+    return;
+  }
+
+  const client = new pg.Client({
+    host: "localhost",
+    port: 5432,
+    user: "postgres",
+    database: "postgres",
   });
+  await client.connect();
+
+  try {
+    for (const migration of migrations) {
+      console.log(`${prefix}Applying ${migration.name}`);
+      await client.query(migration.sql);
+    }
+    console.log(`${prefix}✅ Applied ${migrations.length} user migration(s)`);
+  } finally {
+    await client.end();
+  }
+}
+
+async function applySystemMigrations(): Promise<void> {
+  const prefix = createPrefix("apply-migrations");
+  const db = getConnection();
+  const migrations = await getMigrations();
+  for (const migration of migrations) {
+    await applyMigrations(db as any, 0, migration.version, migration.sql, true);
+  }
+  console.log(`${prefix}✅ System migrations applied`);
+  await db.end();
+}
+
+async function runPgtyped(pgtypedBin: string, pgtypedConfigPath: string): Promise<void> {
+  const prefix = createPrefix("pgtyped");
+  console.log(`${prefix}Starting...`);
+
+  return new Promise((resolve, reject) => {
+    const child = spawn("node", [pgtypedBin, "-c", pgtypedConfigPath], {
+      stdio: ["ignore", "pipe", "pipe"],
+      shell: false,
+    });
 
-  const stdoutPromise = new Promise<void>((resolve) => {
     child.stdout?.on("data", (chunk: Buffer | string) => {
-      const text = chunk.toString();
-      text.split("\n").forEach((line) => {
+      chunk.toString().split("\n").forEach((line) => {
         if (line.trim()) console.log(`${prefix}${line}`);
       });
     });
-    child.stdout?.on("end", resolve);
-    if (!child.stdout) resolve();
-  });
 
-  const stderrPromise = new Promise<void>((resolve) => {
     child.stderr?.on("data", (chunk: Buffer | string) => {
-      const text = chunk.toString();
-      text.split("\n").forEach((line) => {
+      chunk.toString().split("\n").forEach((line) => {
         if (line.trim()) console.error(`${prefix}${line}`);
       });
     });
-    child.stderr?.on("end", resolve);
-    if (!child.stderr) resolve();
-  });
 
-  const exitCode = new Promise<number | null>((resolve) => {
-    child.on("close", (code) => resolve(code));
+    child.on("close", (code) => {
+      if (code === 0) {
+        console.log(`${prefix}✅ Completed successfully`);
+        resolve();
+      } else {
+        reject(new Error(`pgtyped failed with exit code ${code}`));
+      }
+    });
   });
-
-  if (processInfo.wait) {
-    const [code] = await Promise.all([exitCode, stdoutPromise, stderrPromise]);
-    if (code === 0) {
-      console.log(`${prefix}✅ Completed successfully`);
-    } else {
-      console.error(`${prefix}❌ Failed with exit code ${code}`);
-      throw new Error(`Process ${processInfo.name} failed`);
-    }
-  }
 }
 
-async function main() {
-  const processes: ProcessInfo[] = [
-    {
-      name: "db:up",
-      command: "bun",
-      args: ["run", join(__dirname, "start-pglite.ts")],
-      wait: false,
-    },
-    {
-      name: "db:wait",
-      command: "bun",
-      args: ["run", join(__dirname, "wait-for-db.ts")],
-      wait: true,
-    },
-    {
-      name: "apply-migrations",
-      command: "bun",
-      args: ["run", join(__dirname, "apply-migrations.ts")],
-      wait: true,
-    },
-    {
-      name: "pgtyped",
-      command: "npx",
-      args: ["pgtyped", "-c", "./pgtypedconfig.json"],
-      wait: true,
-    },
-  ];
+export async function main(options?: PgtypedUpdateOptions) {
+  const userMigrations = options?.userMigrations ?? await resolveUserMigrations();
+  const pgtypedConfigPath = options?.pgtypedConfigPath ?? "./pgtypedconfig.json";
+  const pgtypedBin = options?.pgtypedBin ?? resolve(process.cwd(), "node_modules/@paima/pgtyped-cli/lib/index.js");
 
-  console.log("🚀 Starting concurrent processes...\n");
+  console.log("🚀 Starting pgtyped-update...\n");
 
+  let pglite: PgliteHandle | undefined;
   try {
-    for (const process of processes) {
-      await runProcess(process);
-    }
-    console.log("\n✅ All processes completed successfully");
-  } catch (error) {
-    console.error("\n❌ One or more processes failed:", error);
-    process.exit(1);
+    pglite = await startPglite();
+    await waitForDb();
+    await applySystemMigrations();
+    await applyUserMigrations(userMigrations);
+    await runPgtyped(pgtypedBin, pgtypedConfigPath);
+    console.log("\n✅ All steps completed successfully");
+  } finally {
+    await pglite?.close();
   }
 }
 
 if (import.meta.main) {
-  await main();
+  try {
+    await main();
+  } catch (error) {
+    console.error("\n❌ One or more steps failed:", error);
+    process.exit(1);
+  }
 }

package/scripts/start-pglite.ts

@@ -7,35 +7,30 @@ import { fromNodeSocket } from "pg-gateway/node";
 import { ENV } from "@effectstream/utils/node-env";
 import { args, cwd } from "@effectstream/utils/runtime";
 
-// TODO PORT be a ENV variable
-// Get port from arguments.
-const portArgName = "--port";
-const argv = args();
-const portArgIndex = argv.indexOf(portArgName);
-const portValue = portArgIndex !== -1 ? argv[portArgIndex + 1] : "5432";
-const port = parseInt(portValue);
-if (isNaN(port)) {
-  throw new Error(`Port argument ${portArgName} is not a number`);
+export interface PgliteHandle {
+  server: net.Server;
+  db: PGlite;
+  close: () => Promise<void>;
 }
 
-// Resolve pg_ivm extension path via import.meta.resolve (works with bun's hoisting)
-const pgliteEntry = import.meta.resolve("@electric-sql/pglite");
-const pgliteDir = pgliteEntry.replace(/\/dist\/[^/]+$/, "");
-const pgIvmUrl = new URL(`${pgliteDir}/dist/pg_ivm.tar.gz`);
+export async function startPglite(port = 5432): Promise<PgliteHandle> {
+  // Resolve pg_ivm extension path via import.meta.resolve (works with bun's hoisting)
+  const pgliteEntry = import.meta.resolve("@electric-sql/pglite");
+  const pgliteDir = pgliteEntry.replace(/\/dist\/[^/]+$/, "");
+  const pgIvmUrl = new URL(`${pgliteDir}/dist/pg_ivm.tar.gz`);
 
-const db = new PGlite(
-  ENV.PGLITE_DATA_DIR,
-  {
-    username: ENV.DB_USER,
-    database: ENV.DB_NAME,
-    extensions: {
-      pg_ivm: pgIvmUrl,
+  const db = new PGlite(
+    ENV.PGLITE_DATA_DIR,
+    {
+      username: ENV.DB_USER,
+      database: ENV.DB_NAME,
+      extensions: {
+        pg_ivm: pgIvmUrl,
+      },
+      debug: (ENV.DEBUG_PGLITE as DebugLevel) || 0,
     },
-    debug: (ENV.DEBUG_PGLITE as DebugLevel) || 0,
-  },
-);
+  );
 
-{
   // TODO: consider switching to pglite-socket once it works
   //       https://discord.com/channels/933657521581858818/1371976702674075780/1371992712076595250
   const server = net.createServer(async (socket) => {
@@ -65,7 +60,33 @@ const db = new PGlite(
     });
   });
 
-  server.listen(port, () => {
-    console.info(`database: server listening on port ${port}`);
+  await new Promise<void>((resolve) => {
+    server.listen(port, () => {
+      console.info(`database: server listening on port ${port}`);
+      resolve();
+    });
   });
+
+  return {
+    server,
+    db,
+    close: async () => {
+      server.close();
+      await db.close();
+    },
+  };
+}
+
+if (import.meta.main) {
+  // TODO PORT be a ENV variable
+  // Get port from arguments.
+  const portArgName = "--port";
+  const argv = args();
+  const portArgIndex = argv.indexOf(portArgName);
+  const portValue = portArgIndex !== -1 ? argv[portArgIndex + 1] : "5432";
+  const port = parseInt(portValue);
+  if (isNaN(port)) {
+    throw new Error(`Port argument ${portArgName} is not a number`);
+  }
+  await startPglite(port);
 }