@getstrata/bootstrap 0.2.26 → 0.2.29

package/dist/entries/discoverModules.js

@@ -1,4 +1,6 @@
 // @bun
+var __jsonParse = (a) => JSON.parse(a);
+
 // ../../src/bootstrap/discoverModules.ts
 import { readdirSync } from "fs";
 import { join } from "path";

package/dist/entries/health.js

@@ -0,0 +1,215 @@
+// @bun
+var __jsonParse = (a) => JSON.parse(a);
+
+// ../../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;
+  }
+});
+var connection_default = db;
+
+// ../../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/http/securedRouteModelBinding.js

@@ -1,298 +1,11 @@
 // @bun
-// ../../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;
-}
+var __jsonParse = (a) => JSON.parse(a);
 
-// ../../src/core/auth/authContext.ts
-var authContext = createAsyncContextStore("@getstrata/authContext");
-function currentAuthUser() {
-  return authContext.getStore() ?? null;
-}
-
-// ../../src/core/errors/http.ts
-class HttpError extends Error {
-  status;
-  details;
-  constructor(status, message, details) {
-    super(message);
-    this.name = new.target.name;
-    this.status = status;
-    this.details = details;
-  }
-}
-
-class BadRequestError extends HttpError {
-  constructor(message = "Bad Request", details) {
-    super(400, message, details);
-  }
-}
-class ConflictError extends HttpError {
-  constructor(message = "Conflict", details) {
-    super(409, message, details);
-  }
-}
-
-class UnprocessableEntityError extends HttpError {
-  constructor(message = "Unprocessable Entity", details) {
-    super(422, message, details);
-  }
-}
-class ForbiddenError extends HttpError {
-  constructor(message = "Forbidden", details) {
-    super(403, message, details);
-  }
-}
-
-class UnauthorizedError extends HttpError {
-  constructor(message = "Unauthorized", details) {
-    super(401, message, details);
-  }
-}
-class PreconditionFailedError extends HttpError {
-  constructor(message = "Precondition Failed", details) {
-    super(412, message, details);
-  }
-}
-
-// ../../src/core/contracts/di.ts
-function getRequiredDependency(dependencies, key) {
-  const dependency = dependencies[key];
-  if (dependency === undefined) {
-    throw new Error(`Required dependency "${key}" is not registered.`);
-  }
-  return dependency;
-}
-
-// ../../src/core/contracts/serviceTokens.ts
-var CORE_POLICY_GATE_TOKEN = "core.policyGate";
-var CORE_AUTH_TOKEN = "core.auth";
-
-// ../../src/core/logging/logger.ts
-class Logger {
-  channel;
-  constructor(channel = "app") {
-    this.channel = channel;
-  }
-  write(level, message, context = {}) {
-    const entry = {
-      level,
-      channel: this.channel,
-      message,
-      timestamp: new Date().toISOString(),
-      ...context
-    };
-    const line = JSON.stringify(entry);
-    if (level === "error") {
-      console.error(line);
-      return;
-    }
-    console.log(line);
-  }
-  debug(message, context) {
-    this.write("debug", message, context);
-  }
-  info(message, context) {
-    this.write("info", message, context);
-  }
-  warn(message, context) {
-    this.write("warn", message, context);
-  }
-  error(message, context) {
-    this.write("error", message, context);
-  }
-}
-var appLogger = new Logger("app");
-
-// ../../src/core/runtime/applicationRegistry.ts
-var APPLICATION_CONTEXT_KEY = Symbol.for("@getstrata/applicationContext");
-var activeContext;
-function readStoredApplicationContext() {
-  if (activeContext) {
-    return activeContext;
-  }
-  const globalContext = globalThis[APPLICATION_CONTEXT_KEY];
-  if (globalContext) {
-    activeContext = globalContext;
-  }
-  return activeContext;
-}
-function requireActiveApplicationContext() {
-  const context = readStoredApplicationContext();
-  if (!context) {
-    throw new Error("The application context has not been bootstrapped.");
-  }
-  return context;
-}
-function resolveApplicationCache() {
-  return getRequiredDependency(requireActiveApplicationContext().dependencies, "cache");
-}
-function resolveApplicationAuth() {
-  return requireActiveApplicationContext().container.resolve(CORE_AUTH_TOKEN);
-}
-function resolveApplicationPolicyGate() {
-  return requireActiveApplicationContext().container.resolve(CORE_POLICY_GATE_TOKEN);
-}
-
-// ../../src/core/crypto/nonCryptographicHash.ts
-function nonCryptographicDigest(input) {
-  return Bun.hash(input).toString(16);
-}
-
-// ../../src/core/http/etag.ts
-function isEtagEnabled() {
-  return (process.env.FEATURE_ETAG ?? "true") !== "false";
-}
-function formatWeakEtag(digest) {
-  return `W/"${digest}"`;
-}
-function etagFromResource(resource) {
-  const version = resource.updated_at ?? resource.created_at ?? "";
-  const versionText = version instanceof Date ? version.toISOString() : version ? String(version) : "0";
-  const digest = nonCryptographicDigest(`${String(resource.id ?? "0")}:${versionText}`).slice(0, 32);
-  return formatWeakEtag(digest);
-}
-function normalizeEtag(value) {
-  return value.trim();
-}
-function etagValuesMatch(left, right) {
-  return normalizeEtag(left) === normalizeEtag(right);
-}
-function parseEtagList(header) {
-  if (!header) {
-    return [];
-  }
-  return header.split(",").map((value) => normalizeEtag(value)).filter(Boolean);
-}
-function ifNoneMatchSatisfied(request, etag) {
-  const header = request.headers.get("if-none-match");
-  if (!header) {
-    return false;
-  }
-  if (header.trim() === "*") {
-    return true;
-  }
-  return parseEtagList(header).some((candidate) => etagValuesMatch(candidate, etag));
-}
-function ifMatchSatisfied(request, etag) {
-  const header = request.headers.get("if-match");
-  if (!header) {
-    return false;
-  }
-  if (header.trim() === "*") {
-    return true;
-  }
-  return parseEtagList(header).some((candidate) => etagValuesMatch(candidate, etag));
-}
-function assertIfMatch(request, etag, options = {}) {
-  const header = request.headers.get("if-match");
-  if (!header) {
-    if (options.required) {
-      throw new PreconditionFailedError("If-Match header is required.");
-    }
-    return;
-  }
-  if (!ifMatchSatisfied(request, etag)) {
-    throw new PreconditionFailedError("Resource ETag does not match If-Match.");
-  }
-}
-function applyEtagHeaders(headers, etag) {
-  const next = new Headers(headers);
-  next.set("ETag", etag);
-  next.set("Cache-Control", "private, must-revalidate");
-  next.append("Vary", "Authorization");
-  next.append("Vary", "X-Tenant-Id");
-  return next;
-}
-function notModifiedResponse(etag) {
-  return new Response(null, {
-    status: 304,
-    headers: applyEtagHeaders(new Headers, etag)
-  });
-}
-function applyConditionalGet(request, response, etag) {
-  if (!isEtagEnabled()) {
-    return response;
-  }
-  if (ifNoneMatchSatisfied(request, etag)) {
-    return notModifiedResponse(etag);
-  }
-  const headers = applyEtagHeaders(new Headers(response.headers), etag);
-  return new Response(response.body, {
-    status: response.status,
-    statusText: response.statusText,
-    headers
-  });
-}
-
-// ../../src/core/tenant/tenantContext.ts
-var tenantContext = createAsyncContextStore("@getstrata/tenantContext");
-
-// ../../src/core/http/validation.ts
-function parsePositiveIntParam(value, name = "id") {
-  const parsed = Number.parseInt(value, 10);
-  if (!Number.isInteger(parsed) || parsed <= 0) {
-    throw new BadRequestError(`Invalid ${name}. Expected a positive integer.`);
-  }
-  return parsed;
-}
-
-// ../../src/core/http/securedRouteModelBinding.ts
-function isMutatingPolicyAction(action) {
-  return action === "update" || action === "delete";
-}
-function securedBindRouteModel(param, resolver, authorization, handler) {
-  return async (request) => {
-    const id = parsePositiveIntParam(String(request.params[param]), String(param));
-    const model = await resolver(id, request);
-    const gate = resolveApplicationPolicyGate();
-    const auth = resolveApplicationAuth();
-    const user = currentAuthUser() ?? await auth.resolve(request);
-    gate.authorize(authorization.resource, authorization.action, user, model);
-    if (isEtagEnabled() && isMutatingPolicyAction(authorization.action)) {
-      assertIfMatch(request, etagFromResource(model), {
-        required: authorization.requireIfMatch ?? true
-      });
-    }
-    const response = await handler(request, model);
-    if (isEtagEnabled() && authorization.action === "view") {
-      return applyConditionalGet(request, response, etagFromResource(model));
-    }
-    return response;
-  };
-}
-function securedBindRouteModelByKey(param, resolver, authorization, handler) {
-  return async (request) => {
-    const key = String(request.params[param] ?? "").trim();
-    if (!key) {
-      throw new BadRequestError(`Missing route parameter "${String(param)}".`);
-    }
-    const model = await resolver(key, request);
-    const gate = resolveApplicationPolicyGate();
-    const auth = resolveApplicationAuth();
-    const user = currentAuthUser() ?? await auth.resolve(request);
-    gate.authorize(authorization.resource, authorization.action, user, model);
-    if (isEtagEnabled() && isMutatingPolicyAction(authorization.action)) {
-      assertIfMatch(request, etagFromResource(model), {
-        required: authorization.requireIfMatch ?? true
-      });
-    }
-    const response = await handler(request, model);
-    if (isEtagEnabled() && authorization.action === "view") {
-      return applyConditionalGet(request, response, etagFromResource(model));
-    }
-    return response;
-  };
-}
+// ../../src/bootstrap/http/securedRouteModelBinding.ts
+import {
+  securedBindRouteModel,
+  securedBindRouteModelByKey
+} from "@getstrata/core/http/securedRouteModelBinding";
 export {
   securedBindRouteModelByKey,
   securedBindRouteModel

package/dist/entries/httpKernel.js

@@ -1,4 +1,6 @@
 // @bun
+var __jsonParse = (a) => JSON.parse(a);
+
 // ../../src/bootstrap/httpKernel.ts
 import {
   createAuthMiddleware,
@@ -39,6 +41,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,120 @@
+// @bun
+var __jsonParse = (a) => JSON.parse(a);
+
+// ../../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/membershipService.js

@@ -1,4 +1,6 @@
 // @bun
+var __jsonParse = (a) => JSON.parse(a);
+
 // ../../src/bootstrap/membershipService.ts
 import { resolveMembershipService } from "@getstrata/core/auth/membershipService";
 export {

package/dist/entries/metricsRoutes.js

@@ -0,0 +1,18 @@
+// @bun
+var __jsonParse = (a) => JSON.parse(a);
+
+// ../../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
+};