@getstrata/bootstrap 0.1.0 → 0.2.0

package/dist/bootstrap/context.d.ts

@@ -0,0 +1,6 @@
+import { type AppContext, type AppModule, type ProviderContext, type ServiceProvider } from "./contracts";
+declare function collectProviders(modules?: AppModule[]): ServiceProvider[];
+declare function runProviderPhase(providers: ServiceProvider[], phase: "register" | "boot", context: ProviderContext): void;
+declare function createAppContext(): AppContext;
+declare const appContext: AppContext;
+export { appContext, collectProviders, createAppContext, runProviderPhase };

package/dist/bootstrap/createWebRoutes.d.ts

@@ -0,0 +1,4 @@
+import type { AppDependencies, AppRouteMap } from "./contracts";
+declare function createWebRoutes(dependencies: AppDependencies): AppRouteMap;
+declare function mergeWebRoutes(dependencies: AppDependencies, routes: AppRouteMap): AppRouteMap;
+export { createWebRoutes, mergeWebRoutes };

package/dist/bootstrap/discoverListeners.d.ts

@@ -0,0 +1,5 @@
+type ListenerRegistrar = () => void;
+declare const appListeners: ListenerRegistrar[];
+declare function discoverListeners(): ListenerRegistrar[];
+export type { ListenerRegistrar };
+export { appListeners, discoverListeners };

package/dist/bootstrap/discoverModules.d.ts

@@ -0,0 +1,4 @@
+import type { AppModule } from "./contracts";
+declare const appModules: AppModule[];
+declare function discoverModules(): AppModule[];
+export { appModules, discoverModules };

package/dist/bootstrap/env.d.ts

@@ -0,0 +1,9 @@
+import { type EnvSchema } from "../core/config/envSchema";
+declare const appEnvSchema: EnvSchema;
+declare const appConfigKeys: {
+    readonly databaseUrl: "database.url";
+    readonly port: "app.port";
+    readonly cacheTtlMs: "cache.ttlMs";
+    readonly cacheMaxEntries: "cache.maxEntries";
+};
+export { appConfigKeys, appEnvSchema };

package/dist/bootstrap/httpKernel.d.ts

@@ -20,6 +20,8 @@ declare class HttpKernel {
     wrapAbility(ability: string, handler: RouteHandler): RouteHandler;
     wrapPolicy(resource: string, action: keyof Policy, handler: RouteHandler): RouteHandler;
     wrapLogin(handler: RouteHandler): RouteHandler;
+    wrapRegister(handler: RouteHandler): RouteHandler;
+    private wrapThrottle;
 }
 declare function createHttpKernel(dependencies: AppDependencies): HttpKernel;
 export type { MiddlewareGroupName };

package/dist/bootstrap/listeners/invalidateCacheOnModelWrite.d.ts

@@ -0,0 +1,3 @@
+import { type EventBus } from "../../core/events";
+declare function registerInvalidateCacheOnModelWriteListeners(bus?: EventBus): void;
+export { registerInvalidateCacheOnModelWriteListeners };

package/dist/bootstrap/modules.d.ts

@@ -0,0 +1 @@
+export { appModules, discoverModules } from "./discoverModules";

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

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

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

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

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

@@ -0,0 +1,5 @@
+import type { ServiceProvider } from "../contracts";
+import { appConfigKeys } from "../env";
+declare const configProvider: ServiceProvider;
+export default configProvider;
+export { appConfigKeys };

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

@@ -0,0 +1,5 @@
+import type { ServiceProvider } from "../contracts";
+declare const CORE_EVENT_BUS_TOKEN = "core.eventBus";
+declare const eventsProvider: ServiceProvider;
+export default eventsProvider;
+export { CORE_EVENT_BUS_TOKEN };

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,5 @@
+import type { ServiceProvider } from "../contracts";
+declare const CORE_VIEW_TOKEN = "core.view";
+declare const VIEW_DIRECTORY_CONFIG_KEY = "view.directory";
+declare const viewProvider: ServiceProvider;
+export { CORE_VIEW_TOKEN, VIEW_DIRECTORY_CONFIG_KEY, viewProvider };

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

@@ -1,10 +1,16 @@
 /**
  * @getstrata/bootstrap — application shell for Strata sibling apps.
  */
+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";
 export { assertAppDependenciesComplete, getRequiredDependency, resolveService, ServiceContainer, } from "./contracts.ts";
-export { createHttpKernel, type HttpKernel } from "./httpKernel.ts";
+export { createWebRoutes, mergeWebRoutes } from "./createWebRoutes.ts";
+export { createHttpKernel, type HttpKernel, type MiddlewareGroupName } from "./httpKernel.ts";
 export { prefixRouteMap } from "./prefixRouteMap.ts";
+export { coreProviders } from "./providers/index.ts";
 export { CookieSessionStore, createCsrfProtection, createWebServer, type ParsedForm, parseFormBody, type SessionUser, slugify, type WebServerOptions, } from "./web/index.ts";

package/dist/bootstrap/routeRegistry.d.ts

@@ -0,0 +1,14 @@
+interface RegisteredRoute {
+    method: string;
+    path: string;
+    middleware: string[];
+}
+declare class RouteRegistry {
+    private readonly routes;
+    register(route: RegisteredRoute): void;
+    clear(): void;
+    list(): RegisteredRoute[];
+}
+declare const routeRegistry: RouteRegistry;
+export type { RegisteredRoute };
+export { RouteRegistry, routeRegistry };

package/dist/bootstrap/schedule.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/bootstrap/secretsGuard.d.ts

@@ -0,0 +1,2 @@
+declare function assertProductionSecrets(env?: Record<string, string | undefined>): void;
+export { assertProductionSecrets };

package/dist/bootstrap/web/session.d.ts

@@ -2,6 +2,7 @@ export interface SessionUser {
     id: number;
     name: string;
     email: string;
+    learn_subscriber?: boolean;
 }
 type SqlClient = {
     unsafe<T>(query: string, params?: readonly unknown[]): Promise<T[]>;
@@ -14,6 +15,7 @@ export declare class CookieSessionStore {
     constructor(sql: SqlClient, secret: string, cookieName?: string, maxAgeSeconds?: number);
     cookieHeader(_user: SessionUser, sessionId: string): string;
     clearCookieHeader(): string;
+    private withSecureFlag;
     create(user: SessionUser): Promise<string>;
     destroy(sessionId: string): Promise<void>;
     read(request: Request): Promise<SessionUser | null>;

package/dist/cli/commands/scheduleRun.d.ts

@@ -0,0 +1,3 @@
+import "../../bootstrap/schedule";
+declare function scheduleRunCommand(): Promise<void>;
+export { scheduleRunCommand };

package/dist/config/auth.d.ts

@@ -0,0 +1,7 @@
+interface AuthConfig {
+    allowDevHeaders: boolean;
+    tokenDefaultAbilities: string[];
+}
+declare const authConfig: AuthConfig;
+export type { AuthConfig };
+export { authConfig };

package/dist/config/queue.d.ts

@@ -0,0 +1,8 @@
+interface QueueConfig {
+    driver: "sync" | "async" | "redis";
+    maxAttempts: number;
+    backoffMs: number;
+}
+declare const queueConfig: QueueConfig;
+export type { QueueConfig };
+export { queueConfig };

package/dist/config/rateLimit.d.ts

@@ -5,5 +5,6 @@ interface LoginRateLimitConfig {
 declare const LOCAL_LOGIN_RATE_LIMIT: LoginRateLimitConfig;
 declare const PRODUCTION_LOGIN_RATE_LIMIT: LoginRateLimitConfig;
 declare function resolveLoginRateLimit(): LoginRateLimitConfig;
+declare function resolveRegisterRateLimit(): LoginRateLimitConfig;
 export type { LoginRateLimitConfig };
-export { LOCAL_LOGIN_RATE_LIMIT, PRODUCTION_LOGIN_RATE_LIMIT, resolveLoginRateLimit };
+export { LOCAL_LOGIN_RATE_LIMIT, PRODUCTION_LOGIN_RATE_LIMIT, resolveLoginRateLimit, resolveRegisterRateLimit, };

package/dist/core/audit/exportAuditLogs.d.ts

@@ -0,0 +1,8 @@
+interface AuditExportConfig {
+    endpoint: string;
+    format: "json" | "cef";
+    batchSize: number;
+}
+declare function resolveAuditExportConfig(): AuditExportConfig | null;
+declare function exportPendingAuditLogs(): Promise<number>;
+export { exportPendingAuditLogs, resolveAuditExportConfig };

package/dist/core/audit/siemFormatter.d.ts

@@ -0,0 +1,30 @@
+interface SiemAuditEvent {
+    timestamp: string;
+    event_type: string;
+    actor_user_id: number | null;
+    tenant_id: number | null;
+    trace_id: string | null;
+    action: string;
+    subject_type: string;
+    subject_id: number | null;
+    ip_address: string | null;
+    user_agent: string | null;
+    checksum: string | null;
+    payload: Record<string, unknown>;
+}
+declare function formatSiemAuditEvent(input: {
+    action: string;
+    subject_type: string;
+    subject_id: number | null;
+    user_id: number | null;
+    tenant_id?: number | null;
+    trace_id?: string | null;
+    ip_address?: string | null;
+    user_agent?: string | null;
+    checksum?: string | null;
+    payload?: Record<string, unknown>;
+    created_at: Date;
+}): SiemAuditEvent;
+declare function formatCefLine(event: SiemAuditEvent): string;
+export type { SiemAuditEvent };
+export { formatCefLine, formatSiemAuditEvent };

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

@@ -0,0 +1,6 @@
+import type { AuthUser } from "./authContext";
+interface AbilityChecker {
+    tokenCan(user: AuthUser | null, ability: string): boolean;
+    requireAbility(user: AuthUser | null, ability: string): void;
+}
+export type { AbilityChecker };

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

@@ -9,7 +9,7 @@ declare class PolicyGate {
     constructor();
     private readonly policies;
     register(resource: string, policy: Policy): void;
-    allows(resource: string, action: keyof Policy, user?: unknown, model?: unknown): boolean;
-    authorize(resource: string, action: keyof Policy, user?: unknown, model?: unknown): void;
+    allows(resource: string, action: string, user?: unknown, model?: unknown): boolean;
+    authorize(resource: string, action: string, user?: unknown, model?: unknown): void;
 }
 export { Policy, PolicyGate };

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

@@ -0,0 +1,6 @@
+declare const SESSION_COOKIE = "workhub_session";
+declare const SESSION_TTL_SECONDS: number;
+declare function readSessionUserId(request: Request): number | null;
+declare function createSessionCookie(userId: number): string;
+declare function clearSessionCookie(): string;
+export { clearSessionCookie, createSessionCookie, readSessionUserId, SESSION_COOKIE, SESSION_TTL_SECONDS, };

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

@@ -0,0 +1,9 @@
+import type { ServiceContainer } from "../../bootstrap/contracts";
+import type { AuthUser } from "./authContext";
+import type { AuthGuard } from "./guard";
+declare class SessionGuard implements AuthGuard {
+    private readonly container;
+    constructor(container: ServiceContainer);
+    resolve(request: Request): Promise<AuthUser | null>;
+}
+export { SessionGuard };

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

@@ -0,0 +1,11 @@
+import type { CacheStore } from "./store";
+type CacheDriver = "array" | "redis";
+interface CreateCacheStoreOptions {
+    driver: CacheDriver;
+    ttlMs: number;
+    maxEntries: number;
+    redisUrl?: string;
+}
+declare function createCacheStore(options: CreateCacheStoreOptions): CacheStore;
+export type { CacheDriver, CreateCacheStoreOptions };
+export { createCacheStore };

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

@@ -0,0 +1,3 @@
+declare function cacheTagsForModelWrite(tableName: string, action: string): string[];
+declare function discoverModelTableNames(): string[];
+export { cacheTagsForModelWrite, discoverModelTableNames };

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

@@ -0,0 +1,23 @@
+import type { CacheStore } from "./store";
+declare class RedisCacheStore implements CacheStore {
+    private readonly ttlMs;
+    private readonly maxEntries;
+    private readonly client;
+    private readonly inflight;
+    private readonly keyTags;
+    constructor(redisUrl: string, ttlMs: number, maxEntries: number);
+    get<T>(key: string): Promise<T | undefined>;
+    set<T>(key: string, value: T, ttlMs?: number): Promise<void>;
+    getOrSet<T>(key: string, loader: () => Promise<T>, ttlMs?: number): Promise<T>;
+    attachTags(key: string, tags: string[]): Promise<void>;
+    flushTags(tags: string[]): Promise<number>;
+    invalidate(key: string): Promise<boolean>;
+    invalidateByPrefix(prefix: string): Promise<number>;
+    clear(): Promise<void>;
+    size(): Promise<number>;
+    private storageKey;
+    private tagKey;
+    private detachKeyFromTags;
+    private enforceMaxEntries;
+}
+export default RedisCacheStore;

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

@@ -0,0 +1,17 @@
+import type { CacheStore } from "./store";
+import TaggedCache from "./taggedCache";
+declare class CacheRepository {
+    private readonly store;
+    constructor(store: CacheStore);
+    get<T>(key: string): Promise<T | undefined>;
+    remember<T>(key: string, callback: () => Promise<T>, ttlMs?: number): Promise<T>;
+    forget(key: string): Promise<boolean>;
+    flush(): Promise<void>;
+    tags(...names: string[]): TaggedCache;
+    getOrSet<T>(key: string, loader: () => Promise<T>, ttlMs?: number): Promise<T>;
+    invalidate(key: string): Promise<boolean>;
+    invalidateByPrefix(prefix: string): Promise<number>;
+    clear(): Promise<void>;
+    size(): Promise<number>;
+}
+export default CacheRepository;

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

@@ -0,0 +1,23 @@
+declare class SimpleCache {
+    private readonly ttlMs;
+    private readonly maxEntries;
+    private readonly cache;
+    private readonly inflight;
+    private readonly tagIndex;
+    private readonly keyTags;
+    constructor(ttlMs?: number, maxEntries?: number);
+    get<T>(key: string): T | undefined;
+    set<T>(key: string, value: T, ttlMs?: number): void;
+    getOrSet<T>(key: string, loader: () => Promise<T>, ttlMs?: number): Promise<T>;
+    attachTags(key: string, tags: string[]): void;
+    flushTags(tags: string[]): number;
+    invalidate(key: string): boolean;
+    invalidateByPrefix(prefix: string): number;
+    clear(): void;
+    size(): number;
+    private detachKeyFromTags;
+    private getFreshEntry;
+    private pruneExpired;
+    private evictOverflow;
+}
+export default SimpleCache;

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

@@ -0,0 +1,16 @@
+import type SimpleCache from "./simpleCache";
+import type { CacheStore } from "./store";
+declare class SimpleCacheStore implements CacheStore {
+    private readonly cache;
+    constructor(cache: SimpleCache);
+    get<T>(key: string): Promise<T | undefined>;
+    set<T>(key: string, value: T, ttlMs?: number): Promise<void>;
+    getOrSet<T>(key: string, loader: () => Promise<T>, ttlMs?: number): Promise<T>;
+    attachTags(key: string, tags: string[]): Promise<void>;
+    flushTags(tags: string[]): Promise<number>;
+    invalidate(key: string): Promise<boolean>;
+    invalidateByPrefix(prefix: string): Promise<number>;
+    clear(): Promise<void>;
+    size(): Promise<number>;
+}
+export default SimpleCacheStore;

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

@@ -0,0 +1,12 @@
+interface CacheStore {
+    get<T>(key: string): Promise<T | undefined>;
+    set<T>(key: string, value: T, ttlMs?: number): Promise<void>;
+    getOrSet<T>(key: string, loader: () => Promise<T>, ttlMs?: number): Promise<T>;
+    attachTags(key: string, tags: string[]): Promise<void>;
+    flushTags(tags: string[]): Promise<number>;
+    invalidate(key: string): Promise<boolean>;
+    invalidateByPrefix(prefix: string): Promise<number>;
+    clear(): Promise<void>;
+    size(): Promise<number>;
+}
+export type { CacheStore };

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

@@ -0,0 +1,9 @@
+import type { CacheStore } from "./store";
+declare class TaggedCache {
+    private readonly store;
+    private readonly tags;
+    constructor(store: CacheStore, tags: string[]);
+    remember<T>(key: string, callback: () => Promise<T>, ttlMs?: number): Promise<T>;
+    flush(): Promise<number>;
+}
+export default TaggedCache;

package/dist/core/config/envSchema.d.ts

@@ -0,0 +1,12 @@
+interface EnvRule {
+    required?: boolean;
+    integer?: boolean;
+    minimum?: number;
+    default?: string;
+    pattern?: RegExp;
+}
+type EnvSchema = Record<string, EnvRule>;
+declare function defineEnvSchema(schema: EnvSchema): EnvSchema;
+declare function validateEnv(schema: EnvSchema, env?: Record<string, string | undefined>): Record<string, string>;
+export type { EnvRule, EnvSchema };
+export { defineEnvSchema, validateEnv };

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

@@ -1,7 +1,12 @@
-import { type PaginatedResult } from "../pagination/index.ts";
+import { type CursorPaginatedResult, type PaginatedResult } from "../pagination/index.ts";
 import { type BelongsToRelation, type HasManyRelation } from "./relationships.ts";
+import { RepositoryQuery } from "./repositoryQuery.ts";
 import type { TableDefinition } from "./table.ts";
 import type { MutationValues, QueryOptions, QueryWhere, UpdateValues } from "./types.ts";
+import type { WhereNode } from "./whereBuilder.ts";
+type ExtendedQueryOptions<TEntity extends object> = QueryOptions<TEntity> & {
+    whereNodes?: WhereNode<TEntity>[];
+};
 interface DatabaseConnection {
     unsafe<T>(query: string, params?: readonly unknown[]): Promise<T[]>;
 }
@@ -10,11 +15,18 @@ declare class BaseRepository<TEntity extends object, PrimaryKey extends keyof TE
     protected readonly table: TableDefinition<TEntity, PrimaryKey>;
     protected readonly connection: DatabaseConnection;
     constructor(table: TableDefinition<TEntity, PrimaryKey>, connection?: DatabaseConnection);
-    findAll(options?: QueryOptions<TEntity>): Promise<TEntity[]>;
+    findAll(options?: ExtendedQueryOptions<TEntity>): Promise<TEntity[]>;
     paginate(options: {
         page: number;
         perPage: number;
-    } & Omit<QueryOptions<TEntity>, "limit" | "offset">): Promise<PaginatedResult<TEntity>>;
+    } & Omit<ExtendedQueryOptions<TEntity>, "limit" | "offset">): Promise<PaginatedResult<TEntity>>;
+    chunk(count: number, callback: (rows: TEntity[]) => Promise<boolean | void>, options?: Omit<ExtendedQueryOptions<TEntity>, "limit" | "offset">): Promise<void>;
+    cursorPaginate(options: {
+        perPage: number;
+        cursor?: TEntity[PrimaryKey];
+        cursorColumn?: PrimaryKey;
+        direction?: "asc" | "desc";
+    } & Omit<ExtendedQueryOptions<TEntity>, "limit" | "offset">): Promise<CursorPaginatedResult<TEntity, TEntity[PrimaryKey]>>;
     findById(id: TEntity[PrimaryKey]): Promise<TEntity | null>;
     findByIdOrThrow(id: TEntity[PrimaryKey], errorFactory?: ErrorFactory<TEntity[PrimaryKey]>): Promise<TEntity>;
     findByIds(ids: readonly TEntity[PrimaryKey][]): Promise<TEntity[]>;
@@ -27,8 +39,11 @@ declare class BaseRepository<TEntity extends object, PrimaryKey extends keyof TE
     forceDeleteById(id: TEntity[PrimaryKey]): Promise<boolean>;
     restoreById(id: TEntity[PrimaryKey]): Promise<TEntity | null>;
     withConnection(connection: DatabaseConnection): this;
+    getConnection(): DatabaseConnection;
+    getTable(): TableDefinition<TEntity, PrimaryKey>;
+    query(where?: QueryWhere<TEntity>): RepositoryQuery<TEntity, PrimaryKey>;
     protected findWhere(where: QueryWhere<TEntity>, options?: Omit<QueryOptions<TEntity>, "where">): Promise<TEntity[]>;
-    protected countWhere(where?: QueryWhere<TEntity>, options?: Pick<QueryOptions<TEntity>, "withTrashed" | "onlyTrashed">): Promise<number>;
+    protected countWhere(where?: QueryWhere<TEntity>, options?: Pick<QueryOptions<TEntity>, "withTrashed" | "onlyTrashed" | "joins" | "groupBy">, whereNodes?: readonly WhereNode<TEntity>[]): Promise<number>;
     protected averageColumn(column: keyof TEntity & string, where?: QueryWhere<TEntity>): Promise<number>;
     protected averageExpression(expression: string, alias: string, where?: QueryWhere<TEntity>): Promise<number>;
     protected pluckNumberValues(expression: string, alias: string, options?: QueryOptions<TEntity>): Promise<number[]>;
@@ -36,9 +51,9 @@ declare class BaseRepository<TEntity extends object, PrimaryKey extends keyof TE
         value: TEntity[K] | null;
         count: number;
     }>>;
-    protected findByHasManyRelation<TParent extends object, LocalKey extends keyof TParent & string, ForeignKey extends keyof TEntity & string>(relation: HasManyRelation<TParent, TEntity, LocalKey, ForeignKey>, parentId: TParent[LocalKey], options?: Omit<QueryOptions<TEntity>, "where">): Promise<TEntity[]>;
-    protected loadHasManyForParents<TParent extends object, LocalKey extends keyof TParent & string, ForeignKey extends keyof TEntity & string>(parents: readonly TParent[], relation: HasManyRelation<TParent, TEntity, LocalKey, ForeignKey>, options?: Omit<QueryOptions<TEntity>, "where">): Promise<Map<TParent[LocalKey], TEntity[]>>;
-    protected loadBelongsToForParents<TChild extends object, TParent extends object, ForeignKey extends keyof TChild & string, OwnerKey extends keyof TParent & string>(children: readonly TChild[], relation: BelongsToRelation<TChild, TParent, ForeignKey, OwnerKey>, parentRepository: BaseRepository<TParent, OwnerKey>, options?: Omit<QueryOptions<TParent>, "where">): Promise<Map<TChild[ForeignKey], TParent>>;
+    findByHasManyRelation<TParent extends object, LocalKey extends keyof TParent & string, ForeignKey extends keyof TEntity & string>(relation: HasManyRelation<TParent, TEntity, LocalKey, ForeignKey>, parentId: TParent[LocalKey], options?: Omit<QueryOptions<TEntity>, "where">): Promise<TEntity[]>;
+    loadHasManyForParents<TParent extends object, LocalKey extends keyof TParent & string, ForeignKey extends keyof TEntity & string>(parents: readonly TParent[], relation: HasManyRelation<TParent, TEntity, LocalKey, ForeignKey>, options?: Omit<QueryOptions<TEntity>, "where">): Promise<Map<TParent[LocalKey], TEntity[]>>;
+    loadBelongsToForParents<TChild extends object, TParent extends object, ForeignKey extends keyof TChild & string, OwnerKey extends keyof TParent & string>(children: readonly TChild[], relation: BelongsToRelation<TChild, TParent, ForeignKey, OwnerKey>, parentRepository: BaseRepository<TParent, OwnerKey>, options?: Omit<QueryOptions<TParent>, "where">): Promise<Map<TChild[ForeignKey], TParent>>;
 }
 export default BaseRepository;
 export type { DatabaseConnection };

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

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

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

@@ -2,10 +2,17 @@ export type { DatabaseConnection } from "./baseRepository.ts";
 export { default as BaseRepository } from "./baseRepository.ts";
 export { createDatabaseConnection } from "./connection.ts";
 export { mapDatabaseError, withDatabaseErrorHandling } from "./errors.ts";
-export { buildCountQuery, buildDeleteByIdQuery, buildGroupedCountQuery, buildInsertQuery, buildOrderByClause, buildProjectionQuery, buildQueryWhereClause, buildRestoreByIdQuery, buildSelectQuery, buildSoftDeleteByIdQuery, buildUpdateQuery, buildWhereClause, qualifyColumn, quoteIdentifier, resolveSoftDeleteColumn, } from "./query.ts";
-export type { BelongsToRelation, HasManyRelation } from "./relationships.ts";
-export { belongsTo, hasMany, indexBelongsToRelation, indexHasManyRelation, } from "./relationships.ts";
+export type { CastType, GlobalScopeFn, ModelConstructor } from "./model.ts";
+export { applyCasts, dehydrateValue, filterMassAssignable, hydrateValue, Model, registerModelRepository, } from "./model.ts";
+export { buildAdvancedWhereClause, buildCountQuery, buildDeleteByIdQuery, buildGroupedCountQuery, buildInsertQuery, buildJoinClause, buildOrderByClause, buildProjectionQuery, buildQueryWhereClause, buildRestoreByIdQuery, buildSelectQuery, buildSoftDeleteByIdQuery, buildUpdateQuery, buildWhereClause, parseQualifiedColumn, qualifyColumn, quoteIdentifier, resolveQualifiedColumn, resolveSoftDeleteColumn, } from "./query.ts";
+export type { BelongsToManyRelation, BelongsToRelation, HasManyRelation, HasOneRelation, } from "./relationships.ts";
+export { belongsTo, belongsToMany, hasMany, hasOne, indexBelongsToManyRelation, indexBelongsToRelation, indexHasManyRelation, indexHasOneRelation, } from "./relationships.ts";
+export { RepositoryQuery } from "./repositoryQuery.ts";
+export type { BlueprintAction, BlueprintCallback, ColumnKind, DatabaseDriver, ForeignKeyOptions, Grammar, IndexDefinition, IndexKind, ResolveDatabaseDriverOptions, SchemaBuilder, } from "./schema/index.ts";
+export { Blueprint, ColumnDefinition, compileBlueprint, createSchemaBuilder, ForeignIdColumnDefinition, grammarForDriver, inferReferencedTable, MySqlGrammar, PostgresGrammar, resolveDatabaseDriver, Schema, SqliteGrammar, UnsupportedSchemaFeatureError, } from "./schema/index.ts";
 export type { TableDefinition } from "./table.ts";
 export { defineTable } from "./table.ts";
 export { runInTransaction } from "./transaction.ts";
-export type { DatabaseComparable, DatabaseScalar, MutationValues, QueryFilterValue, QueryOperator, QueryOptions, QueryOrder, QueryWhere, UpdateValues, } from "./types.ts";
+export type { DatabaseComparable, DatabaseScalar, MutationValues, QueryFilterValue, QueryJoin, QueryJoinOn, QueryOperator, QueryOptions, QueryOrder, QuerySelectItem, QueryWhere, UpdateValues, } from "./types.ts";
+export type { WhereNode } from "./whereBuilder.ts";
+export { WhereBuilder } from "./whereBuilder.ts";

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

@@ -0,0 +1,15 @@
+interface MigrationDatabase {
+    unsafe<T = unknown>(query: string, params?: readonly unknown[]): Promise<T[]>;
+    schema?: import("../schema/schema.ts").SchemaBuilder;
+}
+interface Migration {
+    name: string;
+    up(db: MigrationDatabase): Promise<void>;
+    down(db: MigrationDatabase): Promise<void>;
+}
+type MigrationStatus = {
+    name: string;
+    status: "up" | "pending";
+    batch: number | null;
+};
+export type { Migration, MigrationDatabase, MigrationStatus };

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

@@ -0,0 +1,57 @@
+import type BaseRepository from "./baseRepository.ts";
+import type { BelongsToManyRelation, BelongsToRelation, HasManyRelation, HasOneRelation } from "./relationships.ts";
+import type { RepositoryQuery } from "./repositoryQuery.ts";
+import type { QueryOptions, QueryWhere } from "./types.ts";
+type CastType = "date" | "datetime" | "json" | "bool" | "boolean";
+type LoadedAttributes = Record<string, unknown>;
+type ModelCasts = Partial<Record<string, CastType>>;
+type GlobalScopeFn<TEntity extends object, PrimaryKey extends keyof TEntity & string> = (query: RepositoryQuery<TEntity, PrimaryKey>) => RepositoryQuery<TEntity, PrimaryKey>;
+type ModelClassType<TEntity extends object, PrimaryKey extends keyof TEntity & string> = typeof Model & (new (attributes: TEntity, repository: BaseRepository<TEntity, PrimaryKey>, exists?: boolean) => Model<TEntity, PrimaryKey>);
+interface ModelConstructor<TEntity extends object, PrimaryKey extends keyof TEntity & string, TModel extends Model<TEntity, PrimaryKey>> extends ModelClassType<TEntity, PrimaryKey> {
+    new (attributes: TEntity, repository: BaseRepository<TEntity, PrimaryKey>, exists?: boolean): TModel;
+}
+declare function hydrateValue(value: unknown, cast: CastType): unknown;
+declare function dehydrateValue(value: unknown, cast: CastType): unknown;
+declare function filterMassAssignable(fillable: readonly string[] | undefined, guarded: readonly string[] | true | undefined, input: LoadedAttributes): LoadedAttributes;
+declare function applyCasts(values: LoadedAttributes, casts: ModelCasts, direction: "hydrate" | "dehydrate"): LoadedAttributes;
+declare class Model<TEntity extends object, PrimaryKey extends keyof TEntity & string> {
+    protected attributes: TEntity;
+    protected readonly repository: BaseRepository<TEntity, PrimaryKey>;
+    static $fillable?: readonly string[];
+    static $guarded?: readonly string[] | true;
+    static $casts: ModelCasts;
+    static $timestamps: boolean;
+    private _exists;
+    constructor(attributes: TEntity, repository: BaseRepository<TEntity, PrimaryKey>, exists?: boolean);
+    get $exists(): boolean;
+    get<K extends keyof TEntity>(key: K): TEntity[K];
+    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>;
+    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>;
+    static query<TEntity extends object, PrimaryKey extends keyof TEntity & string>(this: object): RepositoryQuery<TEntity, PrimaryKey>;
+    static create(this: object, attributes: Record<string, unknown>): Promise<Model<Record<string, unknown>, "id">>;
+    static find(this: object, id: unknown): Promise<Model<Record<string, unknown>, "id"> | null>;
+    static findOrFail(this: object, id: unknown, errorFactory?: (id: unknown) => Error): Promise<Model<Record<string, unknown>, "id">>;
+    static all(this: object, options?: Omit<QueryOptions<object>, "where">): Promise<Array<Model<Record<string, unknown>, "id">>>;
+    static firstWhere(this: object, where: QueryWhere<object>, options?: Omit<QueryOptions<object>, "where">): Promise<Model<Record<string, unknown>, "id"> | null>;
+    save(): Promise<this>;
+    update(changes: Partial<TEntity>): Promise<this>;
+    delete(): Promise<boolean>;
+    forceDelete(): Promise<boolean>;
+    restore(): Promise<this | null>;
+    loadHasMany<TChild extends object, LocalKey extends keyof TEntity & string, ForeignKey extends keyof TChild & string, Alias extends string>(as: Alias, relation: HasManyRelation<TEntity, TChild, LocalKey, ForeignKey>, childRepository: BaseRepository<TChild, keyof TChild & string>, options?: Omit<QueryOptions<TChild>, "where">): Promise<this & Record<Alias, TChild[]>>;
+    loadHasOne<TChild extends object, LocalKey extends keyof TEntity & string, ForeignKey extends keyof TChild & string, Alias extends string>(as: Alias, relation: HasOneRelation<TEntity, TChild, LocalKey, ForeignKey>, childRepository: BaseRepository<TChild, keyof TChild & string>, options?: Omit<QueryOptions<TChild>, "where">): Promise<this & Record<Alias, TChild | undefined>>;
+    loadBelongsTo<TParent extends object, ForeignKey extends keyof TEntity & string, OwnerKey extends keyof TParent & string, Alias extends string>(as: Alias, relation: BelongsToRelation<TEntity, TParent, ForeignKey, OwnerKey>, parentRepository: BaseRepository<TParent, OwnerKey>, options?: Omit<QueryOptions<TParent>, "where">): Promise<this & Record<Alias, TParent | undefined>>;
+    loadBelongsToMany<TRelated extends object, Pivot extends object, ParentKey extends keyof TEntity & string, RelatedKey extends keyof TRelated & string, ForeignPivotKey extends keyof Pivot & string, RelatedPivotKey extends keyof Pivot & string, Alias extends string>(as: Alias, relation: BelongsToManyRelation<TEntity, TRelated, Pivot, ParentKey, RelatedKey, ForeignPivotKey, RelatedPivotKey>, relatedRepository: BaseRepository<TRelated, RelatedKey>, options?: Omit<QueryOptions<TRelated>, "where">): Promise<this & Record<Alias, TRelated[]>>;
+    mergeAttributes(patch: Partial<TEntity>): this;
+}
+declare function registerModelRepository<TModelClass>(model: TModelClass, repository: object): TModelClass;
+export type { CastType, GlobalScopeFn, ModelClassType, ModelConstructor };
+export { applyCasts, dehydrateValue, filterMassAssignable, hydrateValue, Model, registerModelRepository, };