@getstrata/bootstrap 1.0.9 → 1.1.1

package/dist/index.js

@@ -17,6 +17,7 @@ import {
 // ../../src/bootstrap/buildModuleRoutes.ts
 import { conditionalJsonResponse } from "@getstrata/core/http/conditionalResponse";
 import { applyMiddlewareToRoutes } from "@getstrata/core/http/middleware";
+import { createJsonErrorMiddleware } from "@getstrata/core/http/response";
 
 // ../../src/bootstrap/httpKernel.ts
 import {
@@ -152,8 +153,9 @@ class HttpKernel {
       case "web":
         return isViewsEnabled() ? [createFlashMiddleware(), createCsrfMiddleware()] : [];
       case "api": {
+        const csrf = createCsrfMiddleware();
         if (!this.dependencies.container.has(CORE_CONFIG_TOKEN)) {
-          return [];
+          return [csrf];
         }
         const config = this.dependencies.container.resolve(CORE_CONFIG_TOKEN);
         const redisUrl = config.get(REDIS_URL_CONFIG_KEY)?.trim() ?? "";
@@ -163,7 +165,8 @@ class HttpKernel {
             createMemoryThrottleMiddleware({
               maxAttempts: Number.isFinite(maxAttempts) ? maxAttempts : 120,
               decaySeconds: 60
-            })
+            }),
+            csrf
           ];
         }
         const maxAttempts = Number(process.env.RATE_LIMIT_PER_MINUTE ?? "120");
@@ -172,7 +175,8 @@ class HttpKernel {
             redisUrl,
             maxAttempts: Number.isFinite(maxAttempts) ? maxAttempts : 120,
             decaySeconds: 60
-          })
+          }),
+          csrf
         ];
       }
       default:
@@ -182,13 +186,14 @@ class HttpKernel {
   wrap(groups, handler) {
     const names = Array.isArray(groups) ? groups : [groups];
     const middleware = names.flatMap((name) => this.group(name));
-    if (middleware.length === 0) {
-      return handler;
+    const wrapped = middleware.length === 0 ? handler : withMiddleware(...middleware)(handler);
+    if (names.includes("api")) {
+      return withJsonErrorHandling(wrapped);
     }
-    return withMiddleware(...middleware)(handler);
+    return wrapped;
   }
   wrapApi(handler) {
-    return withJsonErrorHandling(this.wrap(["api", "authenticated"], handler));
+    return this.wrap(["api", "authenticated"], handler);
   }
   wrapWeb(handler) {
     return withErrorHandling(this.wrap("web", handler));
@@ -297,41 +302,28 @@ class HttpKernel {
     return [createRequireVerifiedMiddleware(auth)];
   }
   wrapThrottle(scope, rateLimit, handler) {
-    const middleware = [];
     const memoryKeyPrefix = scope === "login" ? "login-throttle:" : "register-throttle:";
-    if (this.dependencies.container.has(CORE_CONFIG_TOKEN)) {
-      const config = this.dependencies.container.resolve(CORE_CONFIG_TOKEN);
-      const redisUrl = config.get(REDIS_URL_CONFIG_KEY)?.trim() ?? "";
-      if (redisUrl) {
-        const throttle = scope === "login" ? createLoginThrottleMiddleware({
-          redisUrl,
-          maxAttempts: rateLimit.maxAttempts,
-          decaySeconds: rateLimit.decaySeconds
-        }) : createThrottleMiddleware({
-          redisUrl,
-          maxAttempts: rateLimit.maxAttempts,
-          decaySeconds: rateLimit.decaySeconds,
-          keyPrefix: memoryKeyPrefix
-        });
-        middleware.push(throttle);
-      } else {
-        middleware.push(createMemoryThrottleMiddleware({
-          maxAttempts: rateLimit.maxAttempts,
-          decaySeconds: rateLimit.decaySeconds,
-          keyPrefix: memoryKeyPrefix
-        }));
-      }
-    } else {
-      middleware.push(createMemoryThrottleMiddleware({
+    const redisUrl = this.dependencies.container.has(CORE_CONFIG_TOKEN) ? this.dependencies.container.resolve(CORE_CONFIG_TOKEN).get(REDIS_URL_CONFIG_KEY)?.trim() ?? "" : "";
+    if (scope === "login") {
+      return withMiddleware(createLoginThrottleMiddleware({
+        ...redisUrl ? { redisUrl } : {},
+        maxAttempts: rateLimit.maxAttempts,
+        decaySeconds: rateLimit.decaySeconds
+      }))(handler);
+    }
+    if (redisUrl) {
+      return withMiddleware(createThrottleMiddleware({
+        redisUrl,
         maxAttempts: rateLimit.maxAttempts,
         decaySeconds: rateLimit.decaySeconds,
         keyPrefix: memoryKeyPrefix
-      }));
-    }
-    if (middleware.length === 0) {
-      return handler;
+      }))(handler);
     }
-    return withMiddleware(...middleware)(handler);
+    return withMiddleware(createMemoryThrottleMiddleware({
+      maxAttempts: rateLimit.maxAttempts,
+      decaySeconds: rateLimit.decaySeconds,
+      keyPrefix: memoryKeyPrefix
+    }))(handler);
   }
 }
 function createHttpKernel(dependencies) {
@@ -470,7 +462,11 @@ function buildModuleRoutes(dependencies, options = {}) {
     routeRegistry.clear();
   }
   const kernel = createHttpKernel(dependencies);
-  const middleware = [...kernel.globalMiddleware(), ...kernel.group("api")];
+  const middleware = [
+    ...kernel.globalMiddleware(),
+    createJsonErrorMiddleware(),
+    ...kernel.group("api")
+  ];
   const cachedJson = createCachedJson(dependencies);
   const moduleRoutes = {};
   for (const module of modules) {
@@ -541,7 +537,7 @@ import { SessionGuard } from "@getstrata/core/auth/sessionGuard";
 import { envFlagEnabled } from "@getstrata/core/runtime/appEnv";
 var authConfig = {
   allowDevHeaders: envFlagEnabled(process.env.AUTH_DEV_HEADERS),
-  tokenDefaultAbilities: ["*"]
+  tokenDefaultAbilities: []
 };
 
 // ../../src/bootstrap/providers/auth.ts
@@ -551,7 +547,7 @@ var authProvider = {
     config.set("auth.allowDevHeaders", authConfig.allowDevHeaders);
     const apiGuard = new DatabaseTokenGuard(container);
     const sessionGuard = new SessionGuard(container);
-    const jwtGuard = new JwtGuard;
+    const jwtGuard = new JwtGuard(container);
     const basicGuard = new BasicAuthGuard(container);
     const guards = [apiGuard, jwtGuard, basicGuard, sessionGuard];
     if (authConfig.allowDevHeaders) {
@@ -596,7 +592,7 @@ import { validateEnv } from "@getstrata/core/config/envSchema";
 var appConfig = {
   name: process.env.APP_NAME?.trim() || "Strata",
   env: process.env.APP_ENV ?? "local",
-  debug: (process.env.APP_DEBUG ?? "true") !== "false",
+  debug: (process.env.APP_DEBUG ?? "false") === "true",
   url: process.env.APP_URL ?? "http://localhost:3000",
   apiPrefix: process.env.API_PREFIX ?? "/api/v1"
 };
@@ -777,8 +773,19 @@ var events_default = eventsProvider;
 
 // ../../src/bootstrap/discoverListeners.ts
 import { existsSync, readdirSync as readdirSync2 } from "fs";
+import { createRequire } from "module";
 import { join as join2 } from "path";
-import { pathToFileURL as pathToFileURL2 } from "url";
+var requireListener = createRequire(import.meta.url);
+var DISCOVER_LISTENERS_STATE_KEY = Symbol.for("@getstrata/discoverListenersState");
+function readDiscoverListenersState() {
+  const existing = globalThis[DISCOVER_LISTENERS_STATE_KEY];
+  if (existing) {
+    return existing;
+  }
+  const state = {};
+  globalThis[DISCOVER_LISTENERS_STATE_KEY] = state;
+  return state;
+}
 function resolveListenersDirectory() {
   const fromCwd = join2(process.cwd(), "src", "listeners");
   if (existsSync(fromCwd)) {
@@ -786,7 +793,7 @@ function resolveListenersDirectory() {
   }
   return join2(import.meta.dir, "../listeners");
 }
-async function loadDiscoveredListeners() {
+function loadDiscoveredListeners() {
   const listenersDirectory = resolveListenersDirectory();
   let entries;
   try {
@@ -797,16 +804,17 @@ async function loadDiscoveredListeners() {
     }
     throw error;
   }
-  const listeners = await Promise.all(entries.map(async (fileName) => {
-    const moduleUrl = pathToFileURL2(join2(listenersDirectory, fileName)).href;
-    const loaded = await import(moduleUrl);
+  const listeners = entries.map((fileName) => {
+    const filePath = join2(listenersDirectory, fileName);
+    const loaded = requireListener(filePath);
     return loaded.default;
-  }));
+  });
   return listeners.filter((listener) => typeof listener === "function");
 }
-var appListeners = await loadDiscoveredListeners();
 function discoverListeners() {
-  return appListeners;
+  const state = readDiscoverListenersState();
+  state.appListeners ??= loadDiscoveredListeners();
+  return state.appListeners;
 }
 
 // ../../src/bootstrap/listeners/invalidateCacheOnModelWrite.ts
@@ -1001,6 +1009,7 @@ function createAppContext() {
 // ../../src/bootstrap/createWebRoutes.ts
 import { join as join3 } from "path";
 import { isViewsEnabled as isViewsEnabled3 } from "@getstrata/core/runtime/frontendMode";
+import { assertUrlPathUnderRoot } from "@getstrata/core/security/safePath";
 import { notFoundHtmlResponse } from "@getstrata/core/view";
 function registerRoute(method, path, middleware) {
   routeRegistry.register({ method, path, middleware });
@@ -1014,12 +1023,16 @@ function createWebRoutes(dependencies, options = {}) {
   wrappedRoutes["/assets/*"] = async (request) => {
     registerRoute("GET", "/assets/*", ["global", "web"]);
     const pathname = new URL(request.url).pathname;
-    const relativePath = pathname.replace(/^\//, "");
-    const file = Bun.file(join3(process.cwd(), "public", relativePath));
-    if (!await file.exists()) {
+    try {
+      const filePath = assertUrlPathUnderRoot(join3(process.cwd(), "public"), pathname);
+      const file = Bun.file(filePath);
+      if (!await file.exists()) {
+        return notFoundHtmlResponse();
+      }
+      return new Response(file);
+    } catch {
       return notFoundHtmlResponse();
     }
-    return new Response(file);
   };
   registerRoute("GET", "/assets/*", ["global", "web"]);
   return wrappedRoutes;
@@ -1041,6 +1054,7 @@ function createAppDependencies() {
 import { getBoundDatabaseConnection } from "@getstrata/core/database/boundConnection";
 import { getDefaultDatabasePool } from "@getstrata/core/database/defaultConnection";
 import { jsonResponse } from "@getstrata/core/http/response";
+import { envFlagEnabled as envFlagEnabled2 } from "@getstrata/core/runtime/appEnv";
 var {RedisClient } = globalThis.Bun;
 function resolveRedisUrl(dependencies) {
   if (!dependencies.container.has(CORE_CONFIG_TOKEN)) {
@@ -1124,10 +1138,10 @@ function createHealthRoutes(dependencies, options = {}) {
     "/ready": async () => {
       const extra = await resolveExtraFields(options.extra);
       const { checks, ready } = await collectDependencyChecks(dependencies);
+      const debug = envFlagEnabled2(process.env.APP_DEBUG);
       return jsonResponse({
         status: ready ? "ready" : "not_ready",
-        checks,
-        ...extra
+        ...debug ? { checks, ...extra } : {}
       }, { status: ready ? 200 : 503 });
     }
   };
@@ -1140,8 +1154,16 @@ import {
 // ../../src/bootstrap/membershipService.ts
 import { resolveMembershipService } from "@getstrata/core/auth/membershipService";
 // ../../src/bootstrap/secretsGuard.ts
-import { envFlagEnabled as envFlagEnabled2, isProductionEnv } from "@getstrata/core/runtime/appEnv";
+import { getDefaultDatabasePool as getDefaultDatabasePool2 } from "@getstrata/core/database/defaultConnection";
+import { envFlagEnabled as envFlagEnabled3, isProductionEnv } from "@getstrata/core/runtime/appEnv";
 import { isViewsMode, parseFrontendMode } from "@getstrata/core/runtime/frontendMode";
+import {
+  assertPostgresRoleCannotBypassRls,
+  inspectCurrentPostgresRole,
+  isPostgresUrl,
+  postgresUrlUsername
+} from "@getstrata/core/tenant/enableTenantRls";
+import { isRlsTenancy } from "@getstrata/core/tenant/tenancyConfig";
 var PUBLISHED_TEST_ADMIN_API_TOKEN = "strata-admin-test-token";
 var PUBLISHED_TEST_MEMBER_API_TOKEN = "strata-member-test-token";
 var PUBLISHED_TEST_SCIM_BEARER_TOKEN = "strata-scim-test-token";
@@ -1162,8 +1184,11 @@ var SECRETS_TO_ROTATE = [
   "KMS_ENCRYPTION_KEY",
   "STRIPE_WEBHOOK_SECRET",
   "ADMIN_API_TOKEN",
-  "MEMBER_API_TOKEN"
+  "MEMBER_API_TOKEN",
+  "DATABASE_URL",
+  "APP_DATABASE_URL"
 ];
+var RLS_BYPASS_DATABASE_USERS = new Set(["postgres", "root"]);
 function assertNoPlaceholderSecrets(env) {
   const unrotated = SECRETS_TO_ROTATE.filter((name) => PLACEHOLDER_SECRET_PATTERN.test(env[name]?.trim() ?? ""));
   if (unrotated.length > 0) {
@@ -1171,10 +1196,14 @@ function assertNoPlaceholderSecrets(env) {
   }
 }
 function isTokenAuthEnabled(env) {
-  return Boolean(env.ADMIN_API_TOKEN?.trim()) || Boolean(env.MEMBER_API_TOKEN?.trim()) || envFlagEnabled2(env.FEATURE_API_TOKENS);
+  return Boolean(env.ADMIN_API_TOKEN?.trim()) || Boolean(env.MEMBER_API_TOKEN?.trim()) || envFlagEnabled3(env.FEATURE_API_TOKENS);
 }
 function isOAuthEnabled(env) {
-  return envFlagEnabled2(env.FEATURE_OAUTH) || envFlagEnabled2(env.FEATURE_SAML) || Boolean(env.GITHUB_CLIENT_ID?.trim()) || Boolean(env.OIDC_ISSUER?.trim()) || Boolean(env.SAML_LOGIN_URL?.trim());
+  return envFlagEnabled3(env.FEATURE_OAUTH) || envFlagEnabled3(env.FEATURE_SAML) || Boolean(env.GITHUB_CLIENT_ID?.trim()) || Boolean(env.OIDC_ISSUER?.trim()) || Boolean(env.SAML_IDP_SSO_URL?.trim()) || Boolean(env.SAML_LOGIN_URL?.trim());
+}
+function isHeaderOnlyAuth(env) {
+  const frontend = env.FRONTEND_MODE?.trim() ?? "";
+  return env.AUTH_MODE === "headers" || frontend === "api" && env.AUTH_DEV_HEADERS === "true";
 }
 function isCorsConfigured(env) {
   return env.CORS_ALLOWED_ORIGINS !== undefined;
@@ -1211,16 +1240,35 @@ function assertTokenAuthProductionSecrets(env) {
   }
 }
 function assertFeatureProductionSecrets(env) {
-  if (envFlagEnabled2(env.FEATURE_SCIM)) {
+  if (envFlagEnabled3(env.FEATURE_SCIM)) {
     const scimToken = env.SCIM_BEARER_TOKEN ?? PUBLISHED_TEST_SCIM_BEARER_TOKEN;
     if (PUBLISHED_TEST_SCIM_TOKENS.has(scimToken) || !env.SCIM_BEARER_TOKEN?.trim()) {
       throw new Error("Production startup blocked: rotate SCIM_BEARER_TOKEN away from published test defaults.");
     }
   }
-  if (envFlagEnabled2(env.FEATURE_FIELD_ENCRYPTION) && !env.KMS_ENCRYPTION_KEY?.trim()) {
-    throw new Error("Production startup blocked: set KMS_ENCRYPTION_KEY when field encryption is enabled.");
+  if ((envFlagEnabled3(env.FEATURE_FIELD_ENCRYPTION) || envFlagEnabled3(env.FEATURE_MFA)) && !env.KMS_ENCRYPTION_KEY?.trim()) {
+    throw new Error("Production startup blocked: set KMS_ENCRYPTION_KEY when field encryption or MFA is enabled.");
   }
-  if (envFlagEnabled2(env.FEATURE_BILLING) && !env.STRIPE_WEBHOOK_SECRET?.trim()) {
+  if (envFlagEnabled3(env.FEATURE_SAML)) {
+    const required = [
+      "SAML_IDP_CERT",
+      "SAML_IDP_SSO_URL",
+      "SAML_SP_ENTITY_ID",
+      "SAML_ACS_URL",
+      "SAML_IDP_ISSUER"
+    ];
+    const missing = required.filter((name) => !env[name]?.trim());
+    if (missing.length > 0) {
+      throw new Error(`Production startup blocked: set ${missing.join(", ")} when FEATURE_SAML=true.`);
+    }
+    if (env.SAML_WANT_RESPONSE_SIGNED === "false") {
+      throw new Error("Production startup blocked: signed SAML responses are required (do not set SAML_WANT_RESPONSE_SIGNED=false).");
+    }
+  }
+  if (envFlagEnabled3(env.UPLOAD_ALLOW_UNKNOWN_MIME)) {
+    throw new Error("Production startup blocked: set UPLOAD_ALLOW_UNKNOWN_MIME=false (unknown MIME types are not allowed).");
+  }
+  if (envFlagEnabled3(env.FEATURE_BILLING) && !env.STRIPE_WEBHOOK_SECRET?.trim()) {
     throw new Error("Production startup blocked: set STRIPE_WEBHOOK_SECRET when billing webhooks are enabled.");
   }
   if (isOAuthEnabled(env) && !env.OAUTH_STATE_SECRET?.trim()) {
@@ -1232,14 +1280,44 @@ function assertFeatureProductionSecrets(env) {
       throw new Error("Production startup blocked: set explicit CORS_ALLOWED_ORIGINS instead of wildcard.");
     }
   }
-  if (envFlagEnabled2(env.FEATURE_PUBLIC_READS)) {
+  if (envFlagEnabled3(env.FEATURE_PUBLIC_READS)) {
     throw new Error("Production startup blocked: set FEATURE_PUBLIC_READS=false for authenticated-only reads.");
   }
-  if (!env.SIEM_EXPORT_URL?.trim() && envFlagEnabled2(env.FEATURE_SIEM_EXPORT)) {
+  if (!env.SIEM_EXPORT_URL?.trim() && envFlagEnabled3(env.FEATURE_SIEM_EXPORT)) {
     console.warn("[secrets] SIEM_EXPORT_URL is not configured; audit logs remain database-only.");
   }
 }
 var LOCAL_HOSTS = new Set(["localhost", "127.0.0.1", "0.0.0.0", "::1", "[::1]"]);
+function rlsRuntimeDatabaseUrl(env) {
+  const app = env.APP_DATABASE_URL?.trim();
+  if (app) {
+    return { name: "APP_DATABASE_URL", raw: app };
+  }
+  const database = env.DATABASE_URL?.trim();
+  if (database) {
+    return { name: "DATABASE_URL", raw: database };
+  }
+  return null;
+}
+function assertRlsUsesAppDatabaseRole(env) {
+  if (!isRlsTenancy(env)) {
+    return;
+  }
+  const runtime = rlsRuntimeDatabaseUrl(env);
+  if (!runtime) {
+    return;
+  }
+  const user = postgresUrlUsername(runtime.raw);
+  if (user === null) {
+    return;
+  }
+  if (user === "") {
+    throw new Error(`TENANCY_DRIVER=rls startup blocked: ${runtime.name} must include a NOBYPASSRLS role username.`);
+  }
+  if (RLS_BYPASS_DATABASE_USERS.has(user.toLowerCase())) {
+    throw new Error(`TENANCY_DRIVER=rls startup blocked: ${runtime.name} for TENANCY_DRIVER=rls must use a NOBYPASSRLS role, not ${user}. FORCE RLS does not apply to PostgreSQL superusers.`);
+  }
+}
 function assertPublicAppUrl(env) {
   const raw = env.APP_URL?.trim() ?? "";
   let url = null;
@@ -1262,6 +1340,9 @@ function assertProductionSecrets(env = process.env) {
   assertNoPlaceholderSecrets(env);
   assertAuthDevHeadersDisabled(env);
   assertPublicAppUrl(env);
+  if (isHeaderOnlyAuth(env)) {
+    throw new Error("Production startup blocked: header-only authentication is not allowed. Configure cookie, token, or JWT auth.");
+  }
   if (isTokenAuthEnabled(env)) {
     assertTokenAuthProductionSecrets(env);
   }
@@ -1269,6 +1350,7 @@ function assertProductionSecrets(env = process.env) {
   if (isViewsMode(parseFrontendMode(env.FRONTEND_MODE))) {
     assertSessionSecret(env);
   }
+  assertRlsUsesAppDatabaseRole(env);
 }
 // ../../src/bootstrap/web/forms.ts
 import {
@@ -1350,6 +1432,7 @@ function createRouteKernel(dependencies) {
 }
 // ../../src/bootstrap/web/server.ts
 import { currentRequestMeta as currentRequestMeta2, runWithRequestMeta } from "@getstrata/core/http/requestMetaContext";
+import { assertUrlPathUnderRoot as assertUrlPathUnderRoot2 } from "@getstrata/core/security/safePath";
 import { notFoundHtmlResponse as notFoundHtmlResponse2 } from "@getstrata/core/view";
 function socketAddress(server, request) {
   const address = server?.requestIP(request)?.address;
@@ -1409,9 +1492,14 @@ function createWebServer(options) {
         await options.onRequest?.(request);
         const url = new URL(request.url);
         if (url.pathname.startsWith("/assets/")) {
-          const file = Bun.file(`${publicDir}${url.pathname}`);
-          if (await file.exists()) {
-            return new Response(file);
+          try {
+            const filePath = assertUrlPathUnderRoot2(publicDir, url.pathname);
+            const file = Bun.file(filePath);
+            if (await file.exists()) {
+              return new Response(file);
+            }
+          } catch {
+            return await missingHtmlResponse();
           }
         }
         if (options.handle) {
@@ -1426,13 +1514,22 @@ function createWebServer(options) {
 // ../../src/bootstrap/web/session.ts
 import { createHmac, randomBytes } from "crypto";
 import { AuthManager as AuthManager2 } from "@getstrata/core/auth/guard";
+import { isSessionInvalidated } from "@getstrata/core/auth/sessionCookie";
 import { getBoundDatabaseConnection as getBoundDatabaseConnection2 } from "@getstrata/core/database/boundConnection";
-import { getDefaultDatabasePool as getDefaultDatabasePool2 } from "@getstrata/core/database/defaultConnection";
+import {
+  getActiveDatabaseConnection,
+  hasActiveDatabaseConnection
+} from "@getstrata/core/database/connectionContext";
+import {
+  getDefaultDatabasePool as getDefaultDatabasePool3,
+  getDefaultDatabaseQuery
+} from "@getstrata/core/database/defaultConnection";
 import { currentSqlDialect, sqlTimestamp } from "@getstrata/core/database/dialect";
 import { readRequestCookie } from "@getstrata/core/http/cookies";
 import { currentRequestMeta as currentRequestMeta3 } from "@getstrata/core/http/requestMetaContext";
 import { isProductionEnv as isProductionEnv2 } from "@getstrata/core/runtime/appEnv";
 import { timingSafeCompareString } from "@getstrata/core/security/timingSafeCompare";
+import { runWithMigrationBypassForIdentifier } from "@getstrata/core/tenant/databaseTenantContext";
 function sqlPlaceholder(index) {
   return currentSqlDialect().placeholder(index);
 }
@@ -1443,17 +1540,25 @@ function isSqlClient(value) {
   return typeof value.unsafe === "function";
 }
 function resolveSql(source) {
-  if (isSqlClient(source)) {
-    return source;
+  const client = isSqlClient(source) ? source : source();
+  if (!hasActiveDatabaseConnection()) {
+    return client;
+  }
+  try {
+    if (client === getDefaultDatabasePool3() || client === getDefaultDatabaseQuery()) {
+      return getActiveDatabaseConnection(client);
+    }
+  } catch {
+    return client;
   }
-  return source();
+  return client;
 }
 function defaultSessionSql() {
   const bound = getBoundDatabaseConnection2();
   if (bound) {
     return bound;
   }
-  return getDefaultDatabasePool2();
+  return getDefaultDatabasePool3();
 }
 function defaultMapSessionUser(user) {
   return {
@@ -1483,14 +1588,32 @@ function mapSessionUserRow(row) {
   };
 }
 async function defaultLoadSessionUser(sql, sessionId) {
-  const rows = await sql.unsafe(`SELECT s.user_id, s.expires_at, u.*
-     FROM sessions s
-     INNER JOIN users u ON u.id = s.user_id
-     WHERE s.id = ${sqlPlaceholder(1)} AND s.expires_at > ${sqlNow()}`, [sessionId]);
-  const row = rows[0];
-  if (!row)
+  const sessionRows = await runWithMigrationBypassForIdentifier(sessionId, async () => {
+    return await sql.unsafe(`SELECT user_id, expires_at, created_at AS session_created_at
+     FROM sessions
+     WHERE id = ${sqlPlaceholder(1)} AND expires_at > ${sqlNow()}`, [sessionId]);
+  });
+  const session = sessionRows[0];
+  if (!session)
+    return null;
+  const userId = Number(session.user_id);
+  if (!Number.isInteger(userId) || userId <= 0) {
     return null;
-  return mapSessionUserRow(row);
+  }
+  return await runWithMigrationBypassForIdentifier(userId, async () => {
+    const rows = await sql.unsafe(`SELECT * FROM users WHERE id = ${sqlPlaceholder(1)}`, [
+      userId
+    ]);
+    const row = rows[0];
+    if (!row)
+      return null;
+    const createdSource = session.session_created_at;
+    const createdAt = createdSource instanceof Date ? createdSource.getTime() : createdSource ? Date.parse(String(createdSource)) : Number.NaN;
+    if (!Number.isFinite(createdAt) || isSessionInvalidated(createdAt, row.session_valid_after)) {
+      return null;
+    }
+    return mapSessionUserRow({ ...row, user_id: userId, session_created_at: createdSource });
+  });
 }
 function redirectWithCookie(location, setCookie, status) {
   return new Response(null, {
@@ -1545,25 +1668,40 @@ class CookieSessionStore {
   async create(user, meta = {}) {
     const id = randomBytes(32).toString("hex");
     const expires = new Date(Date.now() + this.maxAgeSeconds * 1000);
-    await this.sql().unsafe(`INSERT INTO sessions (id, user_id, expires_at, user_agent, ip_address, last_active_at)
-       VALUES (${sqlPlaceholder(1)}, ${sqlPlaceholder(2)}, ${sqlPlaceholder(3)}, ${sqlPlaceholder(4)}, ${sqlPlaceholder(5)}, ${sqlNow()})`, [id, user.id, sqlTimestamp(expires), meta.userAgent ?? null, meta.ipAddress ?? null]);
+    await runWithMigrationBypassForIdentifier(user.id, async () => {
+      await this.sql().unsafe(`INSERT INTO sessions (id, user_id, expires_at, user_agent, ip_address, last_active_at, created_at)
+       VALUES (${sqlPlaceholder(1)}, ${sqlPlaceholder(2)}, ${sqlPlaceholder(3)}, ${sqlPlaceholder(4)}, ${sqlPlaceholder(5)}, ${sqlNow()}, ${sqlNow()})`, [id, user.id, sqlTimestamp(expires), meta.userAgent ?? null, meta.ipAddress ?? null]);
+    });
     return id;
   }
   async destroy(sessionId) {
-    await this.sql().unsafe(`DELETE FROM sessions WHERE id = ${sqlPlaceholder(1)}`, [sessionId]);
+    await runWithMigrationBypassForIdentifier(sessionId, async () => {
+      await this.sql().unsafe(`DELETE FROM sessions WHERE id = ${sqlPlaceholder(1)}`, [sessionId]);
+    });
+  }
+  async destroyAllSessions(userId) {
+    await runWithMigrationBypassForIdentifier(userId, async () => {
+      await this.sql().unsafe(`DELETE FROM sessions WHERE user_id = ${sqlPlaceholder(1)}`, [
+        userId
+      ]);
+    });
   }
   async destroyOtherSessions(userId, keepSessionId) {
-    await this.sql().unsafe(`DELETE FROM sessions WHERE user_id = ${sqlPlaceholder(1)} AND id <> ${sqlPlaceholder(2)}`, [userId, keepSessionId]);
+    await runWithMigrationBypassForIdentifier(userId, async () => {
+      await this.sql().unsafe(`DELETE FROM sessions WHERE user_id = ${sqlPlaceholder(1)} AND id <> ${sqlPlaceholder(2)}`, [userId, keepSessionId]);
+    });
   }
   async listForUser(userId) {
     const dialect = currentSqlDialect();
-    return this.sql().unsafe(`SELECT id, user_id, user_agent, ip_address, last_active_at, expires_at
+    return await runWithMigrationBypassForIdentifier(userId, () => this.sql().unsafe(`SELECT id, user_id, user_agent, ip_address, last_active_at, expires_at
        FROM sessions
        WHERE user_id = ${dialect.placeholder(1)} AND expires_at > ${dialect.nowExpression()}
-       ORDER BY last_active_at DESC${dialect.nullsLastSuffix()}, expires_at DESC`, [userId]);
+       ORDER BY last_active_at DESC${dialect.nullsLastSuffix()}, expires_at DESC`, [userId]));
   }
   async touch(sessionId) {
-    await this.sql().unsafe(`UPDATE sessions SET last_active_at = ${sqlNow()} WHERE id = ${sqlPlaceholder(1)}`, [sessionId]);
+    await runWithMigrationBypassForIdentifier(sessionId, async () => {
+      await this.sql().unsafe(`UPDATE sessions SET last_active_at = ${sqlNow()} WHERE id = ${sqlPlaceholder(1)}`, [sessionId]);
+    });
   }
   async read(request) {
     const sessionId = this.sessionIdFromRequest(request);