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

package/dist/server/index.js

@@ -11,7 +11,7 @@ import { setDefaultSafeFetchPolicy } from '@spfn/core/security';
 import { streamSSE } from 'hono/streaming';
 import { randomBytes, createHash } from 'crypto';
 import { Agent, setGlobalDispatcher } from 'undici';
-import { initDatabase, getDatabase, closeDatabase } from '@spfn/core/db';
+import { initDatabase, getDatabase, hasMigrationTargets, collectMigrationStatus, countPendingMigrations, pendingMigrationTargets, formatPendingMigrations, pendingMigrationsSummary, RUN_MIGRATIONS_HINT, migrationTargets, closeDatabase } from '@spfn/core/db';
 import { initCache, getCache, closeCache } from '@spfn/core/cache';
 import { serve } from '@hono/node-server';
 import PgBoss from 'pg-boss';
@@ -646,8 +646,8 @@ var InMemoryTokenStore = class {
   }
 };
 var CacheTokenStore = class {
-  constructor(cache) {
-    this.cache = cache;
+  constructor(cache2) {
+    this.cache = cache2;
   }
   prefix = "sse:token:";
   async set(token, data) {
@@ -989,6 +989,93 @@ async function closeEventTransport() {
 }
 var serverLogger = logger.child("@spfn/core:server");
 
+// src/server/migration-gate.ts
+var SNAPSHOT_TTL_MS = 3e4;
+var cache = null;
+var PendingMigrationsError = class extends Error {
+  targets;
+  constructor(message, targets) {
+    super(message);
+    this.name = "PendingMigrationsError";
+    this.targets = targets;
+  }
+};
+function resetMigrationSnapshot() {
+  cache = null;
+}
+async function inspect(cwd, db) {
+  const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
+  if (!hasMigrationTargets(cwd)) {
+    return { state: "skipped", checkedAt, reason: "no function package or project migrations found" };
+  }
+  let database = db;
+  if (!database) {
+    try {
+      database = getDatabase();
+    } catch {
+      return { state: "skipped", checkedAt, reason: "no database initialized" };
+    }
+  }
+  try {
+    const status = await collectMigrationStatus(database, cwd);
+    return { state: "ok", checkedAt, status, pending: countPendingMigrations(status) };
+  } catch (error) {
+    return {
+      state: "unavailable",
+      checkedAt,
+      reason: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function getMigrationSnapshot(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const ttl = options.ttlMs ?? SNAPSHOT_TTL_MS;
+  const now = Date.now();
+  if (!options.force && cache && cache.cwd === cwd && now - cache.at < ttl) {
+    return cache.value;
+  }
+  const value = await inspect(cwd, options.db);
+  cache = { at: now, cwd, value };
+  return value;
+}
+function pendingIsAllowed(config) {
+  return config?.migrations?.allowPending ?? env.SPFN_ALLOW_PENDING_MIGRATIONS === true;
+}
+async function runMigrationBootGate(config, cwd = process.cwd()) {
+  const snapshot = await getMigrationSnapshot({ cwd, force: true });
+  if (snapshot.state === "skipped") {
+    serverLogger.debug(`Migration gate skipped: ${snapshot.reason}`);
+    return snapshot;
+  }
+  if (snapshot.state === "unavailable") {
+    serverLogger.warn(
+      `Could not verify migration status: ${snapshot.reason}. Starting anyway \u2014 run \`pnpm spfn db status\` to check.`
+    );
+    return snapshot;
+  }
+  const targets = pendingMigrationTargets(snapshot.status);
+  if (targets.length === 0) {
+    serverLogger.debug("Migration gate passed: database is up to date");
+    return snapshot;
+  }
+  const lines = formatPendingMigrations(targets);
+  const summary = pendingMigrationsSummary(targets);
+  if (pendingIsAllowed(config)) {
+    serverLogger.warn(`Starting with pending migrations \u2014 ${summary}`);
+    lines.forEach((line) => serverLogger.warn(`  ${line}`));
+    serverLogger.warn(`  Requests hitting the missing columns will fail. ${RUN_MIGRATIONS_HINT}`);
+    return snapshot;
+  }
+  serverLogger.error(`Refusing to start: ${summary}`);
+  lines.forEach((line) => serverLogger.error(`  ${line}`));
+  serverLogger.error(`  ${RUN_MIGRATIONS_HINT}`);
+  serverLogger.error("  To start anyway: SPFN_ALLOW_PENDING_MIGRATIONS=true (or `spfn dev --allow-pending-migrations`)");
+  throw new PendingMigrationsError(
+    `${summary}. ${RUN_MIGRATIONS_HINT}, or set SPFN_ALLOW_PENDING_MIGRATIONS=true to start anyway.`,
+    targets.map((target) => target.name)
+  );
+}
+
 // src/server/shutdown-manager.ts
 var DEFAULT_HOOK_TIMEOUT = 1e4;
 var DEFAULT_HOOK_ORDER = 100;
@@ -1203,6 +1290,24 @@ async function withTimeout2(promise, timeout, message) {
 }
 
 // src/server/helpers.ts
+async function readMigrationHealth() {
+  const snapshot = await getMigrationSnapshot();
+  if (snapshot.state !== "ok") {
+    return {
+      status: "unknown",
+      pending: 0,
+      checkedAt: snapshot.checkedAt,
+      targets: [],
+      reason: snapshot.reason
+    };
+  }
+  return {
+    status: snapshot.pending > 0 ? "pending" : "up_to_date",
+    pending: snapshot.pending,
+    checkedAt: snapshot.checkedAt,
+    targets: migrationTargets(snapshot.status)
+  };
+}
 function createHealthCheckHandler(detailed) {
   return async (c) => {
     const shutdownManager = getShutdownManager();
@@ -1256,11 +1361,32 @@ function createHealthCheckHandler(detailed) {
       };
       const hasErrors = dbStatus === "error" || dbStatus === "not_initialized" || redisStatus === "error";
       response.status = hasErrors ? "degraded" : "ok";
+      response.migrations = await readMigrationHealth();
     }
     const statusCode = response.status === "ok" ? 200 : 503;
     return c.json(response, statusCode);
   };
 }
+function resolveEndpointMiddlewares(config) {
+  const candidates = [
+    ...config.middlewares ?? [],
+    ...config.routes?._globalMiddlewares ?? []
+  ];
+  for (const pkgRouter of config.routes?._packageRouters ?? []) {
+    candidates.push(...pkgRouter._globalMiddlewares ?? []);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return candidates.filter((mw) => {
+    if (!mw.name) {
+      return true;
+    }
+    if (seen.has(mw.name)) {
+      return false;
+    }
+    seen.add(mw.name);
+    return true;
+  });
+}
 function applyServerTimeouts(server, timeouts) {
   if ("timeout" in server) {
     server.timeout = timeouts.request;
@@ -1416,9 +1542,9 @@ async function applyProxyGuard(app, config) {
   if (proxyGuardConfig?.nonce) {
     try {
       const { getCache: getCache2 } = await import('@spfn/core/cache');
-      const cache = getCache2();
-      if (cache) {
-        nonceStore = createCacheNonceStore(cache);
+      const cache2 = getCache2();
+      if (cache2) {
+        nonceStore = createCacheNonceStore(cache2);
         serverLogger.info("Proxy-guard nonce replay rejection: cache (Redis/Valkey)");
       } else {
         nonceStore = createInMemoryNonceStore();
@@ -1530,9 +1656,9 @@ async function registerSSEEndpoint(app, config) {
     if (!store) {
       try {
         const { getCache: getCache2 } = await import('@spfn/core/cache');
-        const cache = getCache2();
-        if (cache) {
-          store = new CacheTokenStore(cache);
+        const cache2 = getCache2();
+        if (cache2) {
+          store = new CacheTokenStore(cache2);
           if (debug) {
             serverLogger.info("SSE token store: cache (Redis/Valkey)");
           }
@@ -1546,7 +1672,7 @@ async function registerSSEEndpoint(app, config) {
       store
     });
     const tokenPath = streamPath.replace(/\/[^/]+$/, "/token");
-    const mwHandlers = (config.middlewares ?? []).map((mw) => mw.handler);
+    const mwHandlers = resolveEndpointMiddlewares(config).map((mw) => mw.handler);
     const getSubject = authConfig.getSubject ?? ((c) => c.get("auth")?.userId ?? null);
     app.on(["POST"], [tokenPath], ...mwHandlers, async (c) => {
       const subject = getSubject(c);
@@ -2228,6 +2354,7 @@ async function startServer(config) {
   };
   try {
     await initializeInfrastructure(finalConfig);
+    await runMigrationBootGate(finalConfig);
     const app = await createServer(finalConfig);
     const server = startHttpServer(app, host, port);
     let wsCleanup;
@@ -2380,9 +2507,9 @@ async function initializeWebSocket(server, app, config) {
     if (!store) {
       try {
         const { getCache: getCache2 } = await import('@spfn/core/cache');
-        const cache = getCache2();
-        if (cache) {
-          store = new CacheTokenStore(cache);
+        const cache2 = getCache2();
+        if (cache2) {
+          store = new CacheTokenStore(cache2);
           if (debug) serverLogger.info("WS token store: cache (Redis/Valkey)");
         }
       } catch {
@@ -2394,7 +2521,7 @@ async function initializeWebSocket(server, app, config) {
       store
     });
     const tokenPath = wsPath.replace(/\/[^/]+$/, "/token");
-    const mwHandlers = (config.middlewares ?? []).map((mw) => mw.handler);
+    const mwHandlers = resolveEndpointMiddlewares(config).map((mw) => mw.handler);
     const getSubject = authConfig.getSubject ?? ((c) => c.get("auth")?.userId ?? null);
     app.on(["POST"], [tokenPath], ...mwHandlers, async (c) => {
       const subject = getSubject(c);
@@ -2803,9 +2930,16 @@ var ServerConfigBuilder = class {
   /**
    * Register define-route based router
    *
-   * Automatically applies:
-   * - Global middlewares from router._globalMiddlewares (via .use())
-   * - Package routers from router._packageRouters (via .packages())
+   * Router-level middleware (`.use()`) and package routers (`.packages()`) travel
+   * with the router itself and are applied by `registerRoutes` when the routes are
+   * mounted — this method only records which router to mount.
+   *
+   * It deliberately does **not** copy `router._globalMiddlewares` into
+   * `config.middlewares`: that copy used to make `registerRoutes` see the same
+   * middleware twice (once from the config list, once from the router it was
+   * handed) and attach both to every route. Middleware that verifies a JWT survives
+   * running twice; middleware that consumes one-shot state — a nonce replay ledger —
+   * rejects its own request the second time round.
    *
    * @example
    * ```typescript
@@ -2816,29 +2950,12 @@ var ServerConfigBuilder = class {
    * .use([authMiddleware]);
    *
    * export default defineServerConfig()
-   *   .routes(appRouter)  // middlewares auto-applied
+   *   .routes(appRouter)  // .use() middleware applied once, at registration
    *   .build();
    * ```
    */
   routes(router) {
     this.config.routes = router;
-    const allGlobalMiddlewares = [];
-    if (router._globalMiddlewares?.length > 0) {
-      allGlobalMiddlewares.push(...router._globalMiddlewares);
-    }
-    if (router._packageRouters?.length > 0) {
-      for (const pkgRouter of router._packageRouters) {
-        if (pkgRouter._globalMiddlewares?.length > 0) {
-          allGlobalMiddlewares.push(...pkgRouter._globalMiddlewares);
-        }
-      }
-    }
-    if (allGlobalMiddlewares.length > 0) {
-      this.config.middlewares = [
-        ...this.config.middlewares || [],
-        ...allGlobalMiddlewares
-      ];
-    }
     return this;
   }
   /**
@@ -2978,6 +3095,21 @@ var ServerConfigBuilder = class {
     this.config.infrastructure = infrastructure;
     return this;
   }
+  /**
+   * Configure the migration boot gate
+   *
+   * @example
+   * ```typescript
+   * // A harness that applies migrations itself, after the server is up
+   * export default defineServerConfig()
+   *     .migrations({ allowPending: true })
+   *     .build();
+   * ```
+   */
+  migrations(migrations) {
+    this.config.migrations = migrations;
+    return this;
+  }
   /**
    * Register workflow router for workflow orchestration
    *
@@ -3052,6 +3184,6 @@ function defineServerConfig() {
   return new ServerConfigBuilder();
 }
 
-export { createServer, createServerlessApp, defineServerConfig, getShutdownManager, loadEnv, loadEnvFiles, provisionInfrastructure, resetServerlessApp, startServer };
+export { PendingMigrationsError, createServer, createServerlessApp, defineServerConfig, getMigrationSnapshot, getShutdownManager, loadEnv, loadEnvFiles, provisionInfrastructure, resetMigrationSnapshot, resetServerlessApp, startServer };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map