@getstrata/core 0.2.0 → 0.3.2

package/README.md

@@ -9,7 +9,11 @@ WorkHub is the reference application built on Strata; import the framework from
 
 ## Usage
 
+Set `DATABASE_URL` before importing (connection is created lazily on first query):
+
 ```typescript
+process.env.DATABASE_URL ??= "postgresql://postgres:postgres@localhost:5432/myapp";
+
 import {
   BaseRepository,
   FormRequest,
@@ -20,6 +24,8 @@ import {
 } from "@getstrata/core";
 ```
 
+`orderBy` accepts explicit `{ column, direction }` objects or Laravel-style shorthand `{ published_at: "desc" }`.
+
 ## Build & verify (monorepo root)
 
 ```bash

package/dist/bootstrap/applicationRegistry.d.ts

@@ -0,0 +1,16 @@
+import type { AuthManager } from "../core/auth/guard";
+import type { PolicyGate } from "../core/auth/policy";
+import { type Logger } from "../core/logging/logger";
+import type { Queue } from "../core/queue";
+import type { CacheLike } from "../types/services";
+import type { AppContext } from "./contracts";
+import { type ConfigStore } from "./contracts";
+declare function setActiveApplicationContext(context: AppContext): void;
+declare function resolveApplicationCache(): CacheLike;
+declare function resolveApplicationQueue(): Queue;
+declare function resolveApplicationAuth(): AuthManager;
+declare function resolveApplicationPolicyGate(): PolicyGate;
+declare function resolveApplicationConfig(): ConfigStore;
+declare function resolveApplicationLogger(): Logger;
+declare function resolveApplicationDependencies(): import("./contracts").AppDependencies;
+export { resolveApplicationAuth, resolveApplicationCache, resolveApplicationConfig, resolveApplicationDependencies, resolveApplicationLogger, resolveApplicationPolicyGate, resolveApplicationQueue, setActiveApplicationContext, };

package/dist/bootstrap/config.d.ts

@@ -0,0 +1,20 @@
+declare const APP_PORT_CONFIG_KEY = "app.port";
+declare const CACHE_TTL_MS_CONFIG_KEY = "cache.ttlMs";
+declare const CACHE_MAX_ENTRIES_CONFIG_KEY = "cache.maxEntries";
+declare const CACHE_DRIVER_CONFIG_KEY = "cache.driver";
+declare const REDIS_URL_CONFIG_KEY = "cache.redisUrl";
+declare const DATABASE_URL_CONFIG_KEY = "database.url";
+declare const CORE_CONFIG_TOKEN = "core.config";
+declare const CORE_CACHE_TOKEN = "core.cache";
+declare const CORE_QUEUE_TOKEN = "core.queue";
+declare const CORE_POLICY_GATE_TOKEN = "core.policyGate";
+declare const CORE_AUTH_TOKEN = "core.auth";
+declare const CORE_TOKEN_SERVICE_TOKEN = "core.tokenService";
+declare const AUTH_DEV_HEADERS_CONFIG_KEY = "auth.allowDevHeaders";
+declare const DEFAULT_APP_PORT = 3000;
+declare const DEFAULT_CACHE_TTL_MS = 3600000;
+declare const DEFAULT_CACHE_MAX_ENTRIES = 100;
+declare const DEFAULT_CACHE_DRIVER = "array";
+declare const DEFAULT_API_TOKEN = "";
+declare const DEFAULT_QUEUE_DRIVER = "sync";
+export { APP_PORT_CONFIG_KEY, AUTH_DEV_HEADERS_CONFIG_KEY, CACHE_DRIVER_CONFIG_KEY, CACHE_MAX_ENTRIES_CONFIG_KEY, CACHE_TTL_MS_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_API_TOKEN, DEFAULT_APP_PORT, DEFAULT_CACHE_DRIVER, DEFAULT_CACHE_MAX_ENTRIES, DEFAULT_CACHE_TTL_MS, DEFAULT_QUEUE_DRIVER, REDIS_URL_CONFIG_KEY, };

package/dist/bootstrap/contracts.d.ts

@@ -0,0 +1,63 @@
+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;
+}
+type MutableAppDependencies = Partial<Omit<AppDependencies, "container">> & Pick<AppDependencies, "container">;
+interface ProviderContext {
+    container: ServiceContainer;
+    config: ConfigStore;
+    dependencies: MutableAppDependencies;
+}
+import type { HttpKernel } from "./httpKernel";
+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;
+    tableName?: string;
+    cacheTags?: readonly string[];
+    cacheDeleteExtraTags?: readonly string[];
+    providers?: ServiceProvider[];
+    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, };

package/dist/bootstrap/httpKernel.d.ts

@@ -0,0 +1,26 @@
+import type { Policy } from "../core/auth/policy";
+import { type Middleware, type RouteHandler } from "../core/http/middleware";
+import type { AppDependencies } from "./contracts";
+type MiddlewareGroupName = "api" | "authenticated" | "web";
+declare class HttpKernel {
+    private readonly dependencies;
+    constructor(dependencies: AppDependencies);
+    globalMiddleware(): Middleware[];
+    group(name: MiddlewareGroupName): Middleware[];
+    wrap(groups: MiddlewareGroupName | MiddlewareGroupName[], handler: RouteHandler): RouteHandler;
+    wrapApi(handler: RouteHandler): RouteHandler;
+    wrapWeb(handler: RouteHandler): RouteHandler;
+    wrapWebPublicRead(handler: RouteHandler): RouteHandler;
+    wrapWebAuthenticated(handler: RouteHandler): RouteHandler;
+    wrapWebAbility(ability: string, handler: RouteHandler): RouteHandler;
+    wrapWebGlobalAdmin(handler: RouteHandler): RouteHandler;
+    wrapAuthenticated(handler: RouteHandler): RouteHandler;
+    wrapPublicRead(handler: RouteHandler): RouteHandler;
+    wrapGlobalAdmin(handler: RouteHandler): RouteHandler;
+    wrapAbility(ability: string, handler: RouteHandler): RouteHandler;
+    wrapPolicy(resource: string, action: keyof Policy, handler: RouteHandler): RouteHandler;
+    wrapLogin(handler: RouteHandler): RouteHandler;
+}
+declare function createHttpKernel(dependencies: AppDependencies): HttpKernel;
+export type { MiddlewareGroupName };
+export { createHttpKernel, HttpKernel };

package/dist/config/app.d.ts

@@ -0,0 +1,10 @@
+interface AppConfig {
+    name: string;
+    env: string;
+    debug: boolean;
+    url: string;
+    apiPrefix: string;
+}
+declare const appConfig: AppConfig;
+export type { AppConfig };
+export { appConfig };

package/dist/config/contentSecurityPolicy.d.ts

@@ -0,0 +1,5 @@
+declare function strictApiContentSecurityPolicy(): string;
+declare function serverHtmxContentSecurityPolicy(): string;
+declare function spaContentSecurityPolicy(): string;
+declare function resolveContentSecurityPolicy(response: Response): string;
+export { resolveContentSecurityPolicy, serverHtmxContentSecurityPolicy, spaContentSecurityPolicy, strictApiContentSecurityPolicy, };

package/dist/config/cors.d.ts

@@ -0,0 +1,9 @@
+interface CorsConfig {
+    allowedOrigins: string[];
+    allowedMethods: string[];
+    allowedHeaders: string[];
+    maxAgeSeconds: number;
+}
+declare const corsConfig: CorsConfig;
+export type { CorsConfig };
+export { corsConfig };

package/dist/config/database.d.ts

@@ -0,0 +1,10 @@
+interface DatabaseConfig {
+    url: string;
+    poolMax: number;
+    idleTimeoutSeconds: number;
+    maxLifetimeSeconds: number;
+    connectionTimeoutSeconds: number;
+}
+declare const databaseConfig: DatabaseConfig;
+export type { DatabaseConfig };
+export { databaseConfig };

package/dist/config/features.d.ts

@@ -0,0 +1,18 @@
+interface FeatureFlags {
+    webhooks: boolean;
+    fullTextSearch: boolean;
+    auditLog: boolean;
+    oauthLogin: boolean;
+    samlLogin: boolean;
+    scim: boolean;
+    billing: boolean;
+    siemExport: boolean;
+    publicReads: boolean;
+    emailVerification: boolean;
+    mfa: boolean;
+}
+declare function readFeatureFlags(): FeatureFlags;
+declare const featureFlags: FeatureFlags;
+declare function isFeatureEnabled(feature: keyof FeatureFlags): boolean;
+export type { FeatureFlags };
+export { featureFlags, isFeatureEnabled, readFeatureFlags };

package/dist/config/frontend.d.ts

@@ -0,0 +1,6 @@
+type FrontendMode = "api" | "server-htmx" | "spa-react";
+declare function readFrontendMode(): FrontendMode;
+declare function isViewsEnabled(): boolean;
+declare function isSpaEnabled(): boolean;
+export type { FrontendMode };
+export { isSpaEnabled, isViewsEnabled, readFrontendMode };

package/dist/config/rateLimit.d.ts

@@ -0,0 +1,9 @@
+interface LoginRateLimitConfig {
+    maxAttempts: number;
+    decaySeconds: number;
+}
+declare const LOCAL_LOGIN_RATE_LIMIT: LoginRateLimitConfig;
+declare const PRODUCTION_LOGIN_RATE_LIMIT: LoginRateLimitConfig;
+declare function resolveLoginRateLimit(): LoginRateLimitConfig;
+export type { LoginRateLimitConfig };
+export { LOCAL_LOGIN_RATE_LIMIT, PRODUCTION_LOGIN_RATE_LIMIT, resolveLoginRateLimit };

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/accessControl.d.ts

@@ -0,0 +1,8 @@
+import type { OrganizationMemberRole } from "../../modules/organization/memberTypes";
+import { type AuthUser } from "./authContext";
+declare const ROLE_RANK: Record<OrganizationMemberRole, number>;
+declare function isGlobalAdmin(user: AuthUser | null): boolean;
+declare function hasMinimumOrgRole(role: OrganizationMemberRole | null | undefined, minimum: OrganizationMemberRole): boolean;
+declare function requireAuthenticatedUser(): AuthUser;
+declare function resolveUserId(user: AuthUser): number;
+export { hasMinimumOrgRole, isGlobalAdmin, ROLE_RANK, requireAuthenticatedUser, resolveUserId };

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

@@ -0,0 +1,12 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+type AuthUser = {
+    id: number | string;
+    role?: string;
+    abilities?: string[];
+    tokenId?: number;
+};
+declare const authContext: AsyncLocalStorage<AuthUser | null>;
+declare function runWithAuthUser<T>(user: AuthUser | null, callback: () => T | Promise<T>): T | Promise<T>;
+declare function currentAuthUser(): AuthUser | null;
+export type { AuthUser };
+export { authContext, currentAuthUser, runWithAuthUser };

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

@@ -0,0 +1,36 @@
+import type { ServiceContainer } from "../../bootstrap/contracts";
+import type { AuthUser } from "./authContext";
+interface AuthGuard {
+    resolve(request: Request): AuthUser | null | Promise<AuthUser | null>;
+}
+declare class GuestGuard implements AuthGuard {
+    resolve(request: Request): AuthUser | null;
+}
+declare class ApiTokenGuard implements AuthGuard {
+    private readonly options;
+    constructor(options: {
+        token: string;
+        user: AuthUser;
+    });
+    resolve(request: Request): AuthUser | null;
+}
+declare class DatabaseTokenGuard implements AuthGuard {
+    private readonly container;
+    constructor(container: ServiceContainer);
+    resolve(request: Request): Promise<AuthUser | null>;
+}
+declare class CompositeGuard implements AuthGuard {
+    private readonly guards;
+    constructor(guards: AuthGuard[]);
+    resolve(request: Request): Promise<AuthUser | null>;
+}
+declare class AuthManager {
+    private readonly guard;
+    constructor(guard: AuthGuard);
+    resolve(request?: Request): Promise<AuthUser | null>;
+    user(request?: Request): Promise<AuthUser | null>;
+    check(request?: Request): Promise<boolean>;
+    requireUser(request?: Request): Promise<AuthUser>;
+}
+export type { AuthGuard, AuthUser };
+export { ApiTokenGuard, AuthManager, CompositeGuard, DatabaseTokenGuard, GuestGuard };

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

@@ -0,0 +1,16 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import OrganizationMemberRepository from "../../modules/organization/memberRepository";
+import type { OrganizationMemberRole } from "../../modules/organization/memberTypes";
+type MembershipContext = {
+    organizationIds: number[];
+    rolesByOrganizationId: Map<number, OrganizationMemberRole>;
+};
+declare const membershipContext: AsyncLocalStorage<MembershipContext>;
+declare const membershipRepository: OrganizationMemberRepository;
+declare function runWithMembershipContext<T>(callback: () => T | Promise<T>): Promise<T | Promise<T>>;
+declare function currentOrgRole(organizationId: number): OrganizationMemberRole | null;
+declare function hasOrgMembership(organizationId: number): boolean;
+declare function currentOrganizationIds(): number[];
+declare function hasMinimumOrgRole(organizationId: number, minimum: OrganizationMemberRole): boolean;
+export type { MembershipContext };
+export { currentOrganizationIds, currentOrgRole, hasMinimumOrgRole, hasOrgMembership, membershipContext, membershipRepository, runWithMembershipContext, };

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

@@ -0,0 +1,3 @@
+import type { Middleware } from "../http/middleware";
+declare function createMembershipContextMiddleware(): Middleware;
+export { createMembershipContextMiddleware };

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

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

package/dist/core/auth/oauth/oidcProvider.d.ts

@@ -0,0 +1,18 @@
+import type { OAuthProfile, OAuthProvider } from "./types";
+interface OidcProviderOptions {
+    name: string;
+    issuer: string;
+    clientId: string;
+    clientSecret: string;
+    redirectUri: string;
+    scopes?: string[];
+}
+declare class OidcProvider implements OAuthProvider {
+    private readonly options;
+    readonly name: string;
+    constructor(options: OidcProviderOptions);
+    getAuthorizationUrl(state: string): string;
+    exchangeCode(code: string): Promise<OAuthProfile>;
+}
+export type { OidcProviderOptions };
+export { OidcProvider };

package/dist/core/auth/oauth/providers.d.ts

@@ -0,0 +1,22 @@
+import type { OAuthProfile, OAuthProvider } from "./types";
+interface GitHubOAuthOptions {
+    clientId: string;
+    clientSecret: string;
+    redirectUri: string;
+}
+declare class GitHubOAuthProvider implements OAuthProvider {
+    private readonly options;
+    readonly name = "github";
+    constructor(options: GitHubOAuthOptions);
+    getAuthorizationUrl(state: string): string;
+    exchangeCode(code: string): Promise<OAuthProfile>;
+}
+declare class MockOAuthProvider implements OAuthProvider {
+    private readonly profile;
+    readonly name = "mock";
+    constructor(profile: OAuthProfile);
+    getAuthorizationUrl(state: string): string;
+    exchangeCode(code: string): Promise<OAuthProfile>;
+}
+export type { GitHubOAuthOptions };
+export { GitHubOAuthProvider, MockOAuthProvider };

package/dist/core/auth/oauth/samlProvider.d.ts

@@ -0,0 +1,9 @@
+import type { OAuthProfile, OAuthProvider } from "./types";
+declare class SamlProvider implements OAuthProvider {
+    private readonly loginUrl;
+    readonly name = "saml";
+    constructor(loginUrl: string);
+    getAuthorizationUrl(state: string): string;
+    exchangeCode(code: string): Promise<OAuthProfile>;
+}
+export { SamlProvider };

package/dist/core/auth/oauth/types.d.ts

@@ -0,0 +1,11 @@
+interface OAuthProfile {
+    providerUserId: string;
+    email: string;
+    name: string;
+}
+interface OAuthProvider {
+    readonly name: string;
+    getAuthorizationUrl(state: string): string;
+    exchangeCode(code: string): Promise<OAuthProfile>;
+}
+export type { OAuthProfile, OAuthProvider };

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

@@ -0,0 +1,3 @@
+declare function hashPassword(password: string): Promise<string>;
+declare function verifyPassword(password: string, passwordHash: string): Promise<boolean>;
+export { hashPassword, verifyPassword };

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

@@ -0,0 +1,15 @@
+declare abstract class Policy {
+    constructor();
+    view(_user?: unknown, _resource?: unknown): boolean;
+    create(_user?: unknown): boolean;
+    update(_user?: unknown, _resource?: unknown): boolean;
+    delete(_user?: unknown, _resource?: unknown): boolean;
+}
+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;
+}
+export { Policy, PolicyGate };

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

@@ -0,0 +1,3 @@
+declare function resolveTokenPepper(): string;
+declare function hashApiToken(token: string): string;
+export { hashApiToken, resolveTokenPepper };

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/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/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/crypto/fieldEncryption.d.ts

@@ -0,0 +1,13 @@
+declare function resolveEncryptionKey(): Buffer | null;
+declare function isFieldEncryptionEnabled(): boolean;
+declare function encryptField(plaintext: string, key: Buffer): string;
+declare function decryptField(value: string, key: Buffer): string;
+declare function hashLookupValue(normalizedValue: string, key: Buffer): string;
+declare function normalizeEmail(email: string): string;
+declare function protectEmail(email: string): {
+    storedEmail: string;
+    emailLookup: string;
+};
+declare function revealEmail(storedEmail: string): string;
+declare function emailLookupForQuery(email: string): string;
+export { decryptField, emailLookupForQuery, encryptField, hashLookupValue, isFieldEncryptionEnabled, normalizeEmail, protectEmail, resolveEncryptionKey, revealEmail, };

package/dist/core/crypto/mfaSecret.d.ts

@@ -0,0 +1,3 @@
+declare function protectMfaSecret(secret: string): string;
+declare function revealMfaSecret(stored: string | null | undefined): string | null;
+export { protectMfaSecret, revealMfaSecret };

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

@@ -0,0 +1,47 @@
+import { 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";
+interface DatabaseConnection {
+    unsafe<T>(query: string, params?: readonly unknown[]): Promise<T[]>;
+}
+type ErrorFactory<TValue> = (value: TValue) => Error;
+declare class BaseRepository<TEntity extends object, PrimaryKey extends keyof TEntity & string> {
+    protected readonly table: TableDefinition<TEntity, PrimaryKey>;
+    protected readonly connection: DatabaseConnection;
+    constructor(table: TableDefinition<TEntity, PrimaryKey>, connection?: DatabaseConnection);
+    findAll(options?: QueryOptions<TEntity>): Promise<TEntity[]>;
+    paginate(options: {
+        page: number;
+        perPage: number;
+    } & Omit<QueryOptions<TEntity>, "limit" | "offset">): Promise<PaginatedResult<TEntity>>;
+    findById(id: TEntity[PrimaryKey]): Promise<TEntity | null>;
+    findByIdOrThrow(id: TEntity[PrimaryKey], errorFactory?: ErrorFactory<TEntity[PrimaryKey]>): Promise<TEntity>;
+    findByIds(ids: readonly TEntity[PrimaryKey][]): Promise<TEntity[]>;
+    firstOrNull(where: QueryWhere<TEntity>, options?: Omit<QueryOptions<TEntity>, "where" | "limit">): Promise<TEntity | null>;
+    create(values: MutationValues<TEntity>): Promise<TEntity>;
+    updateById(id: TEntity[PrimaryKey], changes: UpdateValues<TEntity, PrimaryKey>): Promise<TEntity | null>;
+    updateByIdOrThrow(id: TEntity[PrimaryKey], changes: UpdateValues<TEntity, PrimaryKey>, errorFactory?: ErrorFactory<TEntity[PrimaryKey]>): Promise<TEntity>;
+    deleteById(id: TEntity[PrimaryKey]): Promise<boolean>;
+    softDeleteById(id: TEntity[PrimaryKey]): Promise<boolean>;
+    forceDeleteById(id: TEntity[PrimaryKey]): Promise<boolean>;
+    restoreById(id: TEntity[PrimaryKey]): Promise<TEntity | null>;
+    withConnection(connection: DatabaseConnection): this;
+    getConnection(): DatabaseConnection;
+    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 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[]>;
+    protected countGroupedBy<K extends keyof TEntity & string>(column: K, where?: QueryWhere<TEntity>): Promise<Array<{
+        value: TEntity[K] | null;
+        count: number;
+    }>>;
+    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/connection.d.ts

@@ -0,0 +1,7 @@
+import type { DatabaseConnection } from "./baseRepository.ts";
+type UnsafeQueryable = {
+    unsafe<T>(query: string, params?: readonly unknown[]): Promise<T[]>;
+};
+declare function createDatabaseConnection(source: UnsafeQueryable): DatabaseConnection;
+export type { UnsafeQueryable };
+export { createDatabaseConnection };

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

@@ -0,0 +1,7 @@
+type ActiveDatabaseHandle = {
+    unsafe<T>(query: string, params?: readonly unknown[]): Promise<T[]>;
+};
+declare function runWithDatabaseConnection<T>(connection: ActiveDatabaseHandle, callback: () => T | Promise<T>): T | Promise<T>;
+declare function getActiveDatabaseConnection<T extends ActiveDatabaseHandle>(fallback: T): T;
+export type { ActiveDatabaseHandle };
+export { getActiveDatabaseConnection, runWithDatabaseConnection };

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

@@ -0,0 +1,12 @@
+import { HttpError } from "../errors/http";
+interface PostgresErrorLike {
+    code?: string;
+    errno?: string | number;
+    constraint?: string;
+    detail?: string;
+    message?: string;
+}
+declare function isPostgresError(error: unknown): error is PostgresErrorLike;
+declare function mapDatabaseError(error: unknown): HttpError;
+declare function withDatabaseErrorHandling<TValue>(operation: () => Promise<TValue>): Promise<TValue>;
+export { isPostgresError, mapDatabaseError, withDatabaseErrorHandling };

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

@@ -0,0 +1,12 @@
+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 { RepositoryQuery } from "./repositoryQuery.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";