@getstrata/bootstrap 0.1.0

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

@@ -0,0 +1,51 @@
+import type { TableDefinition } from "./table.ts";
+import type { MutationValues, QueryOptions, QueryWhere, UpdateValues } from "./types.ts";
+declare function quoteIdentifier(identifier: string): string;
+declare function qualifyColumn(tableName: string, column: string): string;
+declare function buildWhereClause<TEntity>(tableName: string, where?: QueryWhere<TEntity>): {
+    clause: string;
+    params: unknown[];
+};
+declare function resolveSoftDeleteColumn<TEntity>(table: TableDefinition<TEntity>): string | null;
+declare function buildQueryWhereClause<TEntity>(table: TableDefinition<TEntity>, options?: Pick<QueryOptions<TEntity>, "where" | "withTrashed" | "onlyTrashed">): {
+    clause: string;
+    params: unknown[];
+};
+declare function buildOrderByClause<TEntity>(tableName: string, orderBy?: QueryOptions<TEntity>["orderBy"]): string;
+declare function buildSelectQuery<TEntity>(table: TableDefinition<TEntity>, options?: QueryOptions<TEntity>): {
+    text: string;
+    params: unknown[];
+};
+declare function buildCountQuery<TEntity>(table: TableDefinition<TEntity>, where?: QueryWhere<TEntity>, options?: Pick<QueryOptions<TEntity>, "withTrashed" | "onlyTrashed">): {
+    text: string;
+    params: unknown[];
+};
+declare function buildProjectionQuery<TEntity>(table: TableDefinition<TEntity>, expression: string, alias: string, options?: QueryOptions<TEntity>): {
+    text: string;
+    params: unknown[];
+};
+declare function buildGroupedCountQuery<TEntity, K extends keyof TEntity & string>(table: TableDefinition<TEntity>, column: K, where?: QueryWhere<TEntity>, options?: Pick<QueryOptions<TEntity>, "withTrashed" | "onlyTrashed">): {
+    text: string;
+    params: unknown[];
+};
+declare function buildInsertQuery<TEntity, PrimaryKey extends keyof TEntity & string>(table: TableDefinition<TEntity, PrimaryKey>, values: MutationValues<TEntity>): {
+    text: string;
+    params: unknown[];
+};
+declare function buildUpdateQuery<TEntity, PrimaryKey extends keyof TEntity & string>(table: TableDefinition<TEntity, PrimaryKey>, id: TEntity[PrimaryKey], changes: UpdateValues<TEntity, PrimaryKey>): {
+    text: string;
+    params: unknown[];
+};
+declare function buildSoftDeleteByIdQuery<TEntity, PrimaryKey extends keyof TEntity & string>(table: TableDefinition<TEntity, PrimaryKey>, id: TEntity[PrimaryKey], deletedAt: Date): {
+    text: string;
+    params: unknown[];
+};
+declare function buildRestoreByIdQuery<TEntity, PrimaryKey extends keyof TEntity & string>(table: TableDefinition<TEntity, PrimaryKey>, id: TEntity[PrimaryKey]): {
+    text: string;
+    params: unknown[];
+};
+declare function buildDeleteByIdQuery<TEntity, PrimaryKey extends keyof TEntity & string>(table: TableDefinition<TEntity, PrimaryKey>, id: TEntity[PrimaryKey]): {
+    text: string;
+    params: unknown[];
+};
+export { buildCountQuery, buildDeleteByIdQuery, buildGroupedCountQuery, buildInsertQuery, buildOrderByClause, buildProjectionQuery, buildQueryWhereClause, buildRestoreByIdQuery, buildSelectQuery, buildSoftDeleteByIdQuery, buildUpdateQuery, buildWhereClause, qualifyColumn, quoteIdentifier, resolveSoftDeleteColumn, };

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

@@ -0,0 +1,26 @@
+interface HasManyRelation<TParent, TChild, LocalKey extends keyof TParent & string = keyof TParent & string, ForeignKey extends keyof TChild & string = keyof TChild & string> {
+    type: "hasMany";
+    name: string;
+    localKey: LocalKey;
+    foreignKey: ForeignKey;
+}
+interface BelongsToRelation<TChild, TParent, ForeignKey extends keyof TChild & string = keyof TChild & string, OwnerKey extends keyof TParent & string = keyof TParent & string> {
+    type: "belongsTo";
+    name: string;
+    foreignKey: ForeignKey;
+    ownerKey: OwnerKey;
+}
+declare function hasMany<TParent, TChild, LocalKey extends keyof TParent & string = keyof TParent & string, ForeignKey extends keyof TChild & string = keyof TChild & string>(definition: {
+    name: string;
+    localKey: LocalKey;
+    foreignKey: ForeignKey;
+}): HasManyRelation<TParent, TChild, LocalKey, ForeignKey>;
+declare function belongsTo<TChild, TParent, ForeignKey extends keyof TChild & string = keyof TChild & string, OwnerKey extends keyof TParent & string = keyof TParent & string>(definition: {
+    name: string;
+    foreignKey: ForeignKey;
+    ownerKey: OwnerKey;
+}): BelongsToRelation<TChild, TParent, ForeignKey, OwnerKey>;
+declare function indexHasManyRelation<TParent, TChild, LocalKey extends keyof TParent & string, ForeignKey extends keyof TChild & string>(parents: readonly TParent[], children: readonly TChild[], relation: HasManyRelation<TParent, TChild, LocalKey, ForeignKey>): Map<TParent[LocalKey], TChild[]>;
+declare function indexBelongsToRelation<TChild, TParent, ForeignKey extends keyof TChild & string, OwnerKey extends keyof TParent & string>(children: readonly TChild[], parents: readonly TParent[], relation: BelongsToRelation<TChild, TParent, ForeignKey, OwnerKey>): Map<TChild[ForeignKey], TParent>;
+export type { BelongsToRelation, HasManyRelation };
+export { belongsTo, hasMany, indexBelongsToRelation, indexHasManyRelation };

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

@@ -0,0 +1,13 @@
+import type { QueryOrder } from "./types.ts";
+interface TableDefinition<TEntity, PrimaryKey extends keyof TEntity & string = keyof TEntity & string> {
+    name: string;
+    primaryKey: PrimaryKey;
+    columns: readonly (keyof TEntity & string)[];
+    defaultOrderBy?: QueryOrder<TEntity> | QueryOrder<TEntity>[];
+    softDeletes?: boolean | {
+        column?: keyof TEntity & string;
+    };
+}
+declare function defineTable<TEntity, PrimaryKey extends keyof TEntity & string = keyof TEntity & string>(definition: TableDefinition<TEntity, PrimaryKey>): TableDefinition<TEntity, PrimaryKey>;
+export type { TableDefinition };
+export { defineTable };

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

@@ -0,0 +1,3 @@
+import type { DatabaseConnection } from "./baseRepository.ts";
+declare function runInTransaction<TValue>(operation: (connection: DatabaseConnection) => Promise<TValue>): Promise<TValue>;
+export { runInTransaction };

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

@@ -0,0 +1,29 @@
+type DatabaseComparable = string | number | Date;
+type DatabaseScalar = DatabaseComparable | boolean | null;
+type QueryOperator = {
+    eq?: DatabaseScalar;
+    in?: readonly DatabaseScalar[];
+    gt?: DatabaseComparable;
+    gte?: DatabaseComparable;
+    lt?: DatabaseComparable;
+    lte?: DatabaseComparable;
+    isNull?: boolean;
+};
+type QueryFilterValue = DatabaseScalar | readonly DatabaseScalar[] | QueryOperator;
+type QueryWhere<TEntity> = Partial<Record<keyof TEntity & string, QueryFilterValue>>;
+type QueryOrder<TEntity> = {
+    column: keyof TEntity & string;
+    direction?: "ASC" | "DESC" | "asc" | "desc";
+};
+type QueryOrderShorthand<TEntity> = Partial<Record<keyof TEntity & string, "ASC" | "DESC" | "asc" | "desc">>;
+interface QueryOptions<TEntity> {
+    where?: QueryWhere<TEntity>;
+    orderBy?: QueryOrder<TEntity> | QueryOrder<TEntity>[] | QueryOrderShorthand<TEntity>;
+    limit?: number;
+    offset?: number;
+    withTrashed?: boolean;
+    onlyTrashed?: boolean;
+}
+type MutationValues<TEntity> = Partial<TEntity>;
+type UpdateValues<TEntity, PrimaryKey extends keyof TEntity & string = keyof TEntity & string> = Partial<Omit<TEntity, PrimaryKey>>;
+export type { DatabaseComparable, DatabaseScalar, MutationValues, QueryFilterValue, QueryOperator, QueryOptions, QueryOrder, QueryWhere, UpdateValues, };

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

@@ -0,0 +1,33 @@
+declare class HttpError extends Error {
+    readonly status: number;
+    readonly details?: unknown;
+    constructor(status: number, message: string, details?: unknown);
+}
+declare class BadRequestError extends HttpError {
+    constructor(message?: string, details?: unknown);
+}
+declare class NotFoundError extends HttpError {
+    constructor(message?: string, details?: unknown);
+}
+declare class ConflictError extends HttpError {
+    constructor(message?: string, details?: unknown);
+}
+declare class UnprocessableEntityError extends HttpError {
+    constructor(message?: string, details?: unknown);
+}
+declare class ValidationError extends HttpError {
+    constructor(message?: string, details?: unknown);
+}
+declare class ForbiddenError extends HttpError {
+    constructor(message?: string, details?: unknown);
+}
+declare class UnauthorizedError extends HttpError {
+    constructor(message?: string, details?: unknown);
+}
+declare class PayloadTooLargeError extends HttpError {
+    constructor(message?: string, details?: unknown);
+}
+declare class PreconditionFailedError extends HttpError {
+    constructor(message?: string, details?: unknown);
+}
+export { BadRequestError, ConflictError, ForbiddenError, HttpError, NotFoundError, PayloadTooLargeError, PreconditionFailedError, UnauthorizedError, UnprocessableEntityError, ValidationError, };

package/dist/core/events/eventBus.d.ts

@@ -0,0 +1,10 @@
+type EventListener = (payload: unknown) => void | Promise<void>;
+declare class EventBus {
+    constructor();
+    private readonly listeners;
+    listen(event: string, listener: EventListener): () => void;
+    dispatch(event: string, payload: unknown): Promise<void>;
+}
+declare const eventBus: EventBus;
+export type { EventListener };
+export { EventBus, eventBus };

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

@@ -0,0 +1,4 @@
+export type { EventListener } from "./eventBus";
+export { EventBus, eventBus } from "./eventBus";
+declare function modelEventName(tableName: string, action: string): string;
+export { modelEventName };

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

@@ -0,0 +1,5 @@
+import { type AuthUser, authContext } from "../auth/authContext";
+import type { AuthManager } from "../auth/guard";
+declare function createAuthMiddleware(auth: AuthManager): (request: Request, next: () => Promise<Response>) => Promise<Response>;
+export type { AuthUser };
+export { authContext, createAuthMiddleware };

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

@@ -0,0 +1,5 @@
+import type { AuthManager } from "../auth/guard";
+import type { Policy, PolicyGate } from "../auth/policy";
+import type { Middleware } from "./middleware";
+declare function createAuthorizeMiddleware(gate: PolicyGate, auth: AuthManager, resource: string, action: keyof Policy): Middleware;
+export { createAuthorizeMiddleware };

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

@@ -0,0 +1,4 @@
+import type { Middleware } from "./middleware";
+declare function resolveMaxBodyBytes(): number;
+declare function createBodySizeLimitMiddleware(maxBytes?: number): Middleware;
+export { createBodySizeLimitMiddleware, resolveMaxBodyBytes };

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

@@ -0,0 +1,2 @@
+declare function requestPrefersJson(request?: Request): boolean;
+export { requestPrefersJson };

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

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

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

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

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

@@ -0,0 +1,14 @@
+declare const CSRF_COOKIE = "workhub_csrf";
+declare function createCsrfTokenCookie(): {
+    token: string;
+    cookie: string;
+};
+declare function resolveCsrfToken(request: Request): {
+    token: string;
+    cookie?: string;
+};
+declare function readSubmittedCsrfToken(request: Request): string | null;
+declare function readSubmittedCsrfTokenFromBody(request: Request): Promise<string | null>;
+declare function verifyCsrfToken(request: Request, submittedToken: string | null): boolean;
+declare function resolveCsrfTokenForRequest(request: Request): string;
+export { CSRF_COOKIE, createCsrfTokenCookie, readSubmittedCsrfToken, readSubmittedCsrfTokenFromBody, resolveCsrfToken, resolveCsrfTokenForRequest, verifyCsrfToken, };

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

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

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

@@ -0,0 +1,12 @@
+type FlashLevel = "success" | "error" | "info";
+interface FlashMessage {
+    level: FlashLevel;
+    message: string;
+}
+declare function createFlashCookie(message: FlashMessage): string;
+declare function clearFlashCookie(): string;
+declare function pullFlash(request: Request): FlashMessage | null;
+declare function flashResponse(response: Response, message: FlashMessage): Response;
+declare function withFlashClear(response: Response): Response;
+export type { FlashLevel, FlashMessage };
+export { clearFlashCookie, createFlashCookie, flashResponse, pullFlash, withFlashClear };

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

@@ -0,0 +1,11 @@
+import type { Middleware } from "./middleware";
+interface LoginThrottleOptions {
+    redisUrl: string;
+    maxAttempts: number;
+    decaySeconds: number;
+    keyPrefix?: string;
+}
+declare function resolveLoginIdentity(request: Request): string;
+declare function createLoginThrottleMiddleware(options: LoginThrottleOptions): Middleware;
+export type { LoginThrottleOptions };
+export { createLoginThrottleMiddleware, resolveLoginIdentity };

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

@@ -0,0 +1,9 @@
+import type { Middleware } from "./middleware";
+interface MemoryThrottleOptions {
+    maxAttempts: number;
+    decaySeconds: number;
+    keyPrefix?: string;
+}
+declare function createMemoryThrottleMiddleware(options: MemoryThrottleOptions): Middleware;
+export type { MemoryThrottleOptions };
+export { createMemoryThrottleMiddleware };

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

@@ -0,0 +1,4 @@
+import type { Middleware } from "./middleware";
+declare function normalizeMetricPath(pathname: string): string;
+declare function createMetricsMiddleware(): Middleware;
+export { createMetricsMiddleware, normalizeMetricPath };

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

@@ -0,0 +1,8 @@
+type Middleware = (request: Request, next: () => Promise<Response>) => Promise<Response>;
+type RouteHandler = (request: Request) => Response | Promise<Response>;
+declare function composeMiddleware(...middleware: Middleware[]): (handler: RouteHandler) => RouteHandler;
+declare function requestIdMiddleware(request: Request, next: () => Promise<Response>): Promise<Response>;
+declare function wrapRouteHandler<T>(handler: T, middleware: Middleware[]): T;
+declare function applyMiddlewareToRoutes<T extends Record<string, unknown>>(routes: T, middleware: Middleware[]): T;
+export type { Middleware, RouteHandler };
+export { applyMiddlewareToRoutes, composeMiddleware, requestIdMiddleware, wrapRouteHandler };

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

@@ -0,0 +1,16 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+type RequestMeta = {
+    ipAddress: string | null;
+    userAgent: string | null;
+    request?: Request;
+    flash?: {
+        level: string;
+        message: string;
+    } | null;
+    csrfToken?: string;
+};
+declare const requestMetaContext: AsyncLocalStorage<RequestMeta>;
+declare function runWithRequestMeta<T>(meta: RequestMeta, callback: () => T | Promise<T>): T | Promise<T>;
+declare function currentRequestMeta(): RequestMeta;
+export type { RequestMeta };
+export { currentRequestMeta, requestMetaContext, runWithRequestMeta };

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

@@ -0,0 +1,4 @@
+import type TokenService from "../../modules/user/tokenService";
+import type { Middleware } from "./middleware";
+declare function createRequireAbilityMiddleware(tokenService: TokenService): (ability: string) => Middleware;
+export { createRequireAbilityMiddleware };

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

@@ -0,0 +1,4 @@
+import type { AuthManager } from "../auth/guard";
+import type { Middleware } from "./middleware";
+declare function createRequireAuthMiddleware(auth: AuthManager): Middleware;
+export { createRequireAuthMiddleware };

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

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

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

@@ -0,0 +1,4 @@
+import type { AuthManager } from "../auth/guard";
+import type { Middleware } from "./middleware";
+declare function createRequireWebAuthMiddleware(auth: AuthManager): Middleware;
+export { createRequireWebAuthMiddleware };

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

@@ -0,0 +1,3 @@
+import { type Middleware, type RouteHandler } from "./middleware";
+declare function withMiddleware(...middleware: Middleware[]): (handler: RouteHandler) => RouteHandler;
+export { withMiddleware };

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

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

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

@@ -0,0 +1,11 @@
+import type { Middleware } from "./middleware";
+interface ThrottleOptions {
+    redisUrl: string;
+    maxAttempts: number;
+    decaySeconds: number;
+    keyPrefix?: string;
+}
+declare function resolveThrottleIdentity(request: Request): string;
+declare function createThrottleMiddleware(options: ThrottleOptions): Middleware;
+export type { ThrottleOptions };
+export { createThrottleMiddleware, resolveThrottleIdentity };

package/dist/core/logging/logger.d.ts

@@ -0,0 +1,17 @@
+type LogLevel = "debug" | "info" | "warn" | "error";
+interface LogContext {
+    requestId?: string;
+    [key: string]: unknown;
+}
+declare class Logger {
+    private readonly channel;
+    constructor(channel?: string);
+    private write;
+    debug(message: string, context?: LogContext): void;
+    info(message: string, context?: LogContext): void;
+    warn(message: string, context?: LogContext): void;
+    error(message: string, context?: LogContext): void;
+}
+declare const appLogger: Logger;
+export type { LogContext, LogLevel };
+export { appLogger, Logger };

package/dist/core/logging/requestLoggingMiddleware.d.ts

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

package/dist/core/metrics/prometheus.d.ts

@@ -0,0 +1,26 @@
+interface MetricLabels {
+    method: string;
+    path: string;
+    status: string;
+}
+declare class PrometheusRegistry {
+    private readonly httpRequestsTotal;
+    private readonly httpRequestDurationMs;
+    incrementHttpRequest(labels: MetricLabels): void;
+    observeHttpDuration(labels: MetricLabels, durationMs: number): void;
+    renderMetrics(): string;
+    resetForTests(): void;
+    getHttpRequestSummary(): {
+        totalRequests: number;
+        byStatus: Record<string, number>;
+        topPaths: Array<{
+            method: string;
+            path: string;
+            count: number;
+        }>;
+    };
+    private metricKey;
+}
+declare const prometheusRegistry: PrometheusRegistry;
+export type { MetricLabels };
+export { PrometheusRegistry, prometheusRegistry };

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

@@ -0,0 +1,17 @@
+interface PaginationMeta {
+    page: number;
+    per_page: number;
+    total: number;
+    last_page: number;
+}
+interface PaginatedResult<T> {
+    data: T[];
+    meta: PaginationMeta;
+}
+declare function buildPaginationMeta(input: {
+    page: number;
+    perPage: number;
+    total: number;
+}): PaginationMeta;
+export type { PaginatedResult, PaginationMeta };
+export { buildPaginationMeta };

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

@@ -0,0 +1,19 @@
+type QueuePriority = "high" | "default" | "low";
+declare abstract class Job<TPayload extends object = object> {
+    readonly maxAttempts?: number;
+    readonly backoffMs?: number;
+    readonly priority?: QueuePriority;
+    abstract handle(payload: TPayload): Promise<void>;
+}
+interface Queue {
+    dispatch<TPayload extends object>(job: Job<TPayload>, payload: TPayload): Promise<void>;
+}
+declare class SyncQueue implements Queue {
+    dispatch<TPayload extends object>(job: Job<TPayload>, payload: TPayload): Promise<void>;
+}
+declare class AsyncQueue implements Queue {
+    dispatch<TPayload extends object>(job: Job<TPayload>, payload: TPayload): Promise<void>;
+}
+declare function createQueue(driver: "sync" | "async"): Queue;
+export type { Queue, QueuePriority };
+export { AsyncQueue, createQueue, Job, SyncQueue };

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

@@ -0,0 +1,3 @@
+declare function isPublicReadsEnabled(): boolean;
+declare function guestCanViewResource(): boolean;
+export { guestCanViewResource, isPublicReadsEnabled };

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

@@ -0,0 +1,6 @@
+interface SecurityEventDetails {
+    [key: string]: unknown;
+}
+declare function logSecurityEvent(event: string, details?: SecurityEventDetails): void;
+export type { SecurityEventDetails };
+export { logSecurityEvent };

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

@@ -0,0 +1,2 @@
+declare function resolveDefaultTokenExpiryDays(): number | null;
+export { resolveDefaultTokenExpiryDays };

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

@@ -0,0 +1,3 @@
+declare function generateTotp(secret: string, counter: number, digits?: number): string;
+declare function verifyTotp(secret: string, token: string, window?: number): boolean;
+export { generateTotp, verifyTotp };

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

@@ -0,0 +1,2 @@
+declare function runWithMigrationBypass<T>(callback: () => T | Promise<T>): Promise<T>;
+export { runWithMigrationBypass };

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

@@ -0,0 +1,3 @@
+import type { TenantContext } from "./tenantContext";
+declare function resolveTenant(tenantId: number): Promise<TenantContext | null>;
+export { resolveTenant };

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

@@ -0,0 +1,14 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+type TenantContext = {
+    id: number;
+    slug: string;
+    plan: "free" | "pro" | "enterprise";
+    region: "eu" | "us" | "apac";
+};
+declare const tenantContext: AsyncLocalStorage<TenantContext>;
+declare function runWithTenant<T>(tenant: TenantContext, callback: () => T | Promise<T>): T | Promise<T>;
+declare function currentTenant(): TenantContext | null;
+declare function currentTenantId(): number;
+declare function rateLimitMultiplierForPlan(plan: TenantContext["plan"]): number;
+export type { TenantContext };
+export { currentTenant, currentTenantId, rateLimitMultiplierForPlan, runWithTenant, tenantContext };

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

@@ -0,0 +1,7 @@
+import { type TenantContext } from "./tenantContext";
+type TransactionHandle = {
+    unsafe(query: string, params?: readonly unknown[]): Promise<unknown[]>;
+};
+declare function applyTenantContextToTransaction(transaction: TransactionHandle, tenantId: number): Promise<void>;
+declare function runWithTenantDatabase<T>(tenant: TenantContext, callback: () => T | Promise<T>): Promise<T>;
+export { applyTenantContextToTransaction, runWithTenantDatabase };

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

@@ -0,0 +1,6 @@
+import type { TenantContext } from "./tenantContext";
+declare const DEFAULT_TENANT: TenantContext;
+declare function resolveUserTenantId(userId: number): Promise<number>;
+declare function auditChecksum(payload: Record<string, unknown>): string;
+declare function createTenantMiddleware(): (request: Request, next: () => Promise<Response>) => Promise<Response>;
+export { auditChecksum, createTenantMiddleware, DEFAULT_TENANT, resolveUserTenantId };

package/dist/core/tracing/otel.d.ts

@@ -0,0 +1,26 @@
+interface OtelSpan {
+    traceId: string;
+    spanId: string;
+    name: string;
+    startTimeUnixNano: string;
+    endTimeUnixNano: string;
+    attributes: Array<{
+        key: string;
+        value: {
+            stringValue: string;
+        };
+    }>;
+    status: {
+        code: number;
+    };
+}
+declare function createSpan(input: {
+    traceId: string;
+    name: string;
+    startedAt: number;
+    endedAt: number;
+    attributes?: Record<string, string>;
+}): OtelSpan;
+declare function exportOtelSpan(span: OtelSpan): Promise<void>;
+export type { OtelSpan };
+export { createSpan, exportOtelSpan };

package/dist/core/tracing/traceContext.d.ts

@@ -0,0 +1,10 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+type TraceContext = {
+    traceId: string;
+    spanId: string;
+};
+declare const traceContextStorage: AsyncLocalStorage<TraceContext>;
+declare function runWithTraceContext<T>(context: TraceContext, callback: () => T | Promise<T>): T | Promise<T>;
+declare function currentTraceId(): string | null;
+export type { TraceContext };
+export { currentTraceId, runWithTraceContext, traceContextStorage };

package/dist/core/tracing/tracingMiddleware.d.ts

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

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

@@ -0,0 +1,6 @@
+import { SQL } from "bun";
+import type { DatabaseConfig } from "../../config/database";
+type DatabaseConnection = InstanceType<typeof SQL>;
+declare function createDatabaseConnection(config: DatabaseConfig): DatabaseConnection;
+export type { DatabaseConnection };
+export { createDatabaseConnection };

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

@@ -0,0 +1,11 @@
+import { type DatabaseConnection } from "./createConnection";
+declare function getDatabase(): DatabaseConnection;
+declare function pingDatabase(connection?: DatabaseConnection): Promise<boolean>;
+declare function ensureDatabaseConnection(): Promise<DatabaseConnection>;
+declare function closeDatabase(): Promise<void>;
+declare function replaceDatabaseConnectionForTests(connection?: DatabaseConnection): Promise<void>;
+declare function resetDatabaseConnectionForTests(connection: DatabaseConnection): void;
+declare const db: Bun.SQL;
+export default db;
+export type { DatabaseConnection };
+export { closeDatabase, ensureDatabaseConnection, getDatabase, pingDatabase, replaceDatabaseConnectionForTests, resetDatabaseConnectionForTests, };

package/dist/domain/abilities.d.ts

@@ -0,0 +1,5 @@
+declare const MEMBER_ABILITIES: readonly ["organizations:read", "projects:read", "projects:create", "tasks:read", "tasks:create", "comments:read", "comments:create", "attachments:read", "attachments:create", "auth:tokens:read", "auth:tokens:write"];
+declare const ADMIN_ABILITIES: readonly ["organizations:read", "projects:read", "projects:create", "tasks:read", "tasks:create", "comments:read", "comments:create", "attachments:read", "attachments:create", "auth:tokens:read", "auth:tokens:write", "organizations:create", "organizations:update", "organizations:delete", "projects:update", "projects:delete", "tasks:update", "tasks:delete", "comments:update", "comments:delete", "attachments:delete", "webhooks:read", "webhooks:write", "audit:read"];
+declare const PLATFORM_ADMIN_ABILITIES: readonly ["*"];
+declare function resolveAbilitiesForRole(role: string | null | undefined): string[];
+export { ADMIN_ABILITIES, MEMBER_ABILITIES, PLATFORM_ADMIN_ABILITIES, resolveAbilitiesForRole };

package/dist/domain/auth.d.ts

@@ -0,0 +1,4 @@
+export declare const TEST_ADMIN_API_TOKEN = "workhub-admin-test-token";
+export declare const TEST_MEMBER_API_TOKEN = "workhub-member-test-token";
+export declare const USER_ROLES: readonly ["admin", "member"];
+export type UserRole = (typeof USER_ROLES)[number];