@getstrata/core 0.2.0 → 0.3.0

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

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

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/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/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/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 } 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/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/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/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/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/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/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,10 @@
+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>;
+export type { RouteModelAuthorization };
+export { securedBindRouteModel };

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/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,6 @@
+declare abstract class WebFormRequest<TOutput> {
+    authorize(_request: Request): boolean | Promise<boolean>;
+    protected abstract parse(payload: unknown): TOutput;
+    validate(request: Request): Promise<TOutput>;
+}
+export { WebFormRequest };

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/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/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 };