@getstrata/bootstrap 0.2.0 → 0.2.2

package/dist/bootstrap/public-api.d.ts

@@ -1,10 +1,10 @@
 /**
  * @getstrata/bootstrap — application shell for Strata sibling apps.
  */
+export { resolveApplicationQueue, setActiveApplicationContext } from "@getstrata/core";
 export { scheduleRunCommand } from "../cli/commands/scheduleRun.ts";
 export type { ScheduledTask } from "../core/scheduler/schedule.ts";
 export { appSchedule, runDueScheduledTasks, Schedule } from "../core/scheduler/schedule.ts";
-export { resolveApplicationQueue, setActiveApplicationContext } from "./applicationRegistry.ts";
 export { APP_PORT_CONFIG_KEY, CORE_AUTH_TOKEN, CORE_CACHE_TOKEN, CORE_CONFIG_TOKEN, CORE_POLICY_GATE_TOKEN, CORE_QUEUE_TOKEN, CORE_TOKEN_SERVICE_TOKEN, DATABASE_URL_CONFIG_KEY, DEFAULT_APP_PORT, REDIS_URL_CONFIG_KEY, } from "./config.ts";
 export { collectProviders, createAppContext, runProviderPhase } from "./context.ts";
 export type { AppContext, AppDependencies, AppModule, AppRouteMap, CachedJson, ConfigStore, ModuleRouteContext, MutableAppDependencies, ProviderContext, ServiceFactory, ServiceProvider, } from "./contracts.ts";

package/dist/config/uploads.d.ts

@@ -0,0 +1,5 @@
+declare const DEFAULT_MAX_UPLOAD_BYTES: number;
+declare const ALLOWED_UPLOAD_MIME_TYPES: Set<string>;
+declare function resolveMaxUploadBytes(): number;
+declare function isAllowedMimeType(mimeType: string): boolean;
+export { ALLOWED_UPLOAD_MIME_TYPES, DEFAULT_MAX_UPLOAD_BYTES, isAllowedMimeType, resolveMaxUploadBytes, };

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

@@ -1,2 +1,2 @@
-declare function createMembershipMiddleware(): import("../http/middleware").Middleware;
+declare function createMembershipMiddleware(): import("../http").Middleware;
 export { createMembershipMiddleware };

package/dist/core/cache/tags.d.ts

@@ -0,0 +1,11 @@
+declare const CACHE_TAGS: {
+    readonly organizations: "organizations";
+    readonly projects: "projects";
+    readonly tasks: "tasks";
+    readonly comments: "comments";
+    readonly attachments: "attachments";
+    readonly reports: "reports";
+};
+type CacheTag = (typeof CACHE_TAGS)[keyof typeof CACHE_TAGS];
+export type { CacheTag };
+export { CACHE_TAGS };

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

@@ -0,0 +1,3 @@
+import type { DatabaseConnection } from "./baseRepository";
+declare function bindDatabaseConnection(connection: DatabaseConnection): void;
+export { bindDatabaseConnection };

package/dist/core/database/migrations/advisoryLock.d.ts

@@ -0,0 +1,6 @@
+declare const MIGRATION_LOCK_KEY = 42424242;
+type LockableDatabase = {
+    unsafe<T>(query: string, params?: readonly unknown[]): Promise<T[]>;
+};
+declare function withMigrationLock<T>(db: LockableDatabase, callback: () => Promise<T>, lockKey?: number): Promise<T>;
+export { MIGRATION_LOCK_KEY, withMigrationLock };

package/dist/core/database/migrations/runner.d.ts

@@ -0,0 +1,25 @@
+import type { Migration, MigrationDatabase, MigrationStatus } from "./types.ts";
+type AppliedMigrationRow = {
+    name: string;
+    batch: number | string;
+};
+declare function ensureMigrationsTable(db: MigrationDatabase): Promise<void>;
+declare function getAppliedMigrations(db: MigrationDatabase): Promise<AppliedMigrationRow[]>;
+declare function loadMigrationsFromDirectory(directory: string): Promise<Migration[]>;
+declare function getMigrationStatus(db: MigrationDatabase, migrations: Migration[]): Promise<MigrationStatus[]>;
+declare function runPendingMigrations(db: MigrationDatabase, migrations: Migration[], options?: {
+    onMigration?: (name: string) => void;
+}): Promise<number>;
+declare function migrateDatabase(db: MigrationDatabase, migrations: Migration[], options?: {
+    advisoryLock?: boolean;
+    onMigration?: (name: string) => void;
+}): Promise<number>;
+declare function rollbackDatabase(db: MigrationDatabase, migrations: Migration[], options?: {
+    onMigration?: (name: string) => void;
+}): Promise<number>;
+declare function freshDatabase(db: MigrationDatabase, migrations: Migration[], options?: {
+    advisoryLock?: boolean;
+    onMigration?: (name: string) => void;
+}): Promise<void>;
+export { withMigrationLock } from "./advisoryLock.ts";
+export { ensureMigrationsTable, freshDatabase, getAppliedMigrations, getMigrationStatus, loadMigrationsFromDirectory, migrateDatabase, rollbackDatabase, runPendingMigrations, };

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

@@ -28,10 +28,10 @@ declare class Model<TEntity extends object, PrimaryKey extends keyof TEntity & s
     get id(): TEntity[PrimaryKey];
     toObject(): TEntity;
     protected primaryKey(): PrimaryKey;
-    protected static primaryKeyField(this: typeof Model): string;
-    protected static hydrateAttributes<TEntity extends object>(this: typeof Model, attributes: TEntity): TEntity;
-    protected static dehydrateAttributes(this: typeof Model, attributes: LoadedAttributes): LoadedAttributes;
-    protected static fromRecord<TEntity extends object, PrimaryKey extends keyof TEntity & string>(this: typeof Model, record: TEntity, repository: BaseRepository<TEntity, PrimaryKey>, exists?: boolean): Model<TEntity, PrimaryKey>;
+    protected static primaryKeyField(this: object): string;
+    protected static hydrateAttributes<TEntity extends object>(this: object, attributes: TEntity): TEntity;
+    protected static dehydrateAttributes(this: object, attributes: LoadedAttributes): LoadedAttributes;
+    protected static fromRecord<TEntity extends object, PrimaryKey extends keyof TEntity & string>(this: object, record: TEntity, repository: BaseRepository<TEntity, PrimaryKey>, exists?: boolean): Model<TEntity, PrimaryKey>;
     static boot(): void;
     static addGlobalScope<TEntity extends object, PrimaryKey extends keyof TEntity & string>(this: object, _name: string, scope: GlobalScopeFn<TEntity, PrimaryKey>): void;
     static repository<TEntity extends object, PrimaryKey extends keyof TEntity & string>(this: object): BaseRepository<TEntity, PrimaryKey>;

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

@@ -12,12 +12,12 @@ declare function buildWhereClause<TEntity extends object>(tableName: string, whe
     clause: string;
     params: unknown[];
 };
-declare function buildAdvancedWhereClause<TEntity extends object>(tableName: string, where?: QueryWhere<TEntity>, whereNodes?: readonly WhereNode<TEntity>[]): {
+declare function buildAdvancedWhereClause<TEntity extends object>(tableName: string, where?: QueryWhere<TEntity>, whereNodes?: readonly WhereNode<TEntity>[], params?: unknown[]): {
     clause: string;
     params: unknown[];
 };
 declare function resolveSoftDeleteColumn<TEntity>(table: TableDefinition<TEntity>): string | null;
-declare function buildQueryWhereClause<TEntity extends object>(table: TableDefinition<TEntity>, options?: Pick<QueryOptions<TEntity>, "where" | "withTrashed" | "onlyTrashed">, whereNodes?: readonly WhereNode<TEntity>[]): {
+declare function buildQueryWhereClause<TEntity extends object>(table: TableDefinition<TEntity>, options?: Pick<QueryOptions<TEntity>, "where" | "withTrashed" | "onlyTrashed">, whereNodes?: readonly WhereNode<TEntity>[], params?: unknown[]): {
     clause: string;
     params: unknown[];
 };

package/dist/core/database/seeders/runner.d.ts

@@ -0,0 +1,6 @@
+import type { Seeder, SeederDatabase } from "./types.ts";
+declare function loadSeedersFromDirectory(directory: string): Promise<Seeder[]>;
+declare function runSeedersFromDirectory(directory: string, db: SeederDatabase, options?: {
+    onSeeder?: (name: string) => void;
+}): Promise<number>;
+export { loadSeedersFromDirectory, runSeedersFromDirectory };

package/dist/core/database/seeders/types.d.ts

@@ -0,0 +1,8 @@
+interface SeederDatabase {
+    unsafe(query: string): Promise<unknown>;
+}
+interface Seeder {
+    name: string;
+    run(db: SeederDatabase): Promise<void>;
+}
+export type { Seeder, SeederDatabase };

package/dist/core/facades/index.d.ts

@@ -0,0 +1,10 @@
+declare function cache(): import("../../types/services").CacheLike;
+declare function auth(): import("../auth/guard").AuthManager;
+declare function policyGate(): import("../auth/policy").PolicyGate;
+declare function queue(): import("../queue").Queue;
+declare function events(): import("../events").EventBus;
+declare function config<T>(key: string): T | undefined;
+declare function log(): import("../logging/logger").Logger;
+declare function mail(): import("../mail/mailer").Mailer;
+declare function storageFacade(): import("../storage/storage").StorageManager;
+export { auth, cache, config, events, log, mail, policyGate, queue, storageFacade as storage };

package/dist/core/http/conditionalResponse.d.ts

@@ -0,0 +1,2 @@
+declare function conditionalJsonResponse(request: Request | undefined, data: unknown, init?: ResponseInit): Response;
+export { conditionalJsonResponse };

package/dist/core/http/etag.d.ts

@@ -0,0 +1,18 @@
+interface EtagVersioned {
+    id?: number | string;
+    updated_at?: Date | string | null;
+    created_at?: Date | string | null;
+}
+declare function isEtagEnabled(): boolean;
+declare function computeEtagFromJson(data: unknown): string;
+declare function etagFromResource(resource: EtagVersioned): string;
+declare function etagValuesMatch(left: string, right: string): boolean;
+declare function ifNoneMatchSatisfied(request: Request, etag: string): boolean;
+declare function ifMatchSatisfied(request: Request, etag: string): boolean;
+declare function assertIfMatch(request: Request, etag: string, options?: {
+    required?: boolean;
+}): void;
+declare function notModifiedResponse(etag: string): Response;
+declare function applyConditionalGet(request: Request, response: Response, etag: string): Response;
+export type { EtagVersioned };
+export { applyConditionalGet, assertIfMatch, computeEtagFromJson, etagFromResource, etagValuesMatch, ifMatchSatisfied, ifNoneMatchSatisfied, isEtagEnabled, notModifiedResponse, };

package/dist/core/http/formRequest.d.ts

@@ -0,0 +1,10 @@
+declare abstract class FormRequest<TOutput> {
+    authorize(_request: Request): boolean | Promise<boolean>;
+    protected abstract parse(payload: unknown): TOutput;
+    validate(request: Request): Promise<TOutput>;
+}
+declare abstract class QueryFormRequest<TOutput> {
+    validate(request?: Request): TOutput;
+    protected abstract parseQuery(request?: Request): TOutput;
+}
+export { FormRequest, QueryFormRequest };

package/dist/core/http/index.d.ts

@@ -0,0 +1,27 @@
+export { BadRequestError, ConflictError, ForbiddenError, HttpError, NotFoundError, PayloadTooLargeError, PreconditionFailedError, UnauthorizedError, UnprocessableEntityError, ValidationError, } from "../errors/http";
+export type { PaginatedResult, PaginationMeta } from "../pagination";
+export { createAuthMiddleware } from "./authMiddleware";
+export { createAuthorizeMiddleware } from "./authorizeMiddleware";
+export { conditionalJsonResponse } from "./conditionalResponse";
+export type { EtagVersioned } from "./etag";
+export { applyConditionalGet, assertIfMatch, computeEtagFromJson, etagFromResource, etagValuesMatch, ifMatchSatisfied, ifNoneMatchSatisfied, isEtagEnabled, notModifiedResponse, } from "./etag";
+export { FormRequest, QueryFormRequest } from "./formRequest";
+export type { Middleware, RouteHandler } from "./middleware";
+export { applyMiddlewareToRoutes, composeMiddleware, requestIdMiddleware, wrapRouteHandler, } from "./middleware";
+export { buildPaginationMeta, DEFAULT_PER_PAGE, MAX_PER_PAGE, paginatedResponse, parsePaginationQuery, } from "./pagination";
+export { createRequireAuthMiddleware } from "./requireAuthMiddleware";
+export { serializeDate, toPaginatedResourceCollection, toResourceCollection } from "./resources";
+export { withMiddleware } from "./routeMiddleware";
+export { bindRouteModel } from "./routeModelBinding";
+export { securedBindRouteModel, securedBindRouteModelByKey, } from "./securedRouteModelBinding";
+export { buildRequestCacheKey, expectObject, getQueryParams, parseJsonBody, parseOptionalBooleanQueryParam, parseOptionalEnumQueryParam, parseOptionalPositiveIntQueryParam, parsePositiveIntParam, readOptionalEnum, readOptionalPositiveInt, readOptionalString, readRequiredEnum, readRequiredPositiveInt, readRequiredString, } from "./validation";
+declare function jsonResponse(data: unknown, init?: ResponseInit): Response;
+declare function createdResponse(data: unknown, init?: ResponseInit): Response;
+declare function noContentResponse(): Response;
+declare function errorResponse(error: unknown): Response;
+declare function withErrorHandling<TArgs extends unknown[]>(handler: (...args: TArgs) => Response | Promise<Response>): (...args: TArgs) => Promise<Response>;
+export type { ParsedUpload } from "./parseMultipartUpload";
+export { parseMultipartUpload, sanitizeUploadFileName } from "./parseMultipartUpload";
+export type { RouteRequest } from "./route";
+export { getRouteParams } from "./route";
+export { createdResponse, errorResponse, jsonResponse, noContentResponse, withErrorHandling };

package/dist/core/http/pagination.d.ts

@@ -0,0 +1,11 @@
+import { buildPaginationMeta, type PaginatedResult, type PaginationMeta } from "../pagination";
+declare const DEFAULT_PER_PAGE = 15;
+declare const MAX_PER_PAGE = 100;
+interface PaginationQuery {
+    page: number;
+    perPage: number;
+}
+declare function parsePaginationQuery(request?: Request): PaginationQuery;
+declare function paginatedResponse<T>(data: T[], meta: PaginationMeta, init?: ResponseInit): Response;
+export type { PaginatedResult, PaginationMeta, PaginationQuery };
+export { buildPaginationMeta, DEFAULT_PER_PAGE, MAX_PER_PAGE, paginatedResponse, parsePaginationQuery, };

package/dist/core/http/parseFormBody.d.ts

@@ -0,0 +1,6 @@
+interface FormDataLike {
+    entries(): Iterable<[string, unknown]>;
+}
+declare function parseFormBody(request: Request): Promise<Record<string, string>>;
+declare function formDataToRecord(formData: FormDataLike): Record<string, string>;
+export { formDataToRecord, parseFormBody };

package/dist/core/http/parseMultipartUpload.d.ts

@@ -0,0 +1,10 @@
+interface ParsedUpload {
+    fileName: string;
+    mimeType: string;
+    size: number;
+    contents: Uint8Array;
+}
+declare function sanitizeUploadFileName(name: string): string;
+declare function parseMultipartUpload(request: Request, fieldName?: string): Promise<ParsedUpload>;
+export type { ParsedUpload };
+export { parseMultipartUpload, sanitizeUploadFileName };

package/dist/core/http/resources.d.ts

@@ -0,0 +1,7 @@
+declare function serializeDate(value: Date | string): string;
+declare function toResourceCollection<TInput, TOutput>(items: readonly TInput[], transformer: (item: TInput) => TOutput): TOutput[];
+declare function toPaginatedResourceCollection<TInput, TOutput, TMeta extends object>(items: readonly TInput[], meta: TMeta, transformer: (item: TInput) => TOutput): {
+    data: TOutput[];
+    meta: TMeta;
+};
+export { serializeDate, toPaginatedResourceCollection, toResourceCollection };

package/dist/core/http/route.d.ts

@@ -0,0 +1,6 @@
+type RouteRequest<TParams extends Record<string, string>> = Request & {
+    params: TParams;
+};
+declare function getRouteParams<TParams extends Record<string, string>>(request: RouteRequest<TParams>): TParams;
+export type { RouteRequest };
+export { getRouteParams };

package/dist/core/http/routeModelBinding.d.ts

@@ -0,0 +1,3 @@
+import type { RouteRequest } from "./route";
+declare function bindRouteModel<TParams extends Record<string, string>, TModel, TParam extends keyof TParams & string>(param: TParam, resolver: (id: number, request: RouteRequest<TParams>) => Promise<TModel>, handler: (request: RouteRequest<TParams>, model: TModel) => Response | Promise<Response>): (request: RouteRequest<TParams>) => Promise<Response>;
+export { bindRouteModel };

package/dist/core/http/securedRouteModelBinding.d.ts

@@ -0,0 +1,11 @@
+import type { Policy } from "../auth/policy";
+import type { RouteRequest } from "./route";
+interface RouteModelAuthorization {
+    resource: string;
+    action: keyof Policy;
+    requireIfMatch?: boolean;
+}
+declare function securedBindRouteModel<TParams extends Record<string, string>, TModel, TParam extends keyof TParams & string>(param: TParam, resolver: (id: number, request: RouteRequest<TParams>) => Promise<TModel>, authorization: RouteModelAuthorization, handler: (request: RouteRequest<TParams>, model: TModel) => Response | Promise<Response>): (request: RouteRequest<TParams>) => Promise<Response>;
+declare function securedBindRouteModelByKey<TParams extends Record<string, string>, TModel, TParam extends keyof TParams & string>(param: TParam, resolver: (key: string, request: RouteRequest<TParams>) => Promise<TModel>, authorization: RouteModelAuthorization, handler: (request: RouteRequest<TParams>, model: TModel) => Response | Promise<Response>): (request: RouteRequest<TParams>) => Promise<Response>;
+export type { RouteModelAuthorization };
+export { securedBindRouteModel, securedBindRouteModelByKey };

package/dist/core/http/validation.d.ts

@@ -0,0 +1,23 @@
+declare function buildRequestCacheKey(fallbackPath: string, request?: Request): string;
+declare function getQueryParams(request?: Request): URLSearchParams;
+declare function parseOptionalPositiveIntQueryParam(params: URLSearchParams, name: string): number | undefined;
+declare function parseOptionalBooleanQueryParam(params: URLSearchParams, name: string): boolean | undefined;
+declare function parseOptionalEnumQueryParam<TValue extends string>(params: URLSearchParams, name: string, allowedValues: readonly TValue[]): TValue | undefined;
+declare function expectObject(value: unknown, label?: string): Record<string, unknown>;
+declare function parseJsonBody<TValue>(request: Request, validator: (payload: unknown) => TValue): Promise<TValue>;
+declare function readRequiredString(payload: Record<string, unknown>, field: string, options?: {
+    minLength?: number;
+    maxLength?: number;
+    pattern?: RegExp;
+}): string;
+declare function readOptionalString(payload: Record<string, unknown>, field: string, options?: {
+    minLength?: number;
+    maxLength?: number;
+    pattern?: RegExp;
+}): string | undefined;
+declare function readRequiredEnum<TValue extends string>(payload: Record<string, unknown>, field: string, allowedValues: readonly TValue[]): TValue;
+declare function readOptionalEnum<TValue extends string>(payload: Record<string, unknown>, field: string, allowedValues: readonly TValue[]): TValue | undefined;
+declare function readRequiredPositiveInt(payload: Record<string, unknown>, field: string): number;
+declare function readOptionalPositiveInt(payload: Record<string, unknown>, field: string): number | undefined;
+declare function parsePositiveIntParam(value: string, name?: string): number;
+export { buildRequestCacheKey, expectObject, getQueryParams, parseJsonBody, parseOptionalBooleanQueryParam, parseOptionalEnumQueryParam, parseOptionalPositiveIntQueryParam, parsePositiveIntParam, readOptionalEnum, readOptionalPositiveInt, readOptionalString, readRequiredEnum, readRequiredPositiveInt, readRequiredString, };

package/dist/core/http/webErrorResponse.d.ts

@@ -0,0 +1,5 @@
+type FieldErrors = Record<string, string[]>;
+declare function normalizeFieldErrors(details: unknown): FieldErrors;
+declare function webErrorResponse(error: unknown, request?: Request): Response | null;
+export type { FieldErrors };
+export { normalizeFieldErrors, webErrorResponse };

package/dist/core/http/webFormRequest.d.ts

@@ -0,0 +1,7 @@
+declare abstract class WebFormRequest<TOutput> {
+    authorize(_request: Request): boolean | Promise<boolean>;
+    protected abstract parse(payload: unknown): TOutput;
+    validatePayload(payload: unknown): TOutput;
+    validate(request: Request): Promise<TOutput>;
+}
+export { WebFormRequest };

package/dist/core/lifecycle/gracefulShutdown.d.ts

@@ -0,0 +1,6 @@
+type ShutdownHandler = () => void | Promise<void>;
+declare function registerShutdownHandler(name: string, handler: ShutdownHandler): () => void;
+declare function runGracefulShutdown(signal: string): Promise<void>;
+declare function installGracefulShutdownSignals(signals?: NodeJS.Signals[]): void;
+declare function resetGracefulShutdownForTests(): void;
+export { installGracefulShutdownSignals, registerShutdownHandler, resetGracefulShutdownForTests, runGracefulShutdown, };

package/dist/core/mail/mailer.d.ts

@@ -0,0 +1,36 @@
+interface MailMessage {
+    to: string;
+    subject: string;
+    body: string;
+}
+interface MailDriver {
+    send(message: MailMessage): Promise<void>;
+}
+interface SmtpConfig {
+    host: string;
+    port: number;
+    username?: string;
+    password?: string;
+    from: string;
+    secure: boolean;
+}
+type SmtpTransport = (config: SmtpConfig, message: MailMessage) => Promise<void>;
+declare function resolveSmtpConfig(): SmtpConfig;
+declare class LogMailDriver implements MailDriver {
+    send(message: MailMessage): Promise<void>;
+}
+declare class SmtpMailDriver implements MailDriver {
+    private readonly config;
+    private readonly transport;
+    constructor(config: SmtpConfig, transport?: SmtpTransport);
+    send(message: MailMessage): Promise<void>;
+}
+declare class Mailer {
+    private readonly driver;
+    constructor(driver: MailDriver);
+    send(message: MailMessage): Promise<void>;
+}
+declare function createMailDriver(): MailDriver;
+declare function mailer(): Mailer;
+export type { MailDriver, MailMessage, SmtpConfig, SmtpTransport };
+export { createMailDriver, LogMailDriver, Mailer, mailer, resolveSmtpConfig, SmtpMailDriver };

package/dist/core/storage/storage.d.ts

@@ -0,0 +1,41 @@
+import { S3Client } from "bun";
+interface StorageDriver {
+    put(path: string, contents: string | Uint8Array): Promise<string>;
+    get(path: string): Promise<Uint8Array | null>;
+    delete(path: string): Promise<boolean>;
+}
+interface S3StorageConfig {
+    accessKeyId: string;
+    secretAccessKey: string;
+    bucket: string;
+    region?: string;
+    endpoint?: string;
+}
+declare class LocalStorageDriver implements StorageDriver {
+    private readonly rootDirectory;
+    constructor(rootDirectory: string);
+    private resolvePath;
+    put(path: string, contents: string | Uint8Array): Promise<string>;
+    get(path: string): Promise<Uint8Array | null>;
+    delete(path: string): Promise<boolean>;
+}
+declare class S3StorageDriver implements StorageDriver {
+    private readonly client;
+    constructor(client: S3Client);
+    put(path: string, contents: string | Uint8Array): Promise<string>;
+    get(path: string): Promise<Uint8Array | null>;
+    delete(path: string): Promise<boolean>;
+}
+declare class StorageManager {
+    private readonly driver;
+    constructor(driver: StorageDriver);
+    put(path: string, contents: string | Uint8Array): Promise<string>;
+    get(path: string): Promise<Uint8Array | null>;
+    delete(path: string): Promise<boolean>;
+}
+declare function resolveS3Config(): S3StorageConfig;
+declare function createS3Client(config?: S3StorageConfig): S3Client;
+declare function createStorageDriver(): StorageDriver;
+declare function storage(): StorageManager;
+export type { S3StorageConfig, StorageDriver };
+export { createS3Client, createStorageDriver, LocalStorageDriver, resolveS3Config, S3StorageDriver, StorageManager, storage, };

package/dist/core/validation/rules.d.ts

@@ -0,0 +1,17 @@
+type ValidationRule = (field: string, value: unknown, payload: Record<string, unknown>) => string | undefined;
+type ValidationSchema = Record<string, ValidationRule[]>;
+declare function required(): ValidationRule;
+declare function stringRule(): ValidationRule;
+declare function minLength(minimum: number): ValidationRule;
+declare function maxLength(maximum: number): ValidationRule;
+declare function pattern(expression: RegExp): ValidationRule;
+declare function enumRule<TValue extends string>(allowedValues: readonly TValue[]): ValidationRule;
+declare function optional(): ValidationRule;
+declare function integerRule(): ValidationRule;
+declare function emailRule(): ValidationRule;
+declare function confirmed(fieldName: string): ValidationRule;
+declare function positiveIntegerRule(): ValidationRule;
+declare function integerRange(minimum: number, maximum: number): ValidationRule;
+declare function validateObject(payload: unknown, schema: ValidationSchema): Record<string, unknown>;
+export type { ValidationRule, ValidationSchema };
+export { confirmed, emailRule, enumRule, integerRange, integerRule, maxLength, minLength, optional, pattern, positiveIntegerRule, required, stringRule, validateObject, };

package/dist/framework/public-api.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Stable framework surface for application modules and future package extraction.
+ * Import from `@getstrata/core` (workspace) or `src/framework/public-api`.
+ */
+export { resolveApplicationAuth, resolveApplicationCache, resolveApplicationConfig, resolveApplicationDependencies, resolveApplicationLogger, resolveApplicationPolicyGate, resolveApplicationQueue, setActiveApplicationContext, } from "../bootstrap/applicationRegistry.ts";
+export type { ServiceProvider } from "../bootstrap/contracts.ts";
+export { ConfigStore, resolveService, ServiceContainer, } from "../bootstrap/contracts.ts";
+export type { AbilityChecker } from "../core/auth/abilityChecker.ts";
+export type { AuthUser } from "../core/auth/authContext.ts";
+export { currentAuthUser, runWithAuthUser } from "../core/auth/authContext.ts";
+export { Policy, PolicyGate } from "../core/auth/policy.ts";
+export { default as CacheRepository } from "../core/cache/repository.ts";
+export { CACHE_TAGS } from "../core/cache/tags.ts";
+export type { DatabaseConnection } from "../core/database/baseRepository.ts";
+export { default as BaseRepository } from "../core/database/baseRepository.ts";
+export { bindDatabaseConnection } from "../core/database/bindConnection.ts";
+export { getActiveDatabaseConnection, runWithDatabaseConnection, } from "../core/database/connectionContext.ts";
+export { withMigrationLock } from "../core/database/migrations/advisoryLock.ts";
+export { freshDatabase, getMigrationStatus, loadMigrationsFromDirectory, migrateDatabase, rollbackDatabase, } from "../core/database/migrations/runner.ts";
+export type { Migration, MigrationDatabase, MigrationStatus, } from "../core/database/migrations/types.ts";
+export type { CastType, GlobalScopeFn, ModelConstructor } from "../core/database/model.ts";
+export { applyCasts, dehydrateValue, filterMassAssignable, hydrateValue, Model, registerModelRepository, } from "../core/database/model.ts";
+export type { BelongsToManyRelation, BelongsToRelation, HasManyRelation, HasOneRelation, } from "../core/database/relationships.ts";
+export { belongsTo, belongsToMany, hasMany, hasOne, indexBelongsToManyRelation, indexBelongsToRelation, indexHasManyRelation, indexHasOneRelation, } from "../core/database/relationships.ts";
+export { RepositoryQuery } from "../core/database/repositoryQuery.ts";
+export type { BlueprintAction, BlueprintCallback, ColumnKind, DatabaseDriver, ForeignKeyOptions, Grammar, IndexDefinition, IndexKind, ResolveDatabaseDriverOptions, SchemaBuilder, } from "../core/database/schema/index.ts";
+export { Blueprint, ColumnDefinition, compileBlueprint, createSchemaBuilder, ForeignIdColumnDefinition, grammarForDriver, inferReferencedTable, MySqlGrammar, PostgresGrammar, resolveDatabaseDriver, Schema, SqliteGrammar, UnsupportedSchemaFeatureError, } from "../core/database/schema/index.ts";
+export { loadSeedersFromDirectory, runSeedersFromDirectory, } from "../core/database/seeders/runner.ts";
+export type { Seeder, SeederDatabase } from "../core/database/seeders/types.ts";
+export { defineTable } from "../core/database/table.ts";
+export { runInTransaction } from "../core/database/transaction.ts";
+export type { QueryJoin, QueryJoinOn, QueryOptions, QueryOrder, QuerySelectItem, QueryWhere, } from "../core/database/types.ts";
+export type { WhereNode } from "../core/database/whereBuilder.ts";
+export { WhereBuilder } from "../core/database/whereBuilder.ts";
+export { BadRequestError, ConflictError, ForbiddenError, NotFoundError, PreconditionFailedError, UnauthorizedError, UnprocessableEntityError, ValidationError, } from "../core/errors/http.ts";
+export { EventBus } from "../core/events/eventBus.ts";
+export { auth, cache, config, events, log, mail, policyGate, queue, storage, } from "../core/facades/index.ts";
+export { createBodySizeLimitMiddleware } from "../core/http/bodySizeLimitMiddleware.ts";
+export { createCsrfMiddleware } from "../core/http/csrfMiddleware.ts";
+export { assertIfMatch, etagFromResource, isEtagEnabled, } from "../core/http/etag.ts";
+export { FormRequest } from "../core/http/formRequest.ts";
+export { applyMiddlewareToRoutes, composeMiddleware, createAuthMiddleware, createAuthorizeMiddleware, createdResponse, createRequireAuthMiddleware, jsonResponse, noContentResponse, paginatedResponse, parsePaginationQuery, securedBindRouteModel, securedBindRouteModelByKey, withErrorHandling, withMiddleware, } from "../core/http/index.ts";
+export { createLoginThrottleMiddleware } from "../core/http/loginThrottleMiddleware.ts";
+export { createMemoryThrottleMiddleware } from "../core/http/memoryThrottleMiddleware.ts";
+export { createMetricsMiddleware, normalizeMetricPath } from "../core/http/metricsMiddleware.ts";
+export type { Middleware, RouteHandler } from "../core/http/middleware.ts";
+export { createRequireWebAuthMiddleware } from "../core/http/requireWebAuthMiddleware.ts";
+export { serializeDate, toPaginatedResourceCollection, toResourceCollection, } from "../core/http/resources.ts";
+export type { RouteRequest } from "../core/http/route.ts";
+export { createSecurityHeadersMiddleware } from "../core/http/securityHeadersMiddleware.ts";
+export { createThrottleMiddleware } from "../core/http/throttleMiddleware.ts";
+export { WebFormRequest } from "../core/http/webFormRequest.ts";
+export { installGracefulShutdownSignals, registerShutdownHandler, runGracefulShutdown, } from "../core/lifecycle/gracefulShutdown.ts";
+export type { MailDriver, MailMessage } from "../core/mail/mailer.ts";
+export { LogMailDriver, Mailer, mailer } from "../core/mail/mailer.ts";
+export type { MetricLabels } from "../core/metrics/prometheus.ts";
+export { PrometheusRegistry, prometheusRegistry } from "../core/metrics/prometheus.ts";
+export type { CursorPaginatedResult, PaginatedResult, PaginationMeta, } from "../core/pagination/index.ts";
+export type { Queue, QueuePriority } from "../core/queue/index.ts";
+export { AsyncQueue, createQueue, Job, SyncQueue } from "../core/queue/index.ts";
+export { createFailedJobService, createProductionQueue, createQueueWorker, createTrackedJob, FailedJobRepository, FailedJobService, jobRegistry, QueueWorker, RedisQueue, ResilientQueue, } from "../core/queue/publicQueue.ts";
+export type { ScheduledTask } from "../core/scheduler/schedule.ts";
+export { appSchedule, runDueScheduledTasks, Schedule } from "../core/scheduler/schedule.ts";
+export type { StorageDriver } from "../core/storage/storage.ts";
+export { LocalStorageDriver, StorageManager } from "../core/storage/storage.ts";
+export type { ValidationRule, ValidationSchema } from "../core/validation/rules.ts";
+export { emailRule, maxLength, minLength, required, stringRule, validateObject, } from "../core/validation/rules.ts";
+export { DEFAULT_VIEWS_DIRECTORY, EtaViewEngine, htmlResponse, isHtmxRequest, resolveWebLayoutData, } from "../core/view/index.ts";
+export type { ViewEngine } from "../core/view/viewEngine.ts";
+export type { WebLayoutAuthUser, WebLayoutData } from "../core/view/webLayoutData.ts";

package/dist/index.js

@@ -1,4 +1,7 @@
 // @bun
+// ../../src/bootstrap/public-api.ts
+import { resolveApplicationQueue as resolveApplicationQueue2, setActiveApplicationContext as setActiveApplicationContext2 } from "@getstrata/core";
+
 // ../../src/core/scheduler/schedule.ts
 class Schedule {
   tasks = [];
@@ -487,6 +490,8 @@ var DEFAULT_CACHE_MAX_ENTRIES = 100;
 var DEFAULT_CACHE_DRIVER = "array";
 var DEFAULT_API_TOKEN = "";
 var DEFAULT_QUEUE_DRIVER = "sync";
+// ../../src/bootstrap/context.ts
+import { setActiveApplicationContext } from "@getstrata/core";
 
 // ../../src/bootstrap/contracts.ts
 class ServiceContainer {
@@ -572,30 +577,21 @@ 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);
-}
 // ../../src/bootstrap/discoverModules.ts
 import { readdirSync } from "fs";
 import { join } from "path";
 import { pathToFileURL } from "url";
 async function loadDiscoveredModules() {
   const modulesDirectory = join(import.meta.dir, "../modules");
-  const moduleNames = readdirSync(modulesDirectory, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+  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);
@@ -1739,6 +1735,21 @@ class InvalidateCacheTagsJob extends Job {
 }
 var invalidateCacheTagsJob_default = InvalidateCacheTagsJob;
 
+// ../../src/bootstrap/applicationRegistry.ts
+var activeContext;
+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);
+}
+
 // ../../src/core/jobs/dispatchWebhookJob.ts
 import { createHmac as createHmac2 } from "crypto";
 class DispatchWebhookJob extends Job {
@@ -2032,8 +2043,7 @@ function buildWhereGroupClause(tableName, nodes, params) {
   }
   return result;
 }
-function buildAdvancedWhereClause(tableName, where = {}, whereNodes = []) {
-  const params = [];
+function buildAdvancedWhereClause(tableName, where = {}, whereNodes = [], params = []) {
   const nodes = [];
   if (Object.keys(where).length > 0) {
     nodes.push({ kind: "and", where });
@@ -2068,18 +2078,18 @@ function appendSoftDeleteScope(table, options, clauses) {
     clauses.push(`${qualifiedColumn} IS NULL`);
   }
 }
-function buildQueryWhereClause(table, options = {}, whereNodes = []) {
-  const { clause, params } = buildAdvancedWhereClause(table.name, options.where ?? {}, whereNodes);
+function buildQueryWhereClause(table, options = {}, whereNodes = [], params = []) {
+  const { clause, params: whereParams } = buildAdvancedWhereClause(table.name, options.where ?? {}, whereNodes, params);
   const softDeleteClauses = [];
   appendSoftDeleteScope(table, options, softDeleteClauses);
   if (softDeleteClauses.length === 0) {
-    return { clause, params };
+    return { clause, params: whereParams };
   }
   const base = clause.replace(/^ WHERE /, "");
   const scope = softDeleteClauses.join(" AND ");
   return {
     clause: base ? ` WHERE (${base}) AND ${scope}` : ` WHERE ${scope}`,
-    params
+    params: whereParams
   };
 }
 function isQueryOrder(value) {
@@ -2183,8 +2193,7 @@ function getDefinedColumnEntries(table, values, options = {}) {
 function buildSelectQuery(table, options = {}, whereNodes = []) {
   const params = [];
   const columns = buildSelectList(table, options.select, params);
-  const { clause, params: whereParams } = buildQueryWhereClause(table, options, whereNodes);
-  params.push(...whereParams);
+  const { clause } = buildQueryWhereClause(table, options, whereNodes, params);
   const joins = buildJoinClause(options.joins);
   const groupBy = buildGroupByClause(table.name, options.groupBy);
   const havingClause = buildHavingClause(table.name, options.having, params);
@@ -4102,7 +4111,6 @@ function createAppContext() {
   setActiveApplicationContext(appContext);
   return appContext;
 }
-var appContext = createAppContext();
 // ../../src/bootstrap/createWebRoutes.ts
 import { join as join4 } from "path";
 
@@ -5444,12 +5452,12 @@ function slugify(value) {
 }
 export {
   slugify,
-  setActiveApplicationContext,
+  setActiveApplicationContext2 as setActiveApplicationContext,
   scheduleRunCommand,
   runProviderPhase,
   runDueScheduledTasks,
   resolveService,
-  resolveApplicationQueue,
+  resolveApplicationQueue2 as resolveApplicationQueue,
   prefixRouteMap,
   parseFormBody,
   mergeWebRoutes,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getstrata/bootstrap",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Strata application bootstrap — HttpKernel, DI, web session helpers",
   "type": "module",
   "license": "MIT",
@@ -73,7 +73,7 @@
     "access": "public"
   },
   "peerDependencies": {
-    "@getstrata/core": "^0.5.0",
+    "@getstrata/core": "^0.5.5",
     "typescript": "^5.9.0"
   }
 }