@getstrata/bootstrap 0.2.16 → 0.2.18

package/dist/bootstrap/contracts.d.ts

@@ -1,48 +1,13 @@
-import type { StorageManager } from "../core/storage/storage";
-import type { CacheLike } from "../types/services";
-type CachedJson = <T>(cacheKey: string, loader: () => Promise<T>, tags?: string[], request?: Request) => Promise<Response>;
-type AppRouteMap = Record<string, any>;
-type ServiceFactory<T> = (container: ServiceContainer) => T;
-declare class ServiceContainer {
-    private readonly services;
-    private readonly singletonFactories;
-    private readonly bindings;
-    set<T>(key: string, value: T): T;
-    singleton<T>(key: string, factory: ServiceFactory<T>): void;
-    bind<T>(key: string, factory: ServiceFactory<T>): void;
-    get<T>(key: string): T;
-    resolve<T>(key: string): T;
-    has(key: string): boolean;
-}
-declare class ConfigStore {
-    private readonly values;
-    set<T>(key: string, value: T): T;
-    get<T>(key: string): T | undefined;
-    require<T>(key: string): T;
-    has(key: string): boolean;
-}
-interface AppDependencies {
-    container: ServiceContainer;
-    cache: CacheLike;
-    storage: StorageManager;
-}
-type MutableAppDependencies = Partial<Omit<AppDependencies, "container">> & Pick<AppDependencies, "container">;
-interface ProviderContext {
-    container: ServiceContainer;
-    config: ConfigStore;
-    dependencies: MutableAppDependencies;
-}
-import type { HttpKernel } from "./httpKernel";
+export { ConfigStore, type ConfigStoreLike, ServiceContainer, type ServiceContainerLike, } from "../core/contracts/container.ts";
+export type { AppContext, AppDependencies, AppRouteMap, CachedJson, MutableAppDependencies, ProviderContext, ServiceFactory, ServiceProvider, } from "../core/contracts/di.ts";
+export { assertAppDependenciesComplete, getRequiredDependency, resolveService, } from "../core/contracts/di.ts";
+import type { AppDependencies, AppRouteMap, CachedJson, ServiceProvider } from "../core/contracts/di.ts";
+import type { HttpKernel } from "./httpKernel.ts";
 interface ModuleRouteContext {
     dependencies: AppDependencies;
     cachedJson: CachedJson;
     kernel: HttpKernel;
 }
-interface ServiceProvider {
-    name: string;
-    register?(context: ProviderContext): void;
-    boot?(context: ProviderContext): void;
-}
 interface AppModule {
     name: string;
     order?: number;
@@ -53,13 +18,4 @@ interface AppModule {
     routes?(context: ModuleRouteContext): AppRouteMap;
     webRoutes?(context: ModuleRouteContext): AppRouteMap;
 }
-interface AppContext {
-    container: ServiceContainer;
-    config: ConfigStore;
-    dependencies: AppDependencies;
-}
-declare function getRequiredDependency<K extends keyof AppDependencies>(dependencies: Partial<AppDependencies>, key: K): AppDependencies[K];
-declare function assertAppDependenciesComplete(dependencies: MutableAppDependencies): asserts dependencies is AppDependencies;
-declare function resolveService<T>(dependencies: AppDependencies, token: string): T;
-export type { AppContext, AppDependencies, AppModule, AppRouteMap, CachedJson, ModuleRouteContext, MutableAppDependencies, ProviderContext, ServiceFactory, ServiceProvider, };
-export { assertAppDependenciesComplete, ConfigStore, getRequiredDependency, resolveService, ServiceContainer, };
+export type { AppModule, ModuleRouteContext };

package/dist/core/contracts/applicationContext.d.ts

@@ -1,18 +1,7 @@
-import type { CacheLike } from "../../types/services";
-import type { ServiceContainerLike } from "./serviceContainer";
-interface ConfigStoreLike {
-    get<T>(key: string): T | undefined;
-}
-interface ApplicationDependenciesLike {
-    container: ServiceContainerLike;
-    cache: CacheLike;
-    storage?: unknown;
-}
-interface ApplicationContext {
-    container: ServiceContainerLike;
-    config: ConfigStoreLike;
-    dependencies: ApplicationDependenciesLike;
-}
-declare function getRequiredDependency<K extends keyof ApplicationDependenciesLike>(dependencies: Partial<ApplicationDependenciesLike>, key: K): ApplicationDependenciesLike[K];
-export type { ApplicationContext, ApplicationDependenciesLike, ConfigStoreLike };
-export { getRequiredDependency };
+import type { AppContext, AppDependencies } from "./di";
+/** @deprecated Use AppContext from @getstrata/core/contracts/di */
+type ApplicationContext = AppContext;
+/** @deprecated Use AppDependencies from @getstrata/core/contracts/di */
+type ApplicationDependenciesLike = AppDependencies;
+export { getRequiredDependency } from "./di";
+export type { ApplicationContext, ApplicationDependenciesLike };

package/dist/core/contracts/container.d.ts

@@ -0,0 +1,30 @@
+type ServiceFactory<T> = (container: ServiceContainer) => T;
+interface ServiceContainerLike {
+    has(key: string): boolean;
+    resolve<T>(key: string): T;
+}
+declare class ServiceContainer implements ServiceContainerLike {
+    private readonly services;
+    private readonly singletonFactories;
+    private readonly bindings;
+    set<T>(key: string, value: T): T;
+    singleton<T>(key: string, factory: ServiceFactory<T>): void;
+    bind<T>(key: string, factory: ServiceFactory<T>): void;
+    get<T>(key: string): T;
+    resolve<T>(key: string): T;
+    has(key: string): boolean;
+}
+interface ConfigStoreLike {
+    get<T>(key: string): T | undefined;
+    require<T>(key: string): T;
+    has(key: string): boolean;
+}
+declare class ConfigStore implements ConfigStoreLike {
+    private readonly values;
+    set<T>(key: string, value: T): T;
+    get<T>(key: string): T | undefined;
+    require<T>(key: string): T;
+    has(key: string): boolean;
+}
+export type { ConfigStoreLike, ServiceContainerLike, ServiceFactory };
+export { ConfigStore, ServiceContainer };

package/dist/core/contracts/di.d.ts

@@ -0,0 +1,31 @@
+import type { CacheLike } from "../../types/services";
+import type { StorageManager } from "../storage/storage";
+import type { ConfigStore, ConfigStoreLike, ServiceContainer, ServiceFactory } from "./container";
+type AppRouteMap = Record<string, any>;
+type CachedJson = <T>(cacheKey: string, loader: () => Promise<T>, tags?: string[], request?: Request) => Promise<Response>;
+interface AppDependencies {
+    container: ServiceContainer;
+    cache: CacheLike;
+    storage: StorageManager;
+}
+type MutableAppDependencies = Partial<Omit<AppDependencies, "container">> & Pick<AppDependencies, "container">;
+interface ProviderContext {
+    container: ServiceContainer;
+    config: ConfigStore;
+    dependencies: MutableAppDependencies;
+}
+interface ServiceProvider {
+    name: string;
+    register?(context: ProviderContext): void;
+    boot?(context: ProviderContext): void;
+}
+interface AppContext {
+    container: ServiceContainer;
+    config: ConfigStoreLike;
+    dependencies: AppDependencies;
+}
+declare function getRequiredDependency<K extends keyof AppDependencies>(dependencies: Partial<AppDependencies>, key: K): AppDependencies[K];
+declare function assertAppDependenciesComplete(dependencies: MutableAppDependencies): asserts dependencies is AppDependencies;
+declare function resolveService<T>(dependencies: AppDependencies, token: string): T;
+export type { AppContext, AppDependencies, AppRouteMap, CachedJson, MutableAppDependencies, ProviderContext, ServiceFactory, ServiceProvider, };
+export { assertAppDependenciesComplete, getRequiredDependency, resolveService };

package/dist/core/contracts/serviceContainer.d.ts

@@ -1,5 +1 @@
-interface ServiceContainerLike {
-    has(key: string): boolean;
-    resolve<T>(key: string): T;
-}
-export type { ServiceContainerLike };
+export type { ServiceContainerLike } from "./container.ts";

package/dist/core/runtime/applicationRegistry.d.ts

@@ -9,7 +9,7 @@ declare function resolveApplicationCache(): CacheLike;
 declare function resolveApplicationQueue(): Queue;
 declare function resolveApplicationAuth(): AuthManager;
 declare function resolveApplicationPolicyGate(): PolicyGate;
-declare function resolveApplicationConfig(): import("../contracts/applicationContext").ConfigStoreLike;
+declare function resolveApplicationConfig(): import("../contracts/container").ConfigStoreLike;
 declare function resolveApplicationLogger(): Logger;
-declare function resolveApplicationDependencies(): import("../contracts/applicationContext").ApplicationDependenciesLike;
+declare function resolveApplicationDependencies(): import("../contracts/di").AppDependencies;
 export { resolveApplicationAuth, resolveApplicationCache, resolveApplicationConfig, resolveApplicationDependencies, resolveApplicationLogger, resolveApplicationPolicyGate, resolveApplicationQueue, setActiveApplicationContext, };

package/dist/entries/applicationRegistry.js

@@ -1,13 +1,25 @@
 // @bun
-// ../../src/core/contracts/applicationContext.ts
+// ../../src/core/contracts/di.ts
+var requiredDependencyKeys = [
+  "container",
+  "cache",
+  "storage"
+];
 function getRequiredDependency(dependencies, key) {
   const dependency = dependencies[key];
   if (dependency === undefined) {
-    throw new Error(`Required dependency "${String(key)}" is not registered.`);
+    throw new Error(`Required dependency "${key}" is not registered.`);
   }
   return dependency;
 }
-
+function assertAppDependenciesComplete(dependencies) {
+  for (const key of requiredDependencyKeys) {
+    getRequiredDependency(dependencies, key);
+  }
+}
+function resolveService(dependencies, token) {
+  return dependencies.container.resolve(token);
+}
 // ../../src/core/contracts/serviceTokens.ts
 var CORE_CONFIG_TOKEN = "core.config";
 var CORE_CACHE_TOKEN = "core.cache";

package/dist/entries/cache/modelCacheTags.js

@@ -0,0 +1,22 @@
+// @bun
+// ../../src/bootstrap/discoverModules.ts
+var appModules = [];
+function discoverModules() {
+  return 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);
+}
+export {
+  discoverModelTableNames,
+  cacheTagsForModelWrite
+};

package/dist/entries/context.js

@@ -1,13 +1,25 @@
 // @bun
-// ../../src/core/contracts/applicationContext.ts
+// ../../src/core/contracts/di.ts
+var requiredDependencyKeys = [
+  "container",
+  "cache",
+  "storage"
+];
 function getRequiredDependency(dependencies, key) {
   const dependency = dependencies[key];
   if (dependency === undefined) {
-    throw new Error(`Required dependency "${String(key)}" is not registered.`);
+    throw new Error(`Required dependency "${key}" is not registered.`);
   }
   return dependency;
 }
-
+function assertAppDependenciesComplete(dependencies) {
+  for (const key of requiredDependencyKeys) {
+    getRequiredDependency(dependencies, key);
+  }
+}
+function resolveService(dependencies, token) {
+  return dependencies.container.resolve(token);
+}
 // ../../src/core/contracts/serviceTokens.ts
 var CORE_CONFIG_TOKEN = "core.config";
 var CORE_CACHE_TOKEN = "core.cache";
@@ -97,7 +109,7 @@ function resolveApplicationLogger() {
 function resolveApplicationDependencies() {
   return requireActiveApplicationContext().dependencies;
 }
-// ../../src/bootstrap/contracts.ts
+// ../../src/core/contracts/container.ts
 class ServiceContainer {
   services = new Map;
   singletonFactories = new Map;
@@ -161,27 +173,6 @@ class ConfigStore {
     return this.values.has(key);
   }
 }
-var requiredDependencyKeys = [
-  "container",
-  "cache",
-  "storage"
-];
-function getRequiredDependency2(dependencies, key) {
-  const dependency = dependencies[key];
-  if (dependency === undefined) {
-    throw new Error(`Required dependency "${key}" is not registered.`);
-  }
-  return dependency;
-}
-function assertAppDependenciesComplete(dependencies) {
-  for (const key of requiredDependencyKeys) {
-    getRequiredDependency2(dependencies, key);
-  }
-}
-function resolveService(dependencies, token) {
-  return dependencies.container.resolve(token);
-}
-
 // ../../src/bootstrap/discoverModules.ts
 var appModules = [];
 function discoverModules() {

package/dist/entries/contracts.js

@@ -1,5 +1,5 @@
 // @bun
-// ../../src/bootstrap/contracts.ts
+// ../../src/core/contracts/container.ts
 class ServiceContainer {
   services = new Map;
   singletonFactories = new Map;
@@ -63,6 +63,7 @@ class ConfigStore {
     return this.values.has(key);
   }
 }
+// ../../src/core/contracts/di.ts
 var requiredDependencyKeys = [
   "container",
   "cache",

package/dist/entries/http/securedRouteModelBinding.js

@@ -64,15 +64,27 @@ class PreconditionFailedError extends HttpError {
   }
 }
 
-// ../../src/core/contracts/applicationContext.ts
+// ../../src/core/contracts/di.ts
+var requiredDependencyKeys = [
+  "container",
+  "cache",
+  "storage"
+];
 function getRequiredDependency(dependencies, key) {
   const dependency = dependencies[key];
   if (dependency === undefined) {
-    throw new Error(`Required dependency "${String(key)}" is not registered.`);
+    throw new Error(`Required dependency "${key}" is not registered.`);
   }
   return dependency;
 }
-
+function assertAppDependenciesComplete(dependencies) {
+  for (const key of requiredDependencyKeys) {
+    getRequiredDependency(dependencies, key);
+  }
+}
+function resolveService(dependencies, token) {
+  return dependencies.container.resolve(token);
+}
 // ../../src/core/contracts/serviceTokens.ts
 var CORE_CONFIG_TOKEN = "core.config";
 var CORE_CACHE_TOKEN = "core.cache";

package/dist/entries/membershipService.js

@@ -1,13 +1,25 @@
 // @bun
-// ../../src/core/contracts/applicationContext.ts
+// ../../src/core/contracts/di.ts
+var requiredDependencyKeys = [
+  "container",
+  "cache",
+  "storage"
+];
 function getRequiredDependency(dependencies, key) {
   const dependency = dependencies[key];
   if (dependency === undefined) {
-    throw new Error(`Required dependency "${String(key)}" is not registered.`);
+    throw new Error(`Required dependency "${key}" is not registered.`);
   }
   return dependency;
 }
-
+function assertAppDependenciesComplete(dependencies) {
+  for (const key of requiredDependencyKeys) {
+    getRequiredDependency(dependencies, key);
+  }
+}
+function resolveService(dependencies, token) {
+  return dependencies.container.resolve(token);
+}
 // ../../src/core/contracts/serviceTokens.ts
 var CORE_CONFIG_TOKEN = "core.config";
 var CORE_CACHE_TOKEN = "core.cache";

package/dist/entries/providers.js

@@ -3244,15 +3244,27 @@ function createAppQueue(driver, redisUrl, failedJobs = createFailedJobService(),
   });
 }
 
-// ../../src/core/contracts/applicationContext.ts
+// ../../src/core/contracts/di.ts
+var requiredDependencyKeys = [
+  "container",
+  "cache",
+  "storage"
+];
 function getRequiredDependency(dependencies, key) {
   const dependency = dependencies[key];
   if (dependency === undefined) {
-    throw new Error(`Required dependency "${String(key)}" is not registered.`);
+    throw new Error(`Required dependency "${key}" is not registered.`);
   }
   return dependency;
 }
-
+function assertAppDependenciesComplete(dependencies) {
+  for (const key of requiredDependencyKeys) {
+    getRequiredDependency(dependencies, key);
+  }
+}
+function resolveService(dependencies, token) {
+  return dependencies.container.resolve(token);
+}
 // ../../src/core/logging/logger.ts
 class Logger {
   channel;

package/dist/entries/queue/defaultJobs.js

@@ -384,15 +384,27 @@ function readSharedJobRegistry() {
 }
 var jobRegistry = readSharedJobRegistry();
 
-// ../../src/core/contracts/applicationContext.ts
+// ../../src/core/contracts/di.ts
+var requiredDependencyKeys = [
+  "container",
+  "cache",
+  "storage"
+];
 function getRequiredDependency(dependencies, key) {
   const dependency = dependencies[key];
   if (dependency === undefined) {
-    throw new Error(`Required dependency "${String(key)}" is not registered.`);
+    throw new Error(`Required dependency "${key}" is not registered.`);
   }
   return dependency;
 }
-
+function assertAppDependenciesComplete(dependencies) {
+  for (const key of requiredDependencyKeys) {
+    getRequiredDependency(dependencies, key);
+  }
+}
+function resolveService(dependencies, token) {
+  return dependencies.container.resolve(token);
+}
 // ../../src/core/contracts/serviceTokens.ts
 var CORE_CONFIG_TOKEN = "core.config";
 var CORE_CACHE_TOKEN = "core.cache";

package/dist/entries/web/forms.js

@@ -0,0 +1,53 @@
+// @bun
+// ../../src/core/http/csrfProtection.ts
+var DEFAULT_CSRF_TTL_MS = 60 * 60 * 1000;
+function createCsrfProtection(secret, options = {}) {
+  const expiresIn = options.expiresIn ?? DEFAULT_CSRF_TTL_MS;
+  const maxAge = options.maxAge ?? expiresIn;
+  return {
+    generate(_sessionKey) {
+      return Bun.CSRF.generate(secret, { expiresIn });
+    },
+    verify(token, _sessionKey) {
+      if (!token) {
+        return false;
+      }
+      return Bun.CSRF.verify(token, { secret, maxAge });
+    },
+    secret
+  };
+}
+
+// ../../src/bootstrap/web/forms.ts
+async function parseFormBody(request) {
+  const contentType = request.headers.get("content-type") ?? "";
+  const fields = {};
+  const files = {};
+  if (contentType.includes("application/x-www-form-urlencoded")) {
+    const text = await request.text();
+    for (const pair of text.split("&")) {
+      const idx = pair.indexOf("=");
+      if (idx === -1)
+        continue;
+      const key = decodeURIComponent(pair.slice(0, idx).replace(/\+/g, " "));
+      const value = decodeURIComponent(pair.slice(idx + 1).replace(/\+/g, " "));
+      fields[key] = value;
+    }
+    return { fields, files };
+  }
+  if (contentType.includes("multipart/form-data")) {
+    const form = await request.formData();
+    for (const [key, value] of form.entries()) {
+      if (value instanceof File) {
+        files[key] = value;
+      } else {
+        fields[key] = String(value);
+      }
+    }
+  }
+  return { fields, files };
+}
+export {
+  parseFormBody,
+  createCsrfProtection
+};