@getstrata/bootstrap 0.2.6 → 0.2.7

package/dist/bootstrap/contracts.d.ts

@@ -1,3 +1,4 @@
+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>;
@@ -23,6 +24,7 @@ declare class ConfigStore {
 interface AppDependencies {
     container: ServiceContainer;
     cache: CacheLike;
+    storage: StorageManager;
 }
 type MutableAppDependencies = Partial<Omit<AppDependencies, "container">> & Pick<AppDependencies, "container">;
 interface ProviderContext {

package/dist/bootstrap/providers/storage.d.ts

@@ -0,0 +1,3 @@
+import type { ServiceProvider } from "../contracts";
+declare const storageProvider: ServiceProvider;
+export default storageProvider;

package/dist/bootstrap/scimRoutes.d.ts

@@ -1,4 +1,4 @@
-import type { RouteHandler } from "../core/http/middleware";
+import { type RouteHandler } from "@getstrata/core";
 import type { AppDependencies } from "./contracts";
 declare function createScimRoutes(dependencies: AppDependencies): {
     "/scim/v2/ServiceProviderConfig": {

package/dist/core/auth/membershipScope.d.ts

@@ -0,0 +1,16 @@
+declare function resolveOrganizationScope(): number[] | null;
+declare function scopedOrganizationIds(requestedOrganizationId?: number): number[] | null;
+declare function appendOrganizationScope<T extends object>(where: T, requestedOrganizationId?: number): T;
+declare function appendProjectScope<T extends object>(where: T, accessibleProjectIds: number[] | null, requestedProjectId?: number): T;
+declare function emptyPaginateResult<T>(page: number, perPage: number): {
+    data: T[];
+    meta: {
+        page: number;
+        per_page: number;
+        total: number;
+        last_page: number;
+    };
+};
+declare function assertResourceInCurrentTenant(resourceTenantId: number, resourceLabel: string, resourceId: number): void;
+declare function assertOrganizationReadable(organizationId: number): void;
+export { appendOrganizationScope, appendProjectScope, assertOrganizationReadable, assertResourceInCurrentTenant, emptyPaginateResult, resolveOrganizationScope, scopedOrganizationIds, };

package/dist/core/auth/membershipService.d.ts

@@ -0,0 +1,24 @@
+import type { OrganizationMemberRole } from "../../modules/organization/memberTypes";
+import { type AuthUser } from "./authContext";
+import { membershipRepository as defaultMembershipRepository } from "./membershipContext";
+type MembershipRepositoryLike = Pick<typeof defaultMembershipRepository, "listForUser" | "findMembership" | "listForOrganization" | "addMember" | "removeMember">;
+declare class MembershipService {
+    private readonly members;
+    constructor(members?: MembershipRepositoryLike);
+    listOrganizationIdsForUser(userId: number): Promise<number[]>;
+    getOrgRole(userId: number, organizationId: number): Promise<OrganizationMemberRole | null>;
+    requireOrgAccess(organizationId: number, minimumRole?: OrganizationMemberRole, user?: AuthUser | null): Promise<OrganizationMemberRole>;
+    filterAccessibleOrganizationIds(organizationIds: number[], user?: AuthUser | null): Promise<number[]>;
+    addOwnerOnOrganizationCreate(organizationId: number, userId: number): Promise<void>;
+    listMembersForOrganization(organizationId: number): Promise<import("../../modules/organization/memberTypes").OrganizationMemberRecord[]>;
+    addMember(input: {
+        organizationId: number;
+        userId: number;
+        role?: OrganizationMemberRole;
+    }): Promise<import("../../modules/organization/memberTypes").OrganizationMemberRecord>;
+    removeMember(organizationId: number, userId: number): Promise<boolean>;
+}
+declare function resolveMembershipService(): MembershipService;
+export type { MembershipRepositoryLike };
+export default MembershipService;
+export { resolveMembershipService };

package/dist/core/database/baseRepository.d.ts

@@ -9,6 +9,11 @@ type ExtendedQueryOptions<TEntity extends object> = QueryOptions<TEntity> & {
 };
 interface DatabaseConnection {
     unsafe<T>(query: string, params?: readonly unknown[]): Promise<T[]>;
+    begin?<T>(callback: (transaction: DatabaseConnection) => Promise<T>): Promise<T>;
+    close?(): Promise<void>;
+}
+interface SqlDatabaseConnection extends DatabaseConnection {
+    (strings: TemplateStringsArray, ...values: unknown[]): Promise<unknown[]>;
 }
 type ErrorFactory<TValue> = (value: TValue) => Error;
 declare class BaseRepository<TEntity extends object, PrimaryKey extends keyof TEntity & string> {
@@ -59,4 +64,4 @@ declare class BaseRepository<TEntity extends object, PrimaryKey extends keyof TE
     loadMorphToForChildren<TChild extends object, TParent extends object, MorphTypeKey extends keyof TChild & string, MorphIdKey extends keyof TChild & string, OwnerKey extends keyof TParent & string>(children: readonly TChild[], relation: MorphToRelation<TChild, MorphTypeKey, MorphIdKey>, repositoriesByType: ReadonlyMap<string, BaseRepository<TParent, OwnerKey>>, options?: Omit<QueryOptions<TParent>, "where">): Promise<Map<TChild[MorphIdKey], TParent>>;
 }
 export default BaseRepository;
-export type { DatabaseConnection };
+export type { DatabaseConnection, SqlDatabaseConnection };

package/dist/core/database/connectionContext.d.ts

@@ -3,5 +3,6 @@ type ActiveDatabaseHandle = {
 };
 declare function runWithDatabaseConnection<T>(connection: ActiveDatabaseHandle, callback: () => T | Promise<T>): T | Promise<T>;
 declare function getActiveDatabaseConnection<T extends ActiveDatabaseHandle>(fallback: T): T;
+declare function hasActiveDatabaseConnection(): boolean;
 export type { ActiveDatabaseHandle };
-export { getActiveDatabaseConnection, runWithDatabaseConnection };
+export { getActiveDatabaseConnection, hasActiveDatabaseConnection, runWithDatabaseConnection };

package/dist/core/database/defaultConnection.d.ts

@@ -0,0 +1,6 @@
+import type { SqlDatabaseConnection } from "./baseRepository";
+declare function registerDefaultDatabasePool(connection: SqlDatabaseConnection): void;
+declare function getDefaultDatabasePool(): SqlDatabaseConnection;
+declare function getDefaultDatabaseQuery(): SqlDatabaseConnection;
+declare function resetDefaultDatabasePoolForTests(): void;
+export { getDefaultDatabasePool, getDefaultDatabaseQuery, registerDefaultDatabasePool, resetDefaultDatabasePoolForTests, };

package/dist/core/database/queryProxy.d.ts

@@ -0,0 +1,3 @@
+import type { SqlDatabaseConnection } from "./baseRepository";
+declare function createDatabaseQueryProxy(pool: SqlDatabaseConnection): SqlDatabaseConnection;
+export { createDatabaseQueryProxy };

package/dist/core/database/repositoryConnection.d.ts

@@ -1,4 +1,4 @@
-import type { DatabaseConnection } from "./baseRepository";
-declare function resolveRepositoryConnection(): DatabaseConnection;
-declare const repositoryConnection: DatabaseConnection;
+import type { SqlDatabaseConnection } from "./baseRepository";
+declare function resolveRepositoryConnection(): SqlDatabaseConnection;
+declare const repositoryConnection: SqlDatabaseConnection;
 export { repositoryConnection, resolveRepositoryConnection };

package/dist/core/jobs/dispatchWebhookJob.d.ts

@@ -5,7 +5,6 @@ interface DispatchWebhookPayload {
     payload: Record<string, unknown>;
 }
 declare class DispatchWebhookJob extends Job<DispatchWebhookPayload> {
-    constructor();
     readonly maxAttempts = 3;
     readonly backoffMs = 2000;
     handle(payload: DispatchWebhookPayload): Promise<void>;

package/dist/core/queue/queueMetrics.d.ts

@@ -0,0 +1,15 @@
+interface QueueDepthMetrics {
+    high: number;
+    default: number;
+    low: number;
+    total: number;
+}
+interface QueueMetricsSnapshot {
+    driver: string;
+    pending: QueueDepthMetrics;
+    failedCount: number;
+}
+declare function readRedisQueueDepth(redisUrl: string): Promise<QueueDepthMetrics>;
+declare function collectQueueMetrics(): Promise<QueueMetricsSnapshot>;
+export type { QueueDepthMetrics, QueueMetricsSnapshot };
+export { collectQueueMetrics, readRedisQueueDepth };

package/dist/core/security/safeFetch.d.ts

@@ -2,6 +2,8 @@ declare const DEFAULT_FETCH_TIMEOUT_MS = 10000;
 interface SafeFetchOptions {
     timeoutMs?: number;
     maxRedirects?: number;
+    allowHttp?: boolean;
+    resolveDns?: boolean;
 }
 declare function safeFetch(input: string, init?: RequestInit, options?: SafeFetchOptions): Promise<Response>;
 export type { SafeFetchOptions };

package/dist/core/security/safeUrl.d.ts

@@ -1,5 +1,20 @@
+type DnsLookupResult = {
+    address: string;
+    family: number;
+};
+type DnsLookup = (hostname: string, options: {
+    all: true;
+    verbatim: true;
+}) => Promise<DnsLookupResult[]>;
 declare function isBlockedHostname(hostname: string): boolean;
 declare function assertSafeOutboundUrl(rawUrl: string, options?: {
     allowHttp?: boolean;
 }): URL;
-export { assertSafeOutboundUrl, isBlockedHostname };
+declare function isBlockedIpAddress(address: string): boolean;
+declare function assertSafeOutboundUrlResolved(rawUrl: string, options?: {
+    allowHttp?: boolean;
+    resolveDns?: boolean;
+}): Promise<URL>;
+declare function setDnsLookupForTests(lookupFn: DnsLookup): void;
+declare function resetDnsLookupForTests(): void;
+export { assertSafeOutboundUrl, assertSafeOutboundUrlResolved, isBlockedHostname, isBlockedIpAddress, resetDnsLookupForTests, setDnsLookupForTests, };

package/dist/core/tenant/tenantDatabaseScope.d.ts

@@ -4,4 +4,5 @@ type TransactionHandle = {
 };
 declare function applyTenantContextToTransaction(transaction: TransactionHandle, tenantId: number): Promise<void>;
 declare function runWithTenantDatabase<T>(tenant: TenantContext, callback: () => T | Promise<T>): Promise<T>;
-export { applyTenantContextToTransaction, runWithTenantDatabase };
+declare function isInsideTenantDatabaseScope(tenantId?: number | undefined): boolean;
+export { applyTenantContextToTransaction, isInsideTenantDatabaseScope, runWithTenantDatabase };

package/dist/db/connection/index.d.ts

@@ -1,4 +1,4 @@
-import { type DatabaseConnection } from "./createConnection";
+import type { DatabaseConnection } from "./createConnection";
 declare function getDatabase(): DatabaseConnection;
 declare function pingDatabase(connection?: DatabaseConnection): Promise<boolean>;
 declare function ensureDatabaseConnection(): Promise<DatabaseConnection>;

package/dist/domain/workhub.d.ts

@@ -0,0 +1,35 @@
+/**
+ * WorkHub — complex reference domain for framework stress-testing.
+ *
+ * Replaces character/nemesis/secret over time. Module layout:
+ *
+ *   organization/  top-level tenant (CRUD, unique slug)
+ *   project/       belongsTo organization (CRUD, status enum, composite unique name)
+ *   task/          belongsTo project (CRUD, priority, status enum) — Phase 2
+ *   comment/       belongsTo task (CRUD, nested create) — Phase 2
+ *   report/        cross-module aggregations — Phase 2
+ *
+ * Relationship graph:
+ *
+ *   organization 1──* project 1──* task 1──* comment
+ *
+ * Edge cases this domain is meant to exercise:
+ * - unique violations (organization.slug, project per-org name)
+ * - FK violations (project.organization_id, task.project_id)
+ * - enum/check constraints (project.status, task.priority)
+ * - transactions (create project + default task atomically)
+ * - belongsTo eager loading (project → organization)
+ * - cache invalidation on writes
+ * - PATCH partial updates without nulling omitted fields
+ */
+declare const ORGANIZATION_TABLE: "organization";
+declare const PROJECT_TABLE: "project";
+declare const TASK_TABLE: "task";
+declare const COMMENT_TABLE: "comment";
+declare const TASK_ATTACHMENT_TABLE: "task_attachment";
+declare const PROJECT_STATUSES: readonly ["draft", "active", "archived"];
+declare const TASK_STATUSES: readonly ["todo", "in_progress", "done"];
+type ProjectStatus = (typeof PROJECT_STATUSES)[number];
+type TaskStatus = (typeof TASK_STATUSES)[number];
+export type { ProjectStatus, TaskStatus };
+export { COMMENT_TABLE, ORGANIZATION_TABLE, PROJECT_STATUSES, PROJECT_TABLE, TASK_ATTACHMENT_TABLE, TASK_STATUSES, TASK_TABLE, };

package/dist/entries/applicationRegistry.js

@@ -0,0 +1,185 @@
+// @bun
+// ../../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/bootstrap/config.ts
+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 CORE_CONFIG_TOKEN = "core.config";
+var CORE_CACHE_TOKEN = "core.cache";
+var CORE_QUEUE_TOKEN = "core.queue";
+var CORE_POLICY_GATE_TOKEN = "core.policyGate";
+var CORE_AUTH_TOKEN = "core.auth";
+var CORE_TOKEN_SERVICE_TOKEN = "core.tokenService";
+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/contracts.ts
+class ServiceContainer {
+  services = new Map;
+  singletonFactories = new Map;
+  bindings = new Map;
+  set(key, value) {
+    this.singletonFactories.delete(key);
+    this.bindings.delete(key);
+    this.services.set(key, value);
+    return value;
+  }
+  singleton(key, factory) {
+    this.bindings.delete(key);
+    this.services.delete(key);
+    this.singletonFactories.set(key, factory);
+  }
+  bind(key, factory) {
+    this.singletonFactories.delete(key);
+    this.services.delete(key);
+    this.bindings.set(key, factory);
+  }
+  get(key) {
+    if (this.services.has(key)) {
+      return this.services.get(key);
+    }
+    const singletonFactory = this.singletonFactories.get(key);
+    if (singletonFactory) {
+      const value = singletonFactory(this);
+      this.services.set(key, value);
+      return value;
+    }
+    const binding = this.bindings.get(key);
+    if (binding) {
+      return binding(this);
+    }
+    throw new Error(`Service "${key}" is not registered.`);
+  }
+  resolve(key) {
+    return this.get(key);
+  }
+  has(key) {
+    return this.services.has(key) || this.singletonFactories.has(key) || this.bindings.has(key);
+  }
+}
+
+class ConfigStore {
+  values = new Map;
+  set(key, value) {
+    this.values.set(key, value);
+    return value;
+  }
+  get(key) {
+    return this.values.get(key);
+  }
+  require(key) {
+    if (!this.values.has(key)) {
+      throw new Error(`Config key "${key}" is not defined.`);
+    }
+    return this.values.get(key);
+  }
+  has(key) {
+    return this.values.has(key);
+  }
+}
+var requiredDependencyKeys = [
+  "container",
+  "cache",
+  "storage"
+];
+function getRequiredDependency(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) {
+    getRequiredDependency(dependencies, key);
+  }
+}
+function resolveService(dependencies, token) {
+  return dependencies.container.resolve(token);
+}
+
+// ../../src/bootstrap/applicationRegistry.ts
+var activeContext;
+function setActiveApplicationContext(context) {
+  activeContext = context;
+}
+function requireActiveApplicationContext() {
+  if (!activeContext) {
+    throw new Error("The application context has not been bootstrapped.");
+  }
+  return activeContext;
+}
+function resolveApplicationCache() {
+  return getRequiredDependency(requireActiveApplicationContext().dependencies, "cache");
+}
+function resolveApplicationQueue() {
+  return requireActiveApplicationContext().container.resolve(CORE_QUEUE_TOKEN);
+}
+function resolveApplicationAuth() {
+  return requireActiveApplicationContext().container.resolve(CORE_AUTH_TOKEN);
+}
+function resolveApplicationPolicyGate() {
+  return requireActiveApplicationContext().container.resolve(CORE_POLICY_GATE_TOKEN);
+}
+function resolveApplicationConfig() {
+  return requireActiveApplicationContext().config;
+}
+function resolveApplicationLogger() {
+  return appLogger;
+}
+function resolveApplicationDependencies() {
+  return requireActiveApplicationContext().dependencies;
+}
+export {
+  setActiveApplicationContext,
+  resolveApplicationQueue,
+  resolveApplicationPolicyGate,
+  resolveApplicationLogger,
+  resolveApplicationDependencies,
+  resolveApplicationConfig,
+  resolveApplicationCache,
+  resolveApplicationAuth
+};

package/dist/entries/config.js

@@ -0,0 +1,42 @@
+// @bun
+// ../../src/bootstrap/config.ts
+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 CORE_CONFIG_TOKEN = "core.config";
+var CORE_CACHE_TOKEN = "core.cache";
+var CORE_QUEUE_TOKEN = "core.queue";
+var CORE_POLICY_GATE_TOKEN = "core.policyGate";
+var CORE_AUTH_TOKEN = "core.auth";
+var CORE_TOKEN_SERVICE_TOKEN = "core.tokenService";
+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";
+export {
+  REDIS_URL_CONFIG_KEY,
+  DEFAULT_QUEUE_DRIVER,
+  DEFAULT_CACHE_TTL_MS,
+  DEFAULT_CACHE_MAX_ENTRIES,
+  DEFAULT_CACHE_DRIVER,
+  DEFAULT_APP_PORT,
+  DEFAULT_API_TOKEN,
+  DATABASE_URL_CONFIG_KEY,
+  CORE_TOKEN_SERVICE_TOKEN,
+  CORE_QUEUE_TOKEN,
+  CORE_POLICY_GATE_TOKEN,
+  CORE_CONFIG_TOKEN,
+  CORE_CACHE_TOKEN,
+  CORE_AUTH_TOKEN,
+  CACHE_TTL_MS_CONFIG_KEY,
+  CACHE_MAX_ENTRIES_CONFIG_KEY,
+  CACHE_DRIVER_CONFIG_KEY,
+  AUTH_DEV_HEADERS_CONFIG_KEY,
+  APP_PORT_CONFIG_KEY
+};