@getstrata/bootstrap 1.0.9 → 1.1.0

package/dist/entries/metricsRoutes.js

@@ -2,6 +2,7 @@
 // ../../src/bootstrap/metricsRoutes.ts
 import { timingSafeEqual } from "crypto";
 import { prometheusRegistry } from "@getstrata/core/metrics/prometheus";
+import { isProductionEnv } from "@getstrata/core/runtime/appEnv";
 function tokensMatch(left, right) {
   const leftBuffer = Buffer.from(left);
   const rightBuffer = Buffer.from(right);
@@ -17,7 +18,7 @@ function authorizeMetrics(request) {
   if (expected) {
     return presented.length > 0 && tokensMatch(presented, expected);
   }
-  if ((process.env.APP_ENV ?? "local") === "production") {
+  if (isProductionEnv()) {
     return false;
   }
   return true;

package/dist/entries/providers.js

@@ -14,7 +14,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/config.ts
@@ -50,7 +50,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) {
@@ -95,7 +95,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"
 };

package/dist/entries/schedule.js

@@ -14,8 +14,8 @@ function readFeatureFlags() {
     samlLogin: (process.env.FEATURE_SAML ?? "false") === "true",
     scim: (process.env.FEATURE_SCIM ?? "true") !== "false",
     billing: (process.env.FEATURE_BILLING ?? "true") !== "false",
-    siemExport: (process.env.FEATURE_SIEM_EXPORT ?? "true") !== "false",
-    publicReads: (process.env.FEATURE_PUBLIC_READS ?? "true") !== "false",
+    siemExport: (process.env.FEATURE_SIEM_EXPORT ?? "false") === "true",
+    publicReads: (process.env.FEATURE_PUBLIC_READS ?? "false") === "true",
     emailVerification: (process.env.FEATURE_EMAIL_VERIFICATION ?? "false") === "true",
     mfa: (process.env.FEATURE_MFA ?? "false") === "true",
     registration: (process.env.FEATURE_REGISTRATION ?? "true") !== "false"

package/dist/entries/secretsGuard.js

@@ -1,7 +1,15 @@
 // @bun
 // ../../src/bootstrap/secretsGuard.ts
+import { getDefaultDatabasePool } from "@getstrata/core/database/defaultConnection";
 import { envFlagEnabled, 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";
@@ -22,8 +30,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) {
@@ -34,7 +45,11 @@ function isTokenAuthEnabled(env) {
   return Boolean(env.ADMIN_API_TOKEN?.trim()) || Boolean(env.MEMBER_API_TOKEN?.trim()) || envFlagEnabled(env.FEATURE_API_TOKENS);
 }
 function isOAuthEnabled(env) {
-  return envFlagEnabled(env.FEATURE_OAUTH) || envFlagEnabled(env.FEATURE_SAML) || Boolean(env.GITHUB_CLIENT_ID?.trim()) || Boolean(env.OIDC_ISSUER?.trim()) || Boolean(env.SAML_LOGIN_URL?.trim());
+  return envFlagEnabled(env.FEATURE_OAUTH) || envFlagEnabled(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;
@@ -77,8 +92,27 @@ function assertFeatureProductionSecrets(env) {
       throw new Error("Production startup blocked: rotate SCIM_BEARER_TOKEN away from published test defaults.");
     }
   }
-  if (envFlagEnabled(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 ((envFlagEnabled(env.FEATURE_FIELD_ENCRYPTION) || envFlagEnabled(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 (envFlagEnabled(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 (envFlagEnabled(env.UPLOAD_ALLOW_UNKNOWN_MIME)) {
+    throw new Error("Production startup blocked: set UPLOAD_ALLOW_UNKNOWN_MIME=false (unknown MIME types are not allowed).");
   }
   if (envFlagEnabled(env.FEATURE_BILLING) && !env.STRIPE_WEBHOOK_SECRET?.trim()) {
     throw new Error("Production startup blocked: set STRIPE_WEBHOOK_SECRET when billing webhooks are enabled.");
@@ -100,6 +134,61 @@ function assertFeatureProductionSecrets(env) {
   }
 }
 var LOCAL_HOSTS = new Set(["localhost", "127.0.0.1", "0.0.0.0", "::1", "[::1]"]);
+var livePostgresRoleInspector = null;
+function setLivePostgresRoleInspectorForTests(inspect) {
+  livePostgresRoleInspector = inspect;
+}
+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.`);
+  }
+}
+async function defaultInspectLivePostgresRole() {
+  return await inspectCurrentPostgresRole(getDefaultDatabasePool());
+}
+async function assertRlsLiveDatabaseRole(env = process.env, inspect) {
+  if (!isRlsTenancy(env)) {
+    return;
+  }
+  const runtime = rlsRuntimeDatabaseUrl(env);
+  if (!runtime || !isPostgresUrl(runtime.raw)) {
+    return;
+  }
+  const source = runtime.name;
+  assertRlsUsesAppDatabaseRole(env);
+  let role;
+  try {
+    role = await (inspect ?? livePostgresRoleInspector ?? defaultInspectLivePostgresRole)();
+  } catch {
+    throw new Error(`TENANCY_DRIVER=rls startup blocked: could not inspect the live Postgres role for ${source}.`);
+  }
+  assertPostgresRoleCannotBypassRls(role, source);
+}
 function assertPublicAppUrl(env) {
   const raw = env.APP_URL?.trim() ?? "";
   let url = null;
@@ -122,6 +211,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);
   }
@@ -129,7 +221,10 @@ function assertProductionSecrets(env = process.env) {
   if (isViewsMode(parseFrontendMode(env.FRONTEND_MODE))) {
     assertSessionSecret(env);
   }
+  assertRlsUsesAppDatabaseRole(env);
 }
 export {
-  assertProductionSecrets
+  assertProductionSecrets,
+  assertRlsLiveDatabaseRole,
+  setLivePostgresRoleInspectorForTests
 };

package/dist/entries/web/routing.js

@@ -144,8 +144,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() ?? "";
@@ -155,7 +156,8 @@ class HttpKernel {
             createMemoryThrottleMiddleware({
               maxAttempts: Number.isFinite(maxAttempts) ? maxAttempts : 120,
               decaySeconds: 60
-            })
+            }),
+            csrf
           ];
         }
         const maxAttempts = Number(process.env.RATE_LIMIT_PER_MINUTE ?? "120");
@@ -164,7 +166,8 @@ class HttpKernel {
             redisUrl,
             maxAttempts: Number.isFinite(maxAttempts) ? maxAttempts : 120,
             decaySeconds: 60
-          })
+          }),
+          csrf
         ];
       }
       default:
@@ -174,13 +177,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));
@@ -289,41 +293,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) {

package/dist/entries/web/server.js

@@ -1,6 +1,7 @@
 // @bun
 // ../../src/bootstrap/web/server.ts
 import { currentRequestMeta, runWithRequestMeta } from "@getstrata/core/http/requestMetaContext";
+import { assertUrlPathUnderRoot } from "@getstrata/core/security/safePath";
 import { notFoundHtmlResponse } from "@getstrata/core/view";
 function socketAddress(server, request) {
   const address = server?.requestIP(request)?.address;
@@ -60,9 +61,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 = assertUrlPathUnderRoot(publicDir, url.pathname);
+            const file = Bun.file(filePath);
+            if (await file.exists()) {
+              return new Response(file);
+            }
+          } catch {
+            return await missingHtmlResponse();
           }
         }
         if (options.handle) {

package/dist/entries/web/session.js

@@ -2,13 +2,22 @@
 // ../../src/bootstrap/web/session.ts
 import { createHmac, randomBytes } from "crypto";
 import { AuthManager } from "@getstrata/core/auth/guard";
+import { isSessionInvalidated } from "@getstrata/core/auth/sessionCookie";
 import { getBoundDatabaseConnection } from "@getstrata/core/database/boundConnection";
-import { getDefaultDatabasePool } from "@getstrata/core/database/defaultConnection";
+import {
+  getActiveDatabaseConnection,
+  hasActiveDatabaseConnection
+} from "@getstrata/core/database/connectionContext";
+import {
+  getDefaultDatabasePool,
+  getDefaultDatabaseQuery
+} from "@getstrata/core/database/defaultConnection";
 import { currentSqlDialect, sqlTimestamp } from "@getstrata/core/database/dialect";
 import { readRequestCookie } from "@getstrata/core/http/cookies";
 import { currentRequestMeta } from "@getstrata/core/http/requestMetaContext";
 import { isProductionEnv } 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);
 }
@@ -19,10 +28,18 @@ 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;
   }
-  return source();
+  try {
+    if (client === getDefaultDatabasePool() || client === getDefaultDatabaseQuery()) {
+      return getActiveDatabaseConnection(client);
+    }
+  } catch {
+    return client;
+  }
+  return client;
 }
 function defaultSessionSql() {
   const bound = getBoundDatabaseConnection();
@@ -59,14 +76,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, {
@@ -121,25 +156,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);