@getstrata/bootstrap 0.2.26 → 0.2.28

package/dist/entries/dependencies.js

@@ -284,6 +284,25 @@ function getDb() {
   getDatabase();
   return getDefaultDatabaseQuery();
 }
+async function pingDatabase(connection = getDatabase()) {
+  try {
+    await connection`SELECT 1`;
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensureDatabaseConnection() {
+  if (await pingDatabase()) {
+    return getDatabase();
+  }
+  await getDatabase().close().catch(() => {
+    return;
+  });
+  connectionHolder.connection = createDatabaseConnection(databaseConfig);
+  registerDefaultDatabasePool(connectionHolder.connection);
+  return getDatabase();
+}
 var db = new Proxy(function database() {}, {
   apply(_target, _thisArg, args) {
     return getDb()(...args);
@@ -1393,25 +1412,117 @@ function discoverListeners() {
   return appListeners;
 }
 
-// ../../src/core/queue/index.ts
-class Job {
-  maxAttempts;
-  backoffMs;
-  priority;
+// ../../src/bootstrap/listeners/invalidateCacheOnModelWrite.ts
+import { eventBus as eventBus2, modelEventName as modelEventName2 } from "@getstrata/core/events";
+import InvalidateCacheTagsJob from "@getstrata/core/jobs/invalidateCacheTagsJob";
+import { createTrackedJob } from "@getstrata/core/queue/createAppQueue";
+
+// ../../src/bootstrap/cache/modelCacheTags.ts
+function cacheTagsForModelWrite(tableName, action) {
+  const module = discoverModules().find((entry) => entry.tableName === tableName);
+  const baseTags = module?.cacheTags ?? [`${tableName}s`];
+  const isDelete = action === "deleted" || action === "force-deleted";
+  const extraTags = isDelete ? module?.cacheDeleteExtraTags ?? [] : [];
+  return [...new Set([...baseTags, ...extraTags])];
+}
+function discoverModelTableNames() {
+  return discoverModules().map((module) => module.tableName).filter((tableName) => tableName !== undefined);
 }
 
-// ../../src/core/jobs/invalidateCacheTagsJob.ts
-class InvalidateCacheTagsJob extends Job {
-  cache;
-  constructor(cache) {
-    super();
-    this.cache = cache;
+// ../../src/bootstrap/listeners/invalidateCacheOnModelWrite.ts
+var MODEL_WRITE_ACTIONS = ["created", "updated", "deleted", "restored", "force-deleted"];
+function registerInvalidateCacheOnModelWriteListeners(bus = eventBus2) {
+  for (const tableName of discoverModelTableNames()) {
+    for (const action of MODEL_WRITE_ACTIONS) {
+      bus.listen(modelEventName2(tableName, action), async () => {
+        const tags = cacheTagsForModelWrite(tableName, action);
+        if (tags.length === 0) {
+          return;
+        }
+        let cache;
+        let queue;
+        try {
+          cache = resolveApplicationCache();
+          queue = resolveApplicationQueue();
+        } catch {
+          return;
+        }
+        const job = createTrackedJob("cache.invalidate-tags", new InvalidateCacheTagsJob(cache));
+        await queue.dispatch(job, { tags });
+      });
+    }
   }
-  async handle(payload) {
-    await this.cache.tags(...payload.tags).flush();
+}
+
+// ../../src/bootstrap/providers/listeners.ts
+var registeredListenerGroups = new Set;
+function registerListenerGroup(name, register) {
+  if (registeredListenerGroups.has(name)) {
+    return;
   }
+  registeredListenerGroups.add(name);
+  register();
 }
-var invalidateCacheTagsJob_default = InvalidateCacheTagsJob;
+var listenersProvider = {
+  name: "core.listeners",
+  boot() {
+    registerListenerGroup("cache.invalidate-on-model-write", () => {
+      registerInvalidateCacheOnModelWriteListeners();
+    });
+    for (const [index, registerListener] of discoverListeners().entries()) {
+      registerListenerGroup(`app.listener.${index}`, registerListener);
+    }
+  }
+};
+var listeners_default = listenersProvider;
+
+// ../../src/core/auth/policy.ts
+var BLOCKED_POLICY_ACTIONS = new Set([
+  "constructor",
+  "toString",
+  "valueOf",
+  "hasOwnProperty",
+  "isPrototypeOf",
+  "propertyIsEnumerable",
+  "__proto__"
+]);
+
+class PolicyGate {
+  constructor() {}
+  policies = new Map;
+  register(resource, policy) {
+    this.policies.set(resource, policy);
+  }
+  allows(resource, action, user, model) {
+    const policy = this.policies.get(resource);
+    if (!policy) {
+      return false;
+    }
+    if (BLOCKED_POLICY_ACTIONS.has(action) || !(action in policy)) {
+      return false;
+    }
+    const handler = policy[action];
+    if (typeof handler !== "function") {
+      return false;
+    }
+    const resolvedUser = user === undefined ? currentAuthUser() : user;
+    return model === undefined ? handler.call(policy, resolvedUser) : handler.call(policy, resolvedUser, model);
+  }
+  authorize(resource, action, user, model) {
+    if (!this.allows(resource, action, user, model)) {
+      throw new ForbiddenError2;
+    }
+  }
+}
+
+// ../../src/bootstrap/providers/policy.ts
+var policyProvider = {
+  name: "core.policy",
+  register({ container }) {
+    container.set(CORE_POLICY_GATE_TOKEN, new PolicyGate);
+  }
+};
+var policy_default = policyProvider;
 
 // ../../src/core/pagination/index.ts
 function buildPaginationMeta(input) {
@@ -3299,9 +3410,6 @@ class ResilientQueue {
 function createFailedJobService() {
   return new failedJobService_default(new failedJobRepository_default);
 }
-function createTrackedJob(name, job) {
-  return jobRegistry.track(name, job);
-}
 function createProductionQueue(driver, options = {}) {
   options.registerJobs?.();
   const failedJobs = options.failedJobs ?? createFailedJobService();
@@ -3324,116 +3432,16 @@ function createAppQueue(driver, redisUrl, failedJobs = createFailedJobService(),
   });
 }
 
-// ../../src/bootstrap/cache/modelCacheTags.ts
-function cacheTagsForModelWrite(tableName, action) {
-  const module = discoverModules().find((entry) => entry.tableName === tableName);
-  const baseTags = module?.cacheTags ?? [`${tableName}s`];
-  const isDelete = action === "deleted" || action === "force-deleted";
-  const extraTags = isDelete ? module?.cacheDeleteExtraTags ?? [] : [];
-  return [...new Set([...baseTags, ...extraTags])];
-}
-function discoverModelTableNames() {
-  return discoverModules().map((module) => module.tableName).filter((tableName) => tableName !== undefined);
-}
-
-// ../../src/bootstrap/listeners/invalidateCacheOnModelWrite.ts
-var MODEL_WRITE_ACTIONS = ["created", "updated", "deleted", "restored", "force-deleted"];
-function registerInvalidateCacheOnModelWriteListeners(bus = eventBus) {
-  for (const tableName of discoverModelTableNames()) {
-    for (const action of MODEL_WRITE_ACTIONS) {
-      bus.listen(modelEventName(tableName, action), async () => {
-        const tags = cacheTagsForModelWrite(tableName, action);
-        if (tags.length === 0) {
-          return;
-        }
-        let cache;
-        let queue;
-        try {
-          cache = resolveApplicationCache();
-          queue = resolveApplicationQueue();
-        } catch {
-          return;
-        }
-        const job = createTrackedJob("cache.invalidate-tags", new invalidateCacheTagsJob_default(cache));
-        await queue.dispatch(job, { tags });
-      });
-    }
-  }
-}
-
-// ../../src/bootstrap/providers/listeners.ts
-var registeredListenerGroups = new Set;
-function registerListenerGroup(name, register) {
-  if (registeredListenerGroups.has(name)) {
-    return;
-  }
-  registeredListenerGroups.add(name);
-  register();
-}
-var listenersProvider = {
-  name: "core.listeners",
-  boot() {
-    registerListenerGroup("cache.invalidate-on-model-write", () => {
-      registerInvalidateCacheOnModelWriteListeners();
-    });
-    for (const [index, registerListener] of discoverListeners().entries()) {
-      registerListenerGroup(`app.listener.${index}`, registerListener);
-    }
-  }
-};
-var listeners_default = listenersProvider;
-
-// ../../src/core/auth/policy.ts
-var BLOCKED_POLICY_ACTIONS = new Set([
-  "constructor",
-  "toString",
-  "valueOf",
-  "hasOwnProperty",
-  "isPrototypeOf",
-  "propertyIsEnumerable",
-  "__proto__"
-]);
-
-class PolicyGate {
-  constructor() {}
-  policies = new Map;
-  register(resource, policy) {
-    this.policies.set(resource, policy);
-  }
-  allows(resource, action, user, model) {
-    const policy = this.policies.get(resource);
-    if (!policy) {
-      return false;
-    }
-    if (BLOCKED_POLICY_ACTIONS.has(action) || !(action in policy)) {
-      return false;
-    }
-    const handler = policy[action];
-    if (typeof handler !== "function") {
-      return false;
-    }
-    const resolvedUser = user === undefined ? currentAuthUser() : user;
-    return model === undefined ? handler.call(policy, resolvedUser) : handler.call(policy, resolvedUser, model);
-  }
-  authorize(resource, action, user, model) {
-    if (!this.allows(resource, action, user, model)) {
-      throw new ForbiddenError2;
-    }
-  }
-}
-
-// ../../src/bootstrap/providers/policy.ts
-var policyProvider = {
-  name: "core.policy",
-  register({ container }) {
-    container.set(CORE_POLICY_GATE_TOKEN, new PolicyGate);
-  }
-};
-var policy_default = policyProvider;
-
 // ../../src/core/jobs/dispatchWebhookJob.ts
 import { createHmac as createHmac2 } from "crypto";
 
+// ../../src/core/queue/index.ts
+class Job {
+  maxAttempts;
+  backoffMs;
+  priority;
+}
+
 // ../../src/core/security/safeUrl.ts
 import { lookup as dnsLookupImpl } from "dns/promises";
 var dnsLookup = dnsLookupImpl;
@@ -3618,6 +3626,19 @@ class DispatchWebhookJob extends Job {
 }
 var dispatchWebhookJob_default = DispatchWebhookJob;
 
+// ../../src/core/jobs/invalidateCacheTagsJob.ts
+class InvalidateCacheTagsJob2 extends Job {
+  cache;
+  constructor(cache) {
+    super();
+    this.cache = cache;
+  }
+  async handle(payload) {
+    await this.cache.tags(...payload.tags).flush();
+  }
+}
+var invalidateCacheTagsJob_default = InvalidateCacheTagsJob2;
+
 // ../../src/core/contracts/di.ts
 function getRequiredDependency2(dependencies, key) {
   const dependency = dependencies[key];
@@ -3855,6 +3876,9 @@ function readFrontendMode() {
 function isViewsEnabled() {
   return readFrontendMode() === "server-htmx";
 }
+function isSpaEnabled() {
+  return readFrontendMode() === "spa-react";
+}
 
 // ../../src/core/http/requestMetaContext.ts
 var requestMetaContext = createAsyncContextStore("@getstrata/requestMetaContext");

package/dist/entries/health.js

@@ -0,0 +1,212 @@
+// @bun
+// ../../src/bootstrap/health.ts
+import { jsonResponse } from "@getstrata/core/http";
+var {RedisClient } = globalThis.Bun;
+
+// ../../src/config/database.ts
+function readInteger(name, fallback) {
+  const parsed = Number.parseInt(process.env[name] ?? String(fallback), 10);
+  return Number.isInteger(parsed) && parsed >= 0 ? parsed : fallback;
+}
+var databaseConfig = {
+  url: process.env.DATABASE_URL ?? "",
+  poolMax: readInteger("DB_POOL_MAX", 10),
+  idleTimeoutSeconds: readInteger("DB_POOL_IDLE_TIMEOUT", 30),
+  maxLifetimeSeconds: readInteger("DB_POOL_MAX_LIFETIME", 3600),
+  connectionTimeoutSeconds: readInteger("DB_CONNECTION_TIMEOUT", 10)
+};
+
+// ../../src/core/runtime/asyncContextStore.ts
+import { AsyncLocalStorage } from "async_hooks";
+function createAsyncContextStore(key) {
+  const symbol = Symbol.for(key);
+  const globalRecord = globalThis;
+  const existing = globalRecord[symbol];
+  if (existing) {
+    return existing;
+  }
+  const store = new AsyncLocalStorage;
+  globalRecord[symbol] = store;
+  return store;
+}
+
+// ../../src/core/database/connectionContext.ts
+var activeConnection = createAsyncContextStore("@getstrata/databaseConnectionContext");
+function getActiveDatabaseConnection(fallback) {
+  return activeConnection.getStore() ?? fallback;
+}
+
+// ../../src/core/database/queryProxy.ts
+var POOL_CONNECTION_METHODS = new Set(["begin", "close", "connect"]);
+function createDatabaseQueryProxy(pool) {
+  function resolveDatabase() {
+    return getActiveDatabaseConnection(pool);
+  }
+  function resolveDatabaseForProperty(property) {
+    if (typeof property === "string" && POOL_CONNECTION_METHODS.has(property)) {
+      return pool;
+    }
+    return resolveDatabase();
+  }
+  return new Proxy(function database() {}, {
+    apply(_target, _thisArg, args) {
+      return resolveDatabase()(...args);
+    },
+    get(_target, property) {
+      const connection = resolveDatabaseForProperty(property);
+      const value = connection[property];
+      return typeof value === "function" ? value.bind(connection) : value;
+    }
+  });
+}
+
+// ../../src/core/database/defaultConnection.ts
+var defaultPool = {
+  connection: null
+};
+var defaultQuery = {
+  connection: null
+};
+function registerDefaultDatabasePool(connection) {
+  defaultPool.connection = connection;
+  defaultQuery.connection = createDatabaseQueryProxy(connection);
+}
+function getDefaultDatabaseQuery() {
+  if (!defaultQuery.connection) {
+    throw new Error("Default database query handle is not registered. Call registerDefaultDatabasePool() during app bootstrap.");
+  }
+  return defaultQuery.connection;
+}
+
+// ../../src/db/connection/createConnection.ts
+var {SQL } = globalThis.Bun;
+function createDatabaseConnection(config) {
+  if (!config.url) {
+    throw new Error("DATABASE_URL is not configured. Set DATABASE_URL before starting the app or running integration tests.");
+  }
+  return new SQL({
+    url: config.url,
+    max: config.poolMax,
+    idleTimeout: config.idleTimeoutSeconds,
+    maxLifetime: config.maxLifetimeSeconds,
+    connectionTimeout: config.connectionTimeoutSeconds
+  });
+}
+
+// ../../src/db/connection/index.ts
+var connectionHolder = {
+  connection: null
+};
+function getDatabase() {
+  if (!connectionHolder.connection) {
+    connectionHolder.connection = createDatabaseConnection(databaseConfig);
+    registerDefaultDatabasePool(connectionHolder.connection);
+  }
+  return connectionHolder.connection;
+}
+function getDb() {
+  getDatabase();
+  return getDefaultDatabaseQuery();
+}
+async function pingDatabase(connection = getDatabase()) {
+  try {
+    await connection`SELECT 1`;
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensureDatabaseConnection() {
+  if (await pingDatabase()) {
+    return getDatabase();
+  }
+  await getDatabase().close().catch(() => {
+    return;
+  });
+  connectionHolder.connection = createDatabaseConnection(databaseConfig);
+  registerDefaultDatabasePool(connectionHolder.connection);
+  return getDatabase();
+}
+var db = new Proxy(function database() {}, {
+  apply(_target, _thisArg, args) {
+    return getDb()(...args);
+  },
+  get(_target, property) {
+    const connection = getDb();
+    const value = connection[property];
+    return typeof value === "function" ? value.bind(connection) : value;
+  }
+});
+
+// ../../src/bootstrap/config.ts
+import {
+  CORE_AUTH_TOKEN,
+  CORE_CACHE_TOKEN,
+  CORE_CONFIG_TOKEN,
+  CORE_EVENT_BUS_TOKEN,
+  CORE_POLICY_GATE_TOKEN,
+  CORE_QUEUE_TOKEN,
+  CORE_TOKEN_SERVICE_TOKEN
+} from "@getstrata/core/contracts/serviceTokens";
+var APP_PORT_CONFIG_KEY = "app.port";
+var CACHE_TTL_MS_CONFIG_KEY = "cache.ttlMs";
+var CACHE_MAX_ENTRIES_CONFIG_KEY = "cache.maxEntries";
+var CACHE_DRIVER_CONFIG_KEY = "cache.driver";
+var REDIS_URL_CONFIG_KEY = "cache.redisUrl";
+var DATABASE_URL_CONFIG_KEY = "database.url";
+var AUTH_DEV_HEADERS_CONFIG_KEY = "auth.allowDevHeaders";
+var DEFAULT_APP_PORT = 3000;
+var DEFAULT_CACHE_TTL_MS = 3600000;
+var DEFAULT_CACHE_MAX_ENTRIES = 100;
+var DEFAULT_CACHE_DRIVER = "array";
+var DEFAULT_API_TOKEN = "";
+var DEFAULT_QUEUE_DRIVER = "sync";
+
+// ../../src/bootstrap/health.ts
+function resolveRedisUrl(dependencies) {
+  if (!dependencies.container.has(CORE_CONFIG_TOKEN)) {
+    return process.env.REDIS_URL?.trim() || undefined;
+  }
+  const config = dependencies.container.resolve(CORE_CONFIG_TOKEN);
+  const redisUrl = config.get(REDIS_URL_CONFIG_KEY)?.trim();
+  return redisUrl || undefined;
+}
+async function checkDatabase() {
+  await ensureDatabaseConnection();
+  return await pingDatabase();
+}
+async function checkRedis(redisUrl) {
+  try {
+    const client = new RedisClient(redisUrl);
+    const response = await client.ping();
+    return response === "PONG";
+  } catch {
+    return false;
+  }
+}
+function createHealthRoutes(dependencies) {
+  return {
+    "/health": async () => jsonResponse({ status: "ok" }),
+    "/ready": async () => {
+      const checks = {
+        database: await checkDatabase() ? "ok" : "error"
+      };
+      const redisUrl = resolveRedisUrl(dependencies);
+      if (redisUrl) {
+        checks.redis = await checkRedis(redisUrl) ? "ok" : "error";
+      } else {
+        checks.redis = "skipped";
+      }
+      const ready = checks.database === "ok" && (checks.redis === "ok" || checks.redis === "skipped");
+      return jsonResponse({
+        status: ready ? "ready" : "not_ready",
+        checks
+      }, { status: ready ? 200 : 503 });
+    }
+  };
+}
+export {
+  createHealthRoutes,
+  checkRedis,
+  checkDatabase
+};

package/dist/entries/httpKernel.js

@@ -39,6 +39,9 @@ function readFrontendMode() {
 function isViewsEnabled() {
   return readFrontendMode() === "server-htmx";
 }
+function isSpaEnabled() {
+  return readFrontendMode() === "spa-react";
+}
 
 // ../../src/config/rateLimit.ts
 var LOCAL_LOGIN_RATE_LIMIT = {

package/dist/entries/listeners/invalidateCacheOnModelWrite.js

@@ -0,0 +1,118 @@
+// @bun
+// ../../src/bootstrap/listeners/invalidateCacheOnModelWrite.ts
+import { eventBus, modelEventName } from "@getstrata/core/events";
+import InvalidateCacheTagsJob from "@getstrata/core/jobs/invalidateCacheTagsJob";
+import { createTrackedJob } from "@getstrata/core/queue/createAppQueue";
+
+// ../../src/bootstrap/applicationRegistry.ts
+import {
+  resolveApplicationAuth,
+  resolveApplicationCache,
+  resolveApplicationConfig,
+  resolveApplicationDependencies,
+  resolveApplicationEventBus,
+  resolveApplicationLogger,
+  resolveApplicationPolicyGate,
+  resolveApplicationQueue,
+  setActiveApplicationContext
+} from "@getstrata/core/runtime/applicationRegistry";
+
+// ../../src/bootstrap/discoverModules.ts
+import { readdirSync } from "fs";
+import { join } from "path";
+import { pathToFileURL } from "url";
+var DISCOVER_MODULES_STATE_KEY = Symbol.for("@getstrata/discoverModulesState");
+function readDiscoverModulesState() {
+  const existing = globalThis[DISCOVER_MODULES_STATE_KEY];
+  if (existing) {
+    return existing;
+  }
+  const state = { appModules: [] };
+  globalThis[DISCOVER_MODULES_STATE_KEY] = state;
+  return state;
+}
+function configureModulesDirectory(modulesDir) {
+  readDiscoverModulesState().configuredModulesDir = modulesDir;
+}
+function resolveModulesDirectory(options) {
+  const state = readDiscoverModulesState();
+  if (options?.modulesDir) {
+    return options.modulesDir;
+  }
+  if (state.configuredModulesDir) {
+    return state.configuredModulesDir;
+  }
+  return join(import.meta.dir, "../modules");
+}
+async function loadDiscoveredModules(options) {
+  const modulesDirectory = resolveModulesDirectory(options);
+  let moduleNames;
+  try {
+    moduleNames = readdirSync(modulesDirectory, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+  const modules = await Promise.all(moduleNames.map(async (moduleName) => {
+    const moduleUrl = pathToFileURL(join(modulesDirectory, moduleName, "index.ts")).href;
+    const loaded = await import(moduleUrl);
+    return loaded.default;
+  }));
+  return modules.filter((module) => module?.name !== undefined).sort((left, right) => (left.order ?? 100) - (right.order ?? 100));
+}
+async function ensureModulesLoaded(options) {
+  const state = readDiscoverModulesState();
+  if (state.appModules.length > 0) {
+    return state.appModules;
+  }
+  state.modulesReady ??= loadDiscoveredModules(options).then((modules) => {
+    state.appModules.splice(0, state.appModules.length, ...modules);
+    return state.appModules;
+  });
+  return state.modulesReady;
+}
+function discoverModules() {
+  return readDiscoverModulesState().appModules;
+}
+
+// ../../src/bootstrap/cache/modelCacheTags.ts
+function cacheTagsForModelWrite(tableName, action) {
+  const module = discoverModules().find((entry) => entry.tableName === tableName);
+  const baseTags = module?.cacheTags ?? [`${tableName}s`];
+  const isDelete = action === "deleted" || action === "force-deleted";
+  const extraTags = isDelete ? module?.cacheDeleteExtraTags ?? [] : [];
+  return [...new Set([...baseTags, ...extraTags])];
+}
+function discoverModelTableNames() {
+  return discoverModules().map((module) => module.tableName).filter((tableName) => tableName !== undefined);
+}
+
+// ../../src/bootstrap/listeners/invalidateCacheOnModelWrite.ts
+var MODEL_WRITE_ACTIONS = ["created", "updated", "deleted", "restored", "force-deleted"];
+function registerInvalidateCacheOnModelWriteListeners(bus = eventBus) {
+  for (const tableName of discoverModelTableNames()) {
+    for (const action of MODEL_WRITE_ACTIONS) {
+      bus.listen(modelEventName(tableName, action), async () => {
+        const tags = cacheTagsForModelWrite(tableName, action);
+        if (tags.length === 0) {
+          return;
+        }
+        let cache;
+        let queue;
+        try {
+          cache = resolveApplicationCache();
+          queue = resolveApplicationQueue();
+        } catch {
+          return;
+        }
+        const job = createTrackedJob("cache.invalidate-tags", new InvalidateCacheTagsJob(cache));
+        await queue.dispatch(job, { tags });
+      });
+    }
+  }
+}
+export {
+  registerInvalidateCacheOnModelWriteListeners
+};

package/dist/entries/metricsRoutes.js

@@ -0,0 +1,16 @@
+// @bun
+// ../../src/bootstrap/metricsRoutes.ts
+import { prometheusRegistry } from "@getstrata/core/metrics/prometheus";
+function createMetricsRoutes() {
+  return {
+    "/metrics": async () => new Response(prometheusRegistry.renderMetrics(), {
+      status: 200,
+      headers: {
+        "content-type": "text/plain; version=0.0.4; charset=utf-8"
+      }
+    })
+  };
+}
+export {
+  createMetricsRoutes
+};