@getstrata/bootstrap 2.0.9 → 2.2.0

package/dist/entries/buildModuleRoutes.js

@@ -50,8 +50,11 @@ import {
   CORE_CACHE_TOKEN,
   CORE_CONFIG_TOKEN,
   CORE_EVENT_BUS_TOKEN,
+  CORE_HTTP_CLEANUP_TOKEN,
   CORE_POLICY_GATE_TOKEN,
   CORE_QUEUE_TOKEN,
+  CORE_TENANT_RESOLVER_TOKEN,
+  CORE_THROTTLE_QUOTA_POLICY_TOKEN,
   CORE_TOKEN_SERVICE_TOKEN
 } from "@getstrata/core/contracts/serviceTokens";
 var APP_PORT_CONFIG_KEY = "app.port";
@@ -117,8 +120,39 @@ function resolveRegisterRateLimit() {
 // ../../src/bootstrap/httpKernel.ts
 class HttpKernel {
   dependencies;
+  ownedThrottles = new Set;
+  disposed = false;
   constructor(dependencies) {
     this.dependencies = dependencies;
+    if (dependencies.container.has(CORE_HTTP_CLEANUP_TOKEN)) {
+      dependencies.container.resolve(CORE_HTTP_CLEANUP_TOKEN)(() => this.dispose());
+    }
+  }
+  dispose() {
+    this.disposed = true;
+    const owned = [...this.ownedThrottles];
+    this.ownedThrottles.clear();
+    const errors = [];
+    for (const throttle of owned.reverse()) {
+      try {
+        throttle.dispose();
+      } catch (error) {
+        errors.push(error);
+      }
+    }
+    if (errors.length)
+      throw new AggregateError(errors, "HTTP throttle cleanup failed.");
+  }
+  ownThrottle(throttle) {
+    if (this.disposed) {
+      if ("dispose" in throttle && typeof throttle.dispose === "function")
+        throttle.dispose();
+      throw new Error("HTTP kernel is disposed.");
+    }
+    if ("dispose" in throttle && typeof throttle.dispose === "function") {
+      this.ownedThrottles.add(throttle);
+    }
+    return throttle;
   }
   globalMiddleware(errorFormat = "json") {
     const auth = this.dependencies.container.resolve(CORE_AUTH_TOKEN);
@@ -133,7 +167,9 @@ class HttpKernel {
       errorFormat === "json" ? createJsonErrorMiddleware() : createWebErrorMiddleware(),
       createAuthMiddleware(auth),
       createMembershipMiddleware(),
-      createTenantMiddleware()
+      createTenantMiddleware({
+        resolveTenant: this.dependencies.container.has(CORE_TENANT_RESOLVER_TOKEN) ? this.dependencies.container.resolve(CORE_TENANT_RESOLVER_TOKEN) : undefined
+      })
     ];
   }
   group(name) {
@@ -148,25 +184,28 @@ class HttpKernel {
         if (!this.dependencies.container.has(CORE_CONFIG_TOKEN)) {
           return [csrf];
         }
+        const quotaPolicy = this.dependencies.container.has(CORE_THROTTLE_QUOTA_POLICY_TOKEN) ? this.dependencies.container.resolve(CORE_THROTTLE_QUOTA_POLICY_TOKEN) : undefined;
         const config = this.dependencies.container.resolve(CORE_CONFIG_TOKEN);
         const redisUrl = config.get(REDIS_URL_CONFIG_KEY)?.trim() ?? "";
         if (!redisUrl) {
           const maxAttempts = Number(process.env.RATE_LIMIT_PER_MINUTE ?? "120");
           return [
-            createMemoryThrottleMiddleware({
+            this.ownThrottle(createMemoryThrottleMiddleware({
               maxAttempts: Number.isFinite(maxAttempts) ? maxAttempts : 120,
-              decaySeconds: 60
-            }),
+              decaySeconds: 60,
+              quotaPolicy
+            })),
             csrf
           ];
         }
         const maxAttempts = Number(process.env.RATE_LIMIT_PER_MINUTE ?? "120");
         return [
-          createThrottleMiddleware({
+          this.ownThrottle(createThrottleMiddleware({
             redisUrl,
             maxAttempts: Number.isFinite(maxAttempts) ? maxAttempts : 120,
-            decaySeconds: 60
-          }),
+            decaySeconds: 60,
+            quotaPolicy
+          })),
           csrf
         ];
       }
@@ -296,25 +335,25 @@ class HttpKernel {
     const memoryKeyPrefix = scope === "login" ? "login-throttle:" : "register-throttle:";
     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({
+      return withMiddleware(this.ownThrottle(createLoginThrottleMiddleware({
         ...redisUrl ? { redisUrl } : {},
         maxAttempts: rateLimit.maxAttempts,
         decaySeconds: rateLimit.decaySeconds
-      }))(handler);
+      })))(handler);
     }
     if (redisUrl) {
-      return withMiddleware(createThrottleMiddleware({
+      return withMiddleware(this.ownThrottle(createThrottleMiddleware({
         redisUrl,
         maxAttempts: rateLimit.maxAttempts,
         decaySeconds: rateLimit.decaySeconds,
         keyPrefix: memoryKeyPrefix
-      }))(handler);
+      })))(handler);
     }
-    return withMiddleware(createMemoryThrottleMiddleware({
+    return withMiddleware(this.ownThrottle(createMemoryThrottleMiddleware({
       maxAttempts: rateLimit.maxAttempts,
       decaySeconds: rateLimit.decaySeconds,
       keyPrefix: memoryKeyPrefix
-    }))(handler);
+    })))(handler);
   }
 }
 function createHttpKernel(dependencies) {
@@ -322,74 +361,180 @@ function createHttpKernel(dependencies) {
 }
 
 // ../../src/bootstrap/discoverModules.ts
-import { readdirSync } from "fs";
-import { join } from "path";
+import { readdir as readdir2 } from "fs/promises";
+import { join as join2, resolve } from "path";
+
+// ../../src/bootstrap/infrastructureDiscovery.ts
+import { readdir } from "fs/promises";
+import { join, relative } 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) {
-  const state = readDiscoverModulesState();
-  if (state.configuredModulesDir !== modulesDir) {
-    state.appModules.length = 0;
-    state.modulesReady = undefined;
-  }
-  state.configuredModulesDir = modulesDir;
-}
-function resolveModulesDirectory(options) {
-  const state = readDiscoverModulesState();
-  if (options?.modulesDir) {
-    return options.modulesDir;
+async function infrastructureFiles(directory, exclude = []) {
+  const excluded = new Set([
+    "index.ts",
+    "index.js",
+    "index.mts",
+    "index.mjs",
+    "register.ts",
+    "register.js",
+    "register.mts",
+    "register.mjs",
+    ...exclude
+  ]);
+  const files = [];
+  async function visit(path) {
+    const entries = await readdir(path, { withFileTypes: true });
+    entries.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+    for (const entry of entries) {
+      const file = join(path, entry.name);
+      const key = relative(directory, file).replaceAll("\\", "/");
+      if (excluded.has(entry.name) || excluded.has(key))
+        continue;
+      if (entry.isDirectory())
+        await visit(file);
+      else if (entry.isFile() && /\.(ts|js|mts|mjs)$/.test(entry.name) && !/\.(d|test|spec)\.[cm]?[jt]s$/.test(entry.name))
+        files.push(file);
+    }
   }
-  if (state.configuredModulesDir) {
-    return state.configuredModulesDir;
+  try {
+    await visit(directory);
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      throw error;
+    if (error.path !== directory)
+      throw error;
   }
-  throw new Error("configureModulesDirectory() must be called before discovering modules. The app preload (or starter) should call it.");
+  return files;
 }
-async function loadDiscoveredModules(options) {
-  const modulesDirectory = resolveModulesDirectory(options);
-  let moduleNames;
+async function importInfrastructure(file) {
   try {
-    moduleNames = readdirSync(modulesDirectory, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+    return await import(pathToFileURL(file).href);
   } catch (error) {
-    if (error.code === "ENOENT") {
-      return [];
+    throw new Error(`Cannot load infrastructure module ${file}`, { cause: error });
+  }
+}
+
+// ../../src/bootstrap/discoverModules.ts
+var KEY = Symbol.for("@getstrata/discoverModulesState");
+function state() {
+  const globals = globalThis;
+  globals[KEY] ??= { appModules: [] };
+  return globals[KEY];
+}
+function configureModulesDirectory(modulesDir) {
+  const current = state();
+  const directory = resolve(modulesDir);
+  if (current.configuredModulesDir !== directory || current.configuredManifest) {
+    current.appModules.length = 0;
+    current.modulesReady = undefined;
+    current.source = undefined;
+  }
+  current.configuredManifest = undefined;
+  current.configuredModulesDir = directory;
+}
+function configureModulesManifest(manifest) {
+  const current = state();
+  if (current.configuredManifest !== manifest) {
+    current.appModules.length = 0;
+    current.modulesReady = undefined;
+    current.source = undefined;
+  }
+  current.configuredManifest = manifest;
+}
+function validateModule(value, location) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new TypeError(`Invalid application module at ${location}.`);
+  const module = value;
+  if (typeof module.name !== "string" || !module.name.trim())
+    throw new TypeError(`Invalid module name at ${location}.`);
+  if (module.order !== undefined && (typeof module.order !== "number" || !Number.isFinite(module.order)))
+    throw new TypeError(`Invalid module order at ${location}.`);
+  for (const hook of ["routes", "webRoutes"])
+    if (module[hook] !== undefined && typeof module[hook] !== "function")
+      throw new TypeError(`Invalid ${hook} at ${location}.`);
+  if (module.providers !== undefined) {
+    if (!Array.isArray(module.providers))
+      throw new TypeError(`Invalid providers at ${location}.`);
+    for (const provider of module.providers) {
+      if (!provider || typeof provider.name !== "string" || !provider.name.trim() || provider.register !== undefined && typeof provider.register !== "function" || provider.boot !== undefined && typeof provider.boot !== "function")
+        throw new TypeError(`Invalid provider at ${location}.`);
     }
-    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;
+async function load(options) {
+  const manifest = options.manifest ?? (options.modulesDir === undefined ? state().configuredManifest : undefined);
+  const entries = [];
+  if (manifest)
+    for (const [index, value] of manifest.entries())
+      entries.push({ value, location: `module manifest[${index}]` });
+  else {
+    const directory = options.modulesDir ?? state().configuredModulesDir;
+    if (!directory)
+      throw new Error("configureModulesDirectory() or configureModulesManifest() must be called before discovering modules.");
+    let folders;
+    try {
+      folders = await readdir2(directory, { withFileTypes: true });
+    } catch (error) {
+      if (error.code === "ENOENT")
+        return [];
+      throw error;
+    }
+    const excluded = new Set(options.exclude ?? []);
+    for (const folder of folders.filter((entry) => entry.isDirectory() && !excluded.has(entry.name)).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0)) {
+      const path = join2(directory, folder.name);
+      const files = await readdir2(path);
+      const candidates = files.filter((file) => /^index\.(ts|js|mts|mjs)$/.test(file));
+      if (candidates.length !== 1)
+        throw new Error(`Expected one module entrypoint at ${path}; found ${candidates.length}.`);
+      const file = join2(path, candidates[0]);
+      const exports = await importInfrastructure(file);
+      entries.push({ value: exports.default, location: file });
+    }
+  }
+  const names = new Map;
+  const modules = [];
+  for (const { value, location } of entries) {
+    validateModule(value, location);
+    const previous = names.get(value.name);
+    if (previous)
+      throw new Error(`Duplicate module "${value.name}" at ${location}; first declared at ${previous}.`);
+    names.set(value.name, location);
+    modules.push(value);
+  }
+  return modules.sort((left, right) => (left.order ?? 100) - (right.order ?? 100));
+}
+function ensureModulesLoaded(options = {}) {
+  const current = state();
+  const key = options.manifest ?? (options.modulesDir === undefined ? current.configuredManifest : undefined) ?? JSON.stringify([
+    options.modulesDir ? resolve(options.modulesDir) : current.configuredModulesDir,
+    [...options.exclude ?? []].sort()
+  ]);
+  if (current.modulesReady && current.source === key)
+    return current.modulesReady;
+  current.appModules.length = 0;
+  current.source = key;
+  const pending = load(options).then((modules) => {
+    if (current.modulesReady !== pending)
+      return modules;
+    current.appModules.splice(0, current.appModules.length, ...modules);
+    return current.appModules;
+  }).catch((error) => {
+    if (current.modulesReady === pending)
+      current.modulesReady = undefined;
+    throw error;
   });
-  return state.modulesReady;
+  current.modulesReady = pending;
+  return pending;
 }
 function discoverModules() {
-  return readDiscoverModulesState().appModules;
+  return state().appModules;
 }
 function resetDiscoverModulesForTests() {
-  const state = readDiscoverModulesState();
-  state.configuredModulesDir = undefined;
-  state.appModules.length = 0;
-  state.modulesReady = undefined;
+  const current = state();
+  current.configuredModulesDir = undefined;
+  current.configuredManifest = undefined;
+  current.appModules.length = 0;
+  current.modulesReady = undefined;
+  current.source = undefined;
 }
 // ../../src/bootstrap/prefixRouteMap.ts
 function prefixRouteMap(prefix, routes) {