@spfn/core 0.2.0-beta.71 → 0.2.0-beta.72

package/dist/db/index.js

@@ -5,13 +5,13 @@ import net from 'net';
 import postgres from 'postgres';
 import { QueryError, ConnectionError, DeadlockError, TransactionError, ConstraintViolationError, DuplicateEntryError, DatabaseError } from '@spfn/core/errors';
 import { parseNumber, parseBoolean } from '@spfn/core/env';
-import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
+import { existsSync, readdirSync, readFileSync, statSync } from 'fs';
 import { join, dirname, basename } from 'path';
 import { bigserial, timestamp, bigint, uuid as uuid$1, text, jsonb, pgSchema } from 'drizzle-orm/pg-core';
+import { createHash, randomUUID } from 'crypto';
+import { sql, count as count$1, lt, gt, and, desc, asc, eq } from 'drizzle-orm';
 import { AsyncLocalStorage } from 'async_hooks';
 import { createMiddleware } from 'hono/factory';
-import { randomUUID } from 'crypto';
-import { sql, count as count$1, lt, gt, and, desc, asc, eq } from 'drizzle-orm';
 
 // src/db/manager/factory.ts
 function parseUniqueViolation(message) {
@@ -1548,6 +1548,200 @@ function getSchemaInfo(packageName) {
     scope
   };
 }
+var discoveryLogger = logger.child("@spfn/core:migrations");
+function functionMigrationsTable(packageName) {
+  return `__spfn_fn_${packageName.replace("@spfn/", "")}_migrations`;
+}
+function discoverFunctionMigrations(cwd = process.cwd()) {
+  const spfnDir = join(cwd, "node_modules", "@spfn");
+  if (!existsSync(spfnDir)) {
+    return [];
+  }
+  const functions = [];
+  for (const pkg of readdirSync(spfnDir)) {
+    const packagePath = join(spfnDir, pkg);
+    const packageJsonPath = join(packagePath, "package.json");
+    if (!existsSync(packageJsonPath)) {
+      continue;
+    }
+    try {
+      const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+      const migrationsConfig = packageJson.spfn?.migrations;
+      if (!migrationsConfig) {
+        continue;
+      }
+      const migrationsDir = join(packagePath, migrationsConfig.dir);
+      if (!existsSync(migrationsDir)) {
+        discoveryLogger.warn(
+          `@spfn/${pkg} declares migrations but the directory is missing: ${migrationsDir}`
+        );
+        continue;
+      }
+      functions.push({ packageName: `@spfn/${pkg}`, migrationsDir, packagePath });
+    } catch {
+      discoveryLogger.warn(`Failed to parse package.json for @spfn/${pkg}`);
+    }
+  }
+  return functions;
+}
+function readMigrationEntries(migrationsDir, packageName) {
+  const journalPath = join(migrationsDir, "meta", "_journal.json");
+  return existsSync(journalPath) ? readJournalEntries(migrationsDir, journalPath, packageName) : readFolderEntries(migrationsDir, packageName);
+}
+function readJournalEntries(migrationsDir, journalPath, packageName) {
+  let journal;
+  try {
+    journal = JSON.parse(readFileSync(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 = join(migrationsDir, `${entry.tag}.sql`);
+    if (!existsSync(sqlPath)) {
+      throw new Error(`${packageName}: migration file not found: ${entry.tag}.sql`);
+    }
+    return toEntry(entry.tag, readFileSync(sqlPath, "utf-8"), entry.when);
+  });
+}
+function readFolderEntries(migrationsDir, packageName) {
+  const folders = readdirSync(migrationsDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name).filter((name) => existsSync(join(migrationsDir, name, "migration.sql"))).sort((a, b) => a.localeCompare(b));
+  return folders.map((name) => toEntry(
+    name,
+    readFileSync(join(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)
+  };
+}
+var PROJECT_MIGRATIONS_TABLE = "__drizzle_migrations";
+var PROJECT_TARGET_NAME = "project (src/server/drizzle)";
+function filterPendingEntries(entries, lastAppliedMillis, appliedNames) {
+  return entries.filter((entry) => entry.millis > lastAppliedMillis && !appliedNames.has(entry.name));
+}
+function migrationTargets(status) {
+  return [...status.packages, ...status.project ? [status.project] : []];
+}
+function pendingMigrationTargets(status) {
+  return migrationTargets(status).filter((target) => target.pending > 0);
+}
+function countPendingMigrations(status) {
+  return migrationTargets(status).reduce((sum, target) => sum + target.pending, 0);
+}
+function toRows(result) {
+  if (Array.isArray(result)) {
+    return result;
+  }
+  const rows = result?.rows;
+  return Array.isArray(rows) ? rows : [];
+}
+async function tableExists(db, tableName) {
+  const rows = toRows(await db.execute(sql`
+        SELECT EXISTS (
+            SELECT 1 FROM information_schema.tables
+            WHERE table_schema = 'drizzle' AND table_name = ${tableName}
+        ) AS "exists"`));
+  return rows[0]?.exists === true;
+}
+async function readAppliedNames(db, tableName) {
+  const columnRows = toRows(await db.execute(sql`
+        SELECT EXISTS (
+            SELECT 1 FROM information_schema.columns
+            WHERE table_schema = 'drizzle' AND table_name = ${tableName} AND column_name = 'name'
+        ) AS "exists"`));
+  if (columnRows[0]?.exists !== true) {
+    return /* @__PURE__ */ new Set();
+  }
+  const rows = toRows(await db.execute(sql`
+        SELECT name FROM drizzle.${sql.identifier(tableName)} WHERE name IS NOT NULL`));
+  return new Set(rows.map((row) => String(row.name)));
+}
+async function collectTargetStatus(db, name, migrationsDir, tableName) {
+  const entries = readMigrationEntries(migrationsDir, name);
+  let lastApplied = 0;
+  let appliedNames = /* @__PURE__ */ new Set();
+  if (await tableExists(db, tableName)) {
+    const rows = toRows(await db.execute(sql`
+            SELECT created_at FROM drizzle.${sql.identifier(tableName)}
+            ORDER BY created_at DESC LIMIT 1`));
+    lastApplied = rows[0]?.created_at ? Number(rows[0].created_at) : 0;
+    appliedNames = await readAppliedNames(db, tableName);
+  }
+  const pendingEntries = filterPendingEntries(entries, lastApplied, appliedNames);
+  return {
+    name,
+    total: entries.length,
+    applied: entries.length - pendingEntries.length,
+    pending: pendingEntries.length,
+    pendingTags: pendingEntries.map((entry) => entry.name)
+  };
+}
+function hasMigrationTargets(cwd = process.cwd()) {
+  return discoverFunctionMigrations(cwd).length > 0 || existsSync(projectMigrationsDir(cwd));
+}
+function projectMigrationsDir(cwd = process.cwd()) {
+  return join(cwd, "src", "server", "drizzle");
+}
+async function collectMigrationStatus(db, cwd = process.cwd()) {
+  const packages = [];
+  for (const func of discoverFunctionMigrations(cwd)) {
+    packages.push(await collectTargetStatus(
+      db,
+      func.packageName,
+      func.migrationsDir,
+      functionMigrationsTable(func.packageName)
+    ));
+  }
+  const projectDir = projectMigrationsDir(cwd);
+  const project = existsSync(projectDir) ? await collectTargetStatus(db, PROJECT_TARGET_NAME, projectDir, PROJECT_MIGRATIONS_TABLE) : null;
+  return { packages, project: project && project.total > 0 ? project : null };
+}
+
+// src/db/migrations/format.ts
+var RUN_MIGRATIONS_HINT = "Run: pnpm spfn db migrate";
+function formatPendingMigrations(targets) {
+  const lines = [];
+  for (const target of targets) {
+    lines.push(`${target.name}: ${target.pending} pending migration(s) (${target.applied}/${target.total} applied)`);
+    for (const tag of target.pendingTags) {
+      lines.push(`    - ${tag}`);
+    }
+  }
+  return lines;
+}
+function pendingMigrationsSummary(targets) {
+  const pending = targets.reduce((sum, target) => sum + target.pending, 0);
+  const names = targets.map((target) => target.name).join(", ");
+  return `${pending} pending migration(s) in ${names}`;
+}
 var txLogger = logger.child("@spfn/core:transaction");
 var asyncContext = new AsyncLocalStorage();
 function getTransactionContext() {
@@ -2337,6 +2531,6 @@ var BaseRepository = class {
   }
 };
 
-export { BaseRepository, RepositoryError, Transactional, auditFields, checkConnection, closeDatabase, count, create, createDatabaseConnection, createDatabaseFromEnv, createMany, createSchema, deleteMany, deleteOne, detectDialect, enumText, findMany, findOne, forceReconnectDatabase, foreignKey, fromPostgresError, generateDrizzleConfigFile, getDatabase, getDatabaseInfo, getDrizzleConfig, getSchemaInfo, getTransaction, getTransactionContext, id, initDatabase, isConnectionLevelError, onAfterCommit, optionalForeignKey, packageNameToSchema, publishingFields, reportDatabaseError, resetConnectionErrorCounter, runInTransaction, runWithTransaction, setDatabase, setDatabaseProvider, softDelete, timestamps, typedJsonb, updateMany, updateOne, upsert, utcTimestamp, uuid, verificationTimestamp };
+export { BaseRepository, PROJECT_MIGRATIONS_TABLE, PROJECT_TARGET_NAME, RUN_MIGRATIONS_HINT, RepositoryError, Transactional, auditFields, checkConnection, closeDatabase, collectMigrationStatus, count, countPendingMigrations, create, createDatabaseConnection, createDatabaseFromEnv, createMany, createSchema, deleteMany, deleteOne, detectDialect, discoverFunctionMigrations, enumText, filterPendingEntries, findMany, findOne, forceReconnectDatabase, foreignKey, formatPendingMigrations, fromPostgresError, functionMigrationsTable, generateDrizzleConfigFile, getDatabase, getDatabaseInfo, getDrizzleConfig, getSchemaInfo, getTransaction, getTransactionContext, hasMigrationTargets, id, initDatabase, isConnectionLevelError, migrationTargets, onAfterCommit, optionalForeignKey, packageNameToSchema, pendingMigrationTargets, pendingMigrationsSummary, projectMigrationsDir, publishingFields, readMigrationEntries, reportDatabaseError, resetConnectionErrorCounter, runInTransaction, runWithTransaction, setDatabase, setDatabaseProvider, softDelete, timestamps, typedJsonb, updateMany, updateOne, upsert, utcTimestamp, uuid, verificationTimestamp };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map