spfn 0.2.0-beta.59 → 0.2.0-beta.60

package/README.md

@@ -184,6 +184,16 @@ loaded `.env` chain.
 > `db push` is for development. For production, use `db generate` + `db migrate` to keep
 > migration history.
 
+`db push` and `db migrate` also replay migrations shipped by installed SPFN function
+packages (`@spfn/auth`, `@spfn/cms`, …) into per-package tracking tables
+(`drizzle.__spfn_fn_<pkg>_migrations`). The CLI applies these with a built-in runner
+that reads both migration layouts — drizzle-kit ≤0.31 (`NNNN_name.sql` +
+`meta/_journal.json`) and drizzle-kit 1.0 (`<timestamp>_name/migration.sql`) — so a
+package's layout never has to match the CLI's bundled drizzle version. `db push`
+validates every package's migration folder before applying the project schema, and a
+function-migration failure after a successful schema apply exits 1 with a message
+making clear the project schema was already committed.
+
 Database TLS is controlled by `DATABASE_URL`. Loopback URLs (`localhost`, `127.0.0.1`,
 and `::1`) default to `ssl: false`; add an explicit `sslmode` when the local server uses
 TLS. For a TLS connection with a self-signed certificate, set

package/dist/index.js

@@ -869,7 +869,7 @@ var init_deployment_config = __esm({
 
 // src/utils/version.ts
 function getCliVersion() {
-  return "0.2.0-beta.59";
+  return "0.2.0-beta.60";
 }
 function getTagFromVersion(version) {
   const match = version.match(/-([a-z]+)\./i);
@@ -1336,10 +1336,14 @@ var init_init = __esm({
 // src/utils/function-migrations.ts
 var function_migrations_exports = {};
 __export(function_migrations_exports, {
+  applyFunctionMigrationPlan: () => applyFunctionMigrationPlan,
   discoverFunctionMigrations: () => discoverFunctionMigrations,
-  executeFunctionMigrations: () => executeFunctionMigrations
+  executeFunctionMigrations: () => executeFunctionMigrations,
+  loadFunctionMigrationPlans: () => loadFunctionMigrationPlans,
+  readMigrationEntries: () => readMigrationEntries
 });
 import chalk13 from "chalk";
+import { createHash } from "crypto";
 import { join as join19 } from "path";
 import { env as env2 } from "@spfn/core/config";
 import { loadEnv as loadEnv2 } from "@spfn/core/server";
@@ -1385,8 +1389,75 @@ function discoverFunctionMigrations(cwd = process.cwd()) {
   }
   return functions;
 }
-async function migrateLegacyTable(db, functionMigrations) {
-  const legacyCheck = await db.execute(
+function readMigrationEntries(migrationsDir, packageName) {
+  const journalPath = join19(migrationsDir, "meta", "_journal.json");
+  return existsSync19(journalPath) ? readJournalEntries(migrationsDir, journalPath, packageName) : readFolderEntries(migrationsDir, packageName);
+}
+function loadFunctionMigrationPlans(functionMigrations) {
+  return functionMigrations.map((func) => ({
+    ...func,
+    entries: readMigrationEntries(func.migrationsDir, func.packageName)
+  }));
+}
+function readJournalEntries(migrationsDir, journalPath, packageName) {
+  let journal;
+  try {
+    journal = JSON.parse(readFileSync9(journalPath, "utf-8"));
+  } catch {
+    journal = {};
+  }
+  if (!Array.isArray(journal.entries)) {
+    throw new Error(`${packageName}: invalid migration journal at ${journalPath}`);
+  }
+  const entries = [...journal.entries];
+  entries.sort((a, b) => a.idx - b.idx);
+  return entries.map((entry) => {
+    if (typeof entry?.tag !== "string" || typeof entry?.when !== "number") {
+      throw new Error(`${packageName}: invalid journal entry in ${journalPath}`);
+    }
+    const sqlPath = join19(migrationsDir, `${entry.tag}.sql`);
+    if (!existsSync19(sqlPath)) {
+      throw new Error(`${packageName}: migration file not found: ${entry.tag}.sql`);
+    }
+    return toEntry(entry.tag, readFileSync9(sqlPath, "utf-8"), entry.when);
+  });
+}
+function readFolderEntries(migrationsDir, packageName) {
+  const folders = readdirSync2(migrationsDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name).filter((name) => existsSync19(join19(migrationsDir, name, "migration.sql"))).sort((a, b) => a.localeCompare(b));
+  return folders.map((name) => toEntry(
+    name,
+    readFileSync9(join19(migrationsDir, name, "migration.sql"), "utf-8"),
+    folderTimestampMillis(name, packageName)
+  ));
+}
+function folderTimestampMillis(name, packageName) {
+  const match = /^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})/.exec(name);
+  if (!match) {
+    throw new Error(`${packageName}: migration folder name must start with a YYYYMMDDHHMMSS timestamp: ${name}`);
+  }
+  const [, year, month, day, hour, minute, second] = match;
+  return Date.UTC(
+    Number(year),
+    Number(month) - 1,
+    Number(day),
+    Number(hour),
+    Number(minute),
+    Number(second)
+  );
+}
+function toEntry(name, content, millis) {
+  return {
+    name,
+    millis,
+    hash: createHash("sha256").update(content).digest("hex"),
+    statements: content.split("--> statement-breakpoint").map((statement) => statement.trim()).filter((statement) => statement.length > 0)
+  };
+}
+function functionMigrationsTable(packageName) {
+  return `__spfn_fn_${packageName.replace("@spfn/", "")}_migrations`;
+}
+async function migrateLegacyTable(db, plans) {
+  const legacyCheck = await db.query(
     `SELECT EXISTS (
             SELECT 1 FROM information_schema.tables
             WHERE table_schema = 'drizzle' AND table_name = '__spfn_fn_migrations'
@@ -1396,89 +1467,103 @@ async function migrateLegacyTable(db, functionMigrations) {
     return;
   }
   console.log(chalk13.dim("\n  Migrating legacy shared migration table to per-package tables..."));
-  const legacyRows = await db.execute(
+  const legacyRows = await db.query(
     `SELECT hash, created_at FROM drizzle."__spfn_fn_migrations" ORDER BY id`
   );
   if (legacyRows.length === 0) {
-    await db.execute(`DROP TABLE drizzle."__spfn_fn_migrations"`);
+    await db.query(`DROP TABLE drizzle."__spfn_fn_migrations"`);
     return;
   }
-  for (const func of functionMigrations) {
-    const journalPath = join19(func.migrationsDir, "meta", "_journal.json");
-    if (!existsSync19(journalPath)) {
-      continue;
-    }
-    const journal = JSON.parse(readFileSync9(journalPath, "utf-8"));
-    const entries = journal.entries || [];
-    const tableName = `__spfn_fn_${func.packageName.replace("@spfn/", "")}_migrations`;
-    await db.execute(
-      `CREATE SCHEMA IF NOT EXISTS drizzle`
-    );
-    await db.execute(
-      `CREATE TABLE IF NOT EXISTS drizzle."${tableName}" (
-                id serial PRIMARY KEY,
-                hash text NOT NULL,
-                created_at bigint
-            )`
-    );
-    const existing = await db.execute(
+  const legacyHashes = new Set(legacyRows.map((row) => row.hash));
+  for (const plan of plans) {
+    const tableName = functionMigrationsTable(plan.packageName);
+    await ensureMigrationsTable(db, tableName);
+    const existing = await db.query(
       `SELECT COUNT(*) AS "count" FROM drizzle."${tableName}"`
     );
     if (Number(existing[0]?.count) > 0) {
       continue;
     }
-    const { createHash } = await import("crypto");
     let copied = 0;
-    for (const entry of entries) {
-      const sqlPath = join19(func.migrationsDir, `${entry.tag}.sql`);
-      if (!existsSync19(sqlPath)) {
+    for (const entry of plan.entries) {
+      if (!legacyHashes.has(entry.hash)) {
         continue;
       }
-      const sqlContent = readFileSync9(sqlPath, "utf-8");
-      const hash = createHash("sha256").update(sqlContent).digest("hex");
-      const found = legacyRows.find((r) => r.hash === hash);
-      if (found) {
-        await db.execute(
-          `INSERT INTO drizzle."${tableName}" (hash, created_at) VALUES ('${hash}', ${entry.when})`
-        );
-        copied++;
-      }
+      await db.query(
+        `INSERT INTO drizzle."${tableName}" (hash, created_at) VALUES ($1, $2)`,
+        [entry.hash, entry.millis]
+      );
+      copied++;
     }
     if (copied > 0) {
-      console.log(chalk13.dim(`    \u2713 ${func.packageName}: copied ${copied} migration record(s)`));
+      console.log(chalk13.dim(`    \u2713 ${plan.packageName}: copied ${copied} migration record(s)`));
     }
   }
-  await db.execute(`DROP TABLE drizzle."__spfn_fn_migrations"`);
+  await db.query(`DROP TABLE drizzle."__spfn_fn_migrations"`);
   console.log(chalk13.dim("    \u2713 Legacy migration table removed\n"));
 }
-async function executeFunctionMigrations(functionMigrations) {
-  let executedCount = 0;
-  const { drizzle } = await import("drizzle-orm/postgres-js");
-  const { migrate } = await import("drizzle-orm/postgres-js/migrator");
+async function ensureMigrationsTable(db, tableName) {
+  await db.query(`CREATE SCHEMA IF NOT EXISTS drizzle`);
+  await db.query(
+    `CREATE TABLE IF NOT EXISTS drizzle."${tableName}" (
+            id serial PRIMARY KEY,
+            hash text NOT NULL,
+            created_at bigint
+        )`
+  );
+}
+async function applyFunctionMigrationPlan(db, plan) {
+  const tableName = functionMigrationsTable(plan.packageName);
+  await ensureMigrationsTable(db, tableName);
+  const rows = await db.query(
+    `SELECT created_at FROM drizzle."${tableName}" ORDER BY created_at DESC LIMIT 1`
+  );
+  const lastMillis = rows.length > 0 ? Number(rows[0]?.created_at) : Number.NEGATIVE_INFINITY;
+  const pending = plan.entries.filter((entry) => entry.millis > lastMillis);
+  if (pending.length === 0) {
+    return 0;
+  }
+  await db.transaction(async (tx) => {
+    for (const entry of pending) {
+      for (const statement of entry.statements) {
+        await tx.query(statement);
+      }
+      await tx.query(
+        `INSERT INTO drizzle."${tableName}" (hash, created_at) VALUES ($1, $2)`,
+        [entry.hash, entry.millis]
+      );
+    }
+  });
+  return pending.length;
+}
+function createPostgresJsMigrationDb(client) {
+  return {
+    query: (text, params) => client.unsafe(text, params ?? []),
+    transaction: (fn) => client.begin((tx) => fn(createPostgresJsMigrationDb(tx)))
+  };
+}
+async function executeFunctionMigrations(plans) {
   const postgres = await import("postgres");
   loadEnv2();
   if (!env2.DATABASE_URL) {
     throw new Error("DATABASE_URL not found in environment");
   }
   const connection = postgres.default(env2.DATABASE_URL, { max: 1 });
-  const db = drizzle({ client: connection });
+  const db = createPostgresJsMigrationDb(connection);
+  let appliedCount = 0;
   try {
-    await migrateLegacyTable(db, functionMigrations);
-    for (const func of functionMigrations) {
+    await migrateLegacyTable(db, plans);
+    for (const plan of plans) {
       console.log(chalk13.blue(`
-  \u{1F4E6} Running ${func.packageName} migrations...`));
-      const tableName = `__spfn_fn_${func.packageName.replace("@spfn/", "")}_migrations`;
-      await migrate(db, {
-        migrationsFolder: func.migrationsDir,
-        migrationsTable: tableName
-      });
-      console.log(chalk13.green(`  \u2713 ${func.packageName} migrations applied`));
-      executedCount++;
+  \u{1F4E6} Running ${plan.packageName} migrations...`));
+      const applied = await applyFunctionMigrationPlan(db, plan);
+      console.log(applied > 0 ? chalk13.green(`  \u2713 ${plan.packageName}: ${applied} migration(s) applied`) : chalk13.dim(`  \u2013 ${plan.packageName}: up to date`));
+      appliedCount += applied;
     }
   } finally {
     await connection.end();
   }
-  return executedCount;
+  return appliedCount;
 }
 var init_function_migrations = __esm({
   "src/utils/function-migrations.ts"() {
@@ -3039,6 +3124,7 @@ function displayApplySummary(applied, skipped) {
 }
 
 // src/commands/db/push.ts
+init_function_migrations();
 async function resolvePushPlan(imports, db, schemaFilter) {
   const { pushSchema } = await import("drizzle-kit/api-postgres");
   const { sqlStatements, hints } = await pushSchema(
@@ -3094,6 +3180,7 @@ async function dbPush(options = {}) {
     }
   }
   const schemaFilter = Array.from(detectedSchemas);
+  const functionPlans = loadFunctionPlansOrExit();
   const { db, close } = await createPushConnection();
   try {
     const { statements, hints } = await resolvePushPlan(imports, db, schemaFilter);
@@ -3102,7 +3189,7 @@ async function dbPush(options = {}) {
     }
     if (statements.length === 0) {
       console.log(chalk14.green("\u2705 No changes detected \u2014 database is up to date\n"));
-      await applyFunctionMigrations();
+      await applyFunctionMigrations(functionPlans);
       return;
     }
     const result = classifyStatements(statements);
@@ -3144,27 +3231,36 @@ async function dbPush(options = {}) {
         console.log(chalk14.dim("Tip: Use --force to apply all changes without prompting.\n"));
       }
     }
-    await applyFunctionMigrations();
+    await applyFunctionMigrations(functionPlans);
   } finally {
     await close();
   }
 }
-async function applyFunctionMigrations() {
-  const { discoverFunctionMigrations: discoverFunctionMigrations2, executeFunctionMigrations: executeFunctionMigrations2 } = await Promise.resolve().then(() => (init_function_migrations(), function_migrations_exports));
-  const functions = discoverFunctionMigrations2(process.cwd());
-  if (functions.length === 0) {
+function loadFunctionPlansOrExit() {
+  const functions = discoverFunctionMigrations(process.cwd());
+  try {
+    return loadFunctionMigrationPlans(functions);
+  } catch (error) {
+    console.error(chalk14.red("\n\u274C Invalid function package migrations \u2014 nothing was applied"));
+    console.error(chalk14.red(error instanceof Error ? error.message : "Unknown error"));
+    process.exit(1);
+  }
+}
+async function applyFunctionMigrations(plans) {
+  if (plans.length === 0) {
     return;
   }
   console.log(chalk14.blue("\n\u{1F4E6} Applying function package migrations:"));
-  functions.forEach((func) => {
-    console.log(chalk14.dim(`  - ${func.packageName}`));
+  plans.forEach((plan) => {
+    console.log(chalk14.dim(`  - ${plan.packageName}`));
   });
   try {
-    await executeFunctionMigrations2(functions);
+    await executeFunctionMigrations(plans);
     console.log(chalk14.green("\n\u2705 All function migrations applied\n"));
   } catch (error) {
-    console.error(chalk14.red("\n\u274C Failed to apply function migrations"));
+    console.error(chalk14.red("\n\u274C Failed to apply function package migrations"));
     console.error(chalk14.red(error instanceof Error ? error.message : "Unknown error"));
+    console.error(chalk14.yellow("Project schema changes (if any) were already applied \u2014 only function package migrations failed."));
     process.exit(1);
   }
 }
@@ -3571,14 +3667,14 @@ async function dbMigrate(options = {}) {
     console.error(chalk19.red("\u274C DATABASE_URL not found in environment"));
     process.exit(1);
   }
-  const { discoverFunctionMigrations: discoverFunctionMigrations2, executeFunctionMigrations: executeFunctionMigrations2 } = await Promise.resolve().then(() => (init_function_migrations(), function_migrations_exports));
+  const { discoverFunctionMigrations: discoverFunctionMigrations2, loadFunctionMigrationPlans: loadFunctionMigrationPlans2, executeFunctionMigrations: executeFunctionMigrations2 } = await Promise.resolve().then(() => (init_function_migrations(), function_migrations_exports));
   const functions = discoverFunctionMigrations2(process.cwd());
   if (functions.length > 0) {
     console.log(chalk19.blue("\u{1F4E6} Applying function package migrations:"));
     functions.forEach((func) => {
       console.log(chalk19.dim(`  - ${func.packageName}`));
     });
-    await executeFunctionMigrations2(functions);
+    await executeFunctionMigrations2(loadFunctionMigrationPlans2(functions));
     console.log(chalk19.green("\u2705 Function migrations applied\n"));
   }
   const projectMigrationsDir = join20(process.cwd(), "src/server/drizzle");
@@ -4227,13 +4323,13 @@ async function addPackage(packageName) {
       console.log(chalk27.gray("Skipping database setup. Run migrations manually when ready:\n"));
       console.log(chalk27.gray("  pnpm spfn db push\n"));
     } else {
-      const { discoverFunctionMigrations: discoverFunctionMigrations2, executeFunctionMigrations: executeFunctionMigrations2 } = await Promise.resolve().then(() => (init_function_migrations(), function_migrations_exports));
+      const { discoverFunctionMigrations: discoverFunctionMigrations2, loadFunctionMigrationPlans: loadFunctionMigrationPlans2, executeFunctionMigrations: executeFunctionMigrations2 } = await Promise.resolve().then(() => (init_function_migrations(), function_migrations_exports));
       const functions = discoverFunctionMigrations2(process.cwd());
       const targetFunction = functions.find((f) => f.packageName === packageName);
       if (targetFunction) {
         const spinner = ora11("Applying migrations...").start();
         try {
-          await executeFunctionMigrations2([targetFunction]);
+          await executeFunctionMigrations2(loadFunctionMigrationPlans2([targetFunction]));
           spinner.succeed("Migrations applied");
         } catch (error) {
           spinner.fail("Failed to apply migrations");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spfn",
-  "version": "0.2.0-beta.59",
+  "version": "0.2.0-beta.60",
   "description": "Superfunction CLI - Add SPFN to your Next.js project",
   "type": "module",
   "bin": {