@getstrata/bootstrap 0.1.1 → 0.2.1

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

@@ -4,23 +4,53 @@ interface HasManyRelation<TParent, TChild, LocalKey extends keyof TParent & stri
     localKey: LocalKey;
     foreignKey: ForeignKey;
 }
+interface HasOneRelation<TParent, TChild, LocalKey extends keyof TParent & string = keyof TParent & string, ForeignKey extends keyof TChild & string = keyof TChild & string> {
+    type: "hasOne";
+    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;
 }
+interface BelongsToManyRelation<TParent, TRelated, Pivot extends object, ParentKey extends keyof TParent & string = keyof TParent & string, RelatedKey extends keyof TRelated & string = keyof TRelated & string, ForeignPivotKey extends keyof Pivot & string = keyof Pivot & string, RelatedPivotKey extends keyof Pivot & string = keyof Pivot & string> {
+    type: "belongsToMany";
+    name: string;
+    pivotTable: string;
+    parentKey: ParentKey;
+    relatedKey: RelatedKey;
+    foreignPivotKey: ForeignPivotKey;
+    relatedPivotKey: RelatedPivotKey;
+}
 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 hasOne<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;
+}): HasOneRelation<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 belongsToMany<TParent, TRelated, Pivot extends object, ParentKey extends keyof TParent & string = keyof TParent & string, RelatedKey extends keyof TRelated & string = keyof TRelated & string, ForeignPivotKey extends keyof Pivot & string = keyof Pivot & string, RelatedPivotKey extends keyof Pivot & string = keyof Pivot & string>(definition: {
+    name: string;
+    pivotTable: string;
+    parentKey: ParentKey;
+    relatedKey: RelatedKey;
+    foreignPivotKey: ForeignPivotKey;
+    relatedPivotKey: RelatedPivotKey;
+}): BelongsToManyRelation<TParent, TRelated, Pivot, ParentKey, RelatedKey, ForeignPivotKey, RelatedPivotKey>;
 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 indexHasOneRelation<TParent, TChild, LocalKey extends keyof TParent & string, ForeignKey extends keyof TChild & string>(parents: readonly TParent[], children: readonly TChild[], relation: HasOneRelation<TParent, TChild, LocalKey, ForeignKey>): Map<TParent[LocalKey], TChild | undefined>;
 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 };
+declare function indexBelongsToManyRelation<TParent, TRelated, Pivot extends object, ParentKey extends keyof TParent & string, RelatedKey extends keyof TRelated & string, ForeignPivotKey extends keyof Pivot & string, RelatedPivotKey extends keyof Pivot & string>(parents: readonly TParent[], pivotRows: readonly Pivot[], relatedRows: readonly TRelated[], relation: BelongsToManyRelation<TParent, TRelated, Pivot, ParentKey, RelatedKey, ForeignPivotKey, RelatedPivotKey>): Map<TParent[ParentKey], TRelated[]>;
+export type { BelongsToManyRelation, BelongsToRelation, HasManyRelation, HasOneRelation };
+export { belongsTo, belongsToMany, hasMany, hasOne, indexBelongsToManyRelation, indexBelongsToRelation, indexHasManyRelation, indexHasOneRelation, };

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

@@ -1,20 +1,35 @@
+import type { PaginatedResult } from "../pagination/index.ts";
 import type BaseRepository from "./baseRepository.ts";
 import type { BelongsToRelation, HasManyRelation } from "./relationships.ts";
 import type { QueryOptions, QueryWhere } from "./types.ts";
+import { WhereBuilder } from "./whereBuilder.ts";
 type LoadedRow = Record<string, unknown>;
 declare class RepositoryQuery<TEntity extends object, PrimaryKey extends keyof TEntity & string> {
     private readonly repository;
     private whereClause;
     private queryOptions;
     private readonly eagerLoads;
+    private readonly whereNodes;
     constructor(repository: BaseRepository<TEntity, PrimaryKey>, whereClause?: QueryWhere<TEntity>, queryOptions?: Omit<QueryOptions<TEntity>, "where">);
-    where(where: QueryWhere<TEntity>): this;
+    where(input: QueryWhere<TEntity> | ((builder: WhereBuilder<TEntity>) => void)): this;
+    orWhere(input: QueryWhere<TEntity> | ((builder: WhereBuilder<TEntity>) => void)): this;
     orderBy(orderBy: QueryOptions<TEntity>["orderBy"]): this;
     limit(limit: number): this;
+    offset(offset: number): this;
+    join(left: `${string}.${string}`, right: `${string}.${string}`): this;
+    leftJoin(left: `${string}.${string}`, right: `${string}.${string}`): this;
+    groupBy(groupBy: QueryOptions<TEntity>["groupBy"]): this;
+    having(having: QueryWhere<TEntity>): this;
     withHasMany<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">): this;
     withBelongsTo<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">): this;
     get(): Promise<Array<TEntity & LoadedRow>>;
     first(): Promise<(TEntity & LoadedRow) | null>;
+    paginate(options: {
+        page: number;
+        perPage: number;
+    }): Promise<PaginatedResult<TEntity>>;
+    private buildOptions;
+    private addJoin;
     private attach;
 }
 export { RepositoryQuery };

package/dist/core/database/schema/blueprint.d.ts

@@ -0,0 +1,47 @@
+import { ColumnDefinition, ForeignIdColumnDefinition } from "./columnDefinition.ts";
+type IndexKind = "index" | "unique" | "partial" | "uniquePartial" | "fullText" | "gin";
+interface IndexDefinition {
+    name?: string;
+    columns: string[];
+    kind: IndexKind;
+    where?: string;
+    order?: "asc" | "desc";
+}
+type BlueprintAction = "create" | "alter" | "drop";
+declare class Blueprint {
+    readonly table: string;
+    readonly action: BlueprintAction;
+    readonly columns: ColumnDefinition[];
+    readonly indexes: IndexDefinition[];
+    readonly droppedColumns: string[];
+    readonly droppedIndexes: string[];
+    constructor(table: string, action: BlueprintAction);
+    id(name?: string): ColumnDefinition;
+    string(name: string, length?: number): ColumnDefinition;
+    text(name: string): ColumnDefinition;
+    boolean(name: string): ColumnDefinition;
+    integer(name: string): ColumnDefinition;
+    bigInteger(name: string): ColumnDefinition;
+    timestamp(name: string): ColumnDefinition;
+    json(name: string): ColumnDefinition;
+    jsonb(name: string): ColumnDefinition;
+    foreignId(name: string): ForeignIdColumnDefinition;
+    timestamps(): void;
+    softDeletes(): void;
+    dropColumn(name: string): void;
+    dropSoftDeletes(): void;
+    dropIndex(name: string): void;
+    unique(columns: string | string[], name?: string): void;
+    index(columns: string | string[], options?: {
+        name?: string;
+        order?: "asc" | "desc";
+    }): void;
+    partialIndex(columns: string | string[], where: string, nameOrOptions?: string | {
+        name?: string;
+        unique?: boolean;
+    }): void;
+    fullText(columns: string | string[], name?: string): void;
+    ginIndex(column: string, name?: string): void;
+}
+export type { BlueprintAction, IndexDefinition, IndexKind };
+export { Blueprint };

package/dist/core/database/schema/columnDefinition.d.ts

@@ -0,0 +1,36 @@
+type ColumnKind = "id" | "string" | "text" | "boolean" | "integer" | "bigInteger" | "timestamp" | "json" | "jsonb" | "foreignId";
+interface ForeignKeyOptions {
+    referencesTable: string;
+    referencesColumn: string;
+    onDelete?: "cascade" | "set null" | "restrict";
+}
+declare class ColumnDefinition {
+    readonly name: string;
+    kind: ColumnKind;
+    length?: number;
+    isNullable: boolean;
+    isPrimary: boolean;
+    isUnique: boolean;
+    autoIncrement: boolean;
+    defaultValue?: string;
+    checkExpression?: string;
+    foreignKey?: ForeignKeyOptions;
+    constructor(name: string, kind: ColumnKind);
+    nullable(): this;
+    notNullable(): this;
+    default(value: string | number | boolean): this;
+    defaultRaw(expression: string): this;
+    unique(): this;
+    primary(): this;
+    check(expression: string): this;
+}
+declare class ForeignIdColumnDefinition extends ColumnDefinition {
+    constructor(name: string);
+    references(table: string, column?: string): this;
+    constrained(table?: string): this;
+    cascadeOnDelete(): this;
+    nullOnDelete(): this;
+}
+declare function inferReferencedTable(columnName: string): string;
+export type { ColumnKind, ForeignKeyOptions };
+export { ColumnDefinition, ForeignIdColumnDefinition, inferReferencedTable };

package/dist/core/database/schema/driver.d.ts

@@ -0,0 +1,8 @@
+type DatabaseDriver = "pgsql" | "mysql" | "sqlite";
+interface ResolveDatabaseDriverOptions {
+    url?: string;
+    connection?: string;
+}
+declare function resolveDatabaseDriver(options?: ResolveDatabaseDriverOptions): DatabaseDriver;
+export type { DatabaseDriver, ResolveDatabaseDriverOptions };
+export { resolveDatabaseDriver };

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

@@ -0,0 +1,4 @@
+declare class UnsupportedSchemaFeatureError extends Error {
+    constructor(feature: string, driver: string);
+}
+export { UnsupportedSchemaFeatureError };

package/dist/core/database/schema/grammars/compileStatements.d.ts

@@ -0,0 +1,8 @@
+import type { Blueprint, IndexDefinition } from "../blueprint.ts";
+import type { ColumnDefinition } from "../columnDefinition.ts";
+import type { DatabaseDriver } from "../driver.ts";
+declare function compileDropTable(driver: DatabaseDriver, tableName: string): string[];
+declare function compileColumn(driver: DatabaseDriver, column: ColumnDefinition, mode: "create" | "alter"): string;
+declare function compileIndex(_driver: DatabaseDriver, tableName: string, index: IndexDefinition): string;
+declare function compileBlueprint(driver: DatabaseDriver, blueprint: Blueprint): string[];
+export { compileBlueprint, compileColumn, compileDropTable, compileIndex };

package/dist/core/database/schema/grammars/createGrammar.d.ts

@@ -0,0 +1,4 @@
+import type { DatabaseDriver } from "../driver.ts";
+import type { Grammar } from "./grammar.ts";
+declare function createGrammar(driver: DatabaseDriver): Grammar;
+export { createGrammar };

package/dist/core/database/schema/grammars/grammar.d.ts

@@ -0,0 +1,10 @@
+import type { Blueprint } from "../blueprint.ts";
+import type { ColumnDefinition } from "../columnDefinition.ts";
+import type { DatabaseDriver } from "../driver.ts";
+interface Grammar {
+    readonly driver: DatabaseDriver;
+    compile(blueprint: Blueprint): string[];
+}
+declare function compileColumnType(driver: DatabaseDriver, column: ColumnDefinition): string;
+export type { Grammar };
+export { compileColumnType };

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

@@ -0,0 +1,7 @@
+import type { DatabaseDriver } from "../driver.ts";
+import type { Grammar } from "./grammar.ts";
+import { MySqlGrammar } from "./mysqlGrammar.ts";
+import { PostgresGrammar } from "./postgresGrammar.ts";
+import { SqliteGrammar } from "./sqliteGrammar.ts";
+declare function grammarForDriver(driver: DatabaseDriver): Grammar;
+export { grammarForDriver, MySqlGrammar, PostgresGrammar, SqliteGrammar };

package/dist/core/database/schema/grammars/mysqlGrammar.d.ts

@@ -0,0 +1,2 @@
+declare const MySqlGrammar: import("./grammar.ts").Grammar;
+export { MySqlGrammar };

package/dist/core/database/schema/grammars/postgresGrammar.d.ts

@@ -0,0 +1,2 @@
+declare const PostgresGrammar: import("./grammar.ts").Grammar;
+export { PostgresGrammar };

package/dist/core/database/schema/grammars/sqliteGrammar.d.ts

@@ -0,0 +1,2 @@
+declare const SqliteGrammar: import("./grammar.ts").Grammar;
+export { SqliteGrammar };

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

@@ -0,0 +1,12 @@
+export type { BlueprintAction, IndexDefinition, IndexKind } from "./blueprint.ts";
+export { Blueprint } from "./blueprint.ts";
+export type { ColumnKind, ForeignKeyOptions } from "./columnDefinition.ts";
+export { ColumnDefinition, ForeignIdColumnDefinition, inferReferencedTable, } from "./columnDefinition.ts";
+export type { DatabaseDriver, ResolveDatabaseDriverOptions } from "./driver.ts";
+export { resolveDatabaseDriver } from "./driver.ts";
+export { UnsupportedSchemaFeatureError } from "./errors.ts";
+export { compileBlueprint } from "./grammars/compileStatements.ts";
+export type { Grammar } from "./grammars/grammar.ts";
+export { grammarForDriver, MySqlGrammar, PostgresGrammar, SqliteGrammar, } from "./grammars/index.ts";
+export type { BlueprintCallback } from "./schema.ts";
+export { createSchemaBuilder, Schema, SchemaBuilder } from "./schema.ts";

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

@@ -0,0 +1,21 @@
+import type { MigrationDatabase } from "../migrations/types.ts";
+import { Blueprint } from "./blueprint.ts";
+import type { DatabaseDriver } from "./driver.ts";
+import { resolveDatabaseDriver } from "./driver.ts";
+type BlueprintCallback = (table: Blueprint) => void;
+declare class SchemaBuilder {
+    #private;
+    constructor(driver: DatabaseDriver);
+    create(table: string, callback: BlueprintCallback): this;
+    table(table: string, callback: BlueprintCallback): this;
+    drop(table: string): this;
+    toSql(): string[];
+    execute(db: MigrationDatabase): Promise<void>;
+}
+declare class Schema {
+    static builder(driver?: DatabaseDriver): SchemaBuilder;
+    static run(db: MigrationDatabase, driver: DatabaseDriver, callback: (schema: SchemaBuilder) => void | Promise<void>): Promise<void>;
+}
+declare function createSchemaBuilder(db: MigrationDatabase, driver?: DatabaseDriver): SchemaBuilder;
+export type { BlueprintCallback };
+export { createSchemaBuilder, resolveDatabaseDriver, Schema, SchemaBuilder };

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

@@ -8,14 +8,47 @@ type QueryOperator = {
     lt?: DatabaseComparable;
     lte?: DatabaseComparable;
     isNull?: boolean;
+    ilike?: string;
+    tsMatch?: string;
 };
 type QueryFilterValue = DatabaseScalar | readonly DatabaseScalar[] | QueryOperator;
-type QueryWhere<TEntity> = Partial<Record<keyof TEntity & string, QueryFilterValue>>;
+type QueryWhere<TEntity> = Partial<Record<keyof TEntity & string, QueryFilterValue>> & Partial<Record<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">>;
+type QueryJoinOn = {
+    left: {
+        table: string;
+        column: string;
+    };
+    right: {
+        table: string;
+        column: string;
+    };
+};
+type QueryJoin = {
+    type: "inner" | "left";
+    table: string;
+    on: QueryJoinOn[];
+};
+type QuerySelectItem = {
+    kind: "column";
+    table: string;
+    column: string;
+    as?: string;
+} | {
+    kind: "literalText";
+    value: string;
+    as: string;
+} | {
+    kind: "tsRank";
+    table: string;
+    column: string;
+    query: string;
+    as: string;
+};
 interface QueryOptions<TEntity> {
     where?: QueryWhere<TEntity>;
     orderBy?: QueryOrder<TEntity> | QueryOrder<TEntity>[] | QueryOrderShorthand<TEntity>;
@@ -23,7 +56,11 @@ interface QueryOptions<TEntity> {
     offset?: number;
     withTrashed?: boolean;
     onlyTrashed?: boolean;
+    joins?: QueryJoin[];
+    groupBy?: string | string[];
+    having?: QueryWhere<TEntity>;
+    select?: QuerySelectItem[];
 }
 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, };
+export type { DatabaseComparable, DatabaseScalar, MutationValues, QueryFilterValue, QueryJoin, QueryJoinOn, QueryOperator, QueryOptions, QueryOrder, QuerySelectItem, QueryWhere, UpdateValues, };

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

@@ -0,0 +1,17 @@
+import type { QueryWhere } from "./types.ts";
+type WhereNode<TEntity extends object> = {
+    kind: "and" | "or";
+    where: QueryWhere<TEntity>;
+} | {
+    kind: "and" | "or";
+    group: WhereNode<TEntity>[];
+};
+declare class WhereBuilder<TEntity extends object> {
+    readonly nodes: WhereNode<TEntity>[];
+    where(where: QueryWhere<TEntity>): this;
+    orWhere(where: QueryWhere<TEntity>): this;
+    whereGroup(fn: (builder: WhereBuilder<TEntity>) => void): this;
+    orWhereGroup(fn: (builder: WhereBuilder<TEntity>) => void): this;
+}
+export type { WhereNode };
+export { WhereBuilder };

package/dist/core/jobs/dispatchWebhookJob.d.ts

@@ -0,0 +1,14 @@
+import { Job } from "../queue";
+interface DispatchWebhookPayload {
+    webhookId: number;
+    event: string;
+    payload: Record<string, unknown>;
+}
+declare class DispatchWebhookJob extends Job<DispatchWebhookPayload> {
+    constructor();
+    readonly maxAttempts = 3;
+    readonly backoffMs = 2000;
+    handle(payload: DispatchWebhookPayload): Promise<void>;
+}
+export default DispatchWebhookJob;
+export type { DispatchWebhookPayload };

package/dist/core/jobs/invalidateCacheTagsJob.d.ts

@@ -0,0 +1,12 @@
+import type { CacheLike } from "../../types/services";
+import { Job } from "../queue";
+interface InvalidateCacheTagsPayload {
+    tags: string[];
+}
+declare class InvalidateCacheTagsJob extends Job<InvalidateCacheTagsPayload> {
+    private readonly cache;
+    constructor(cache: CacheLike);
+    handle(payload: InvalidateCacheTagsPayload): Promise<void>;
+}
+export default InvalidateCacheTagsJob;
+export type { InvalidateCacheTagsPayload };

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

@@ -8,10 +8,20 @@ interface PaginatedResult<T> {
     data: T[];
     meta: PaginationMeta;
 }
+interface CursorPaginationMeta<Cursor = unknown> {
+    per_page: number;
+    next_cursor: Cursor | null;
+    prev_cursor: Cursor | null;
+    has_more: boolean;
+}
+interface CursorPaginatedResult<T, Cursor = unknown> {
+    data: T[];
+    meta: CursorPaginationMeta<Cursor>;
+}
 declare function buildPaginationMeta(input: {
     page: number;
     perPage: number;
     total: number;
 }): PaginationMeta;
-export type { PaginatedResult, PaginationMeta };
+export type { CursorPaginatedResult, CursorPaginationMeta, PaginatedResult, PaginationMeta };
 export { buildPaginationMeta };

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

@@ -0,0 +1,6 @@
+import type { Queue } from "./index";
+import { createFailedJobService, createQueueWorker, createTrackedJob, type FailedJobService } from "./publicQueue";
+declare const FAILED_JOB_SERVICE_TOKEN = "core.failedJobs";
+declare function registerDefaultJobs(): void;
+declare function createAppQueue(driver: "sync" | "async" | "redis", redisUrl?: string, failedJobs?: FailedJobService): Queue;
+export { createAppQueue, createFailedJobService, createQueueWorker, createTrackedJob, FAILED_JOB_SERVICE_TOKEN, registerDefaultJobs, };

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

@@ -0,0 +1,6 @@
+import { BaseRepository } from "../database";
+import type { FailedJobRecord } from "./types";
+declare class FailedJobRepository extends BaseRepository<FailedJobRecord, "id"> {
+    constructor();
+}
+export default FailedJobRepository;

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

@@ -0,0 +1,15 @@
+import type FailedJobRepository from "./failedJobRepository";
+import type { FailedJobRecord } from "./types";
+declare class FailedJobService {
+    private readonly repository;
+    constructor(repository: FailedJobRepository);
+    recordFailure(input: {
+        jobName: string;
+        payload: Record<string, unknown>;
+        exception: string;
+    }): Promise<FailedJobRecord>;
+    listRecent(limit?: number): Promise<FailedJobRecord[]>;
+    retry(id: number): Promise<FailedJobRecord>;
+    flush(): Promise<number>;
+}
+export default FailedJobService;

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

@@ -0,0 +1,3 @@
+import type { FailedJobRecord } from "./types";
+declare const failedJobTable: import("../database").TableDefinition<FailedJobRecord, "id">;
+export { failedJobTable };

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

@@ -0,0 +1,14 @@
+import type { Job } from "./index";
+type JobFactory = () => Job;
+declare class JobRegistry {
+    constructor();
+    private readonly factories;
+    private readonly instances;
+    register(name: string, factory: JobFactory): void;
+    resolveName(job: Job): string | undefined;
+    track(name: string, job: Job): Job;
+    create(name: string): Job | undefined;
+    names(): string[];
+}
+declare const jobRegistry: JobRegistry;
+export { JobRegistry, jobRegistry };

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

@@ -0,0 +1,9 @@
+import type FailedJobService from "./failedJobService";
+interface QueueJobEnvelope {
+    name: string;
+    payload: Record<string, unknown>;
+    attempts?: number;
+}
+declare function runQueueJob(envelope: QueueJobEnvelope, failedJobs: FailedJobService): Promise<void>;
+export type { QueueJobEnvelope };
+export { runQueueJob };

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

@@ -0,0 +1,15 @@
+import FailedJobRepository from "./failedJobRepository.ts";
+import FailedJobService from "./failedJobService.ts";
+import type { Job, Queue } from "./index.ts";
+import { jobRegistry } from "./jobRegistry.ts";
+import { QueueWorker, RedisQueue } from "./redisQueue.ts";
+import { ResilientQueue } from "./resilientQueue.ts";
+declare function createFailedJobService(): FailedJobService;
+declare function createTrackedJob<TPayload extends object>(name: string, job: Job<TPayload>): Job<TPayload>;
+declare function createProductionQueue(driver: "sync" | "async" | "redis", options?: {
+    redisUrl?: string;
+    failedJobs?: FailedJobService;
+    registerJobs?: () => void;
+}): Queue;
+declare function createQueueWorker(redisUrl: string, failedJobs?: FailedJobService): QueueWorker;
+export { createFailedJobService, createProductionQueue, createQueueWorker, createTrackedJob, FailedJobRepository, FailedJobService, jobRegistry, QueueWorker, RedisQueue, ResilientQueue, };

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

@@ -0,0 +1,29 @@
+import type FailedJobService from "./failedJobService";
+import type { Job, Queue, QueuePriority } from "./index";
+import { type QueueJobEnvelope } from "./jobRunner";
+declare const QUEUE_LIST_KEY = "workhub:queue:default";
+declare const QUEUE_HIGH_KEY = "workhub:queue:high";
+declare const QUEUE_LOW_KEY = "workhub:queue:low";
+declare function queueKeyForPriority(priority?: QueuePriority): string;
+declare function parseQueueJobEnvelope(rawPayload: string): QueueJobEnvelope | null;
+declare class RedisQueue implements Queue {
+    private readonly client;
+    constructor(redisUrl: string);
+    dispatch<TPayload extends object>(job: Job<TPayload>, payload: TPayload): Promise<void>;
+}
+declare class QueueWorker {
+    private readonly failedJobs;
+    private readonly timeoutSeconds;
+    private running;
+    private stopping;
+    private readonly client;
+    constructor(redisUrl: string, failedJobs: FailedJobService, timeoutSeconds?: number);
+    requestStop(): void;
+    isRunning(): boolean;
+    processNext(): Promise<boolean>;
+    run(): Promise<void>;
+    close(): void;
+}
+declare function countPendingQueueJobs(redisUrl: string): Promise<number>;
+export type { QueueJobEnvelope };
+export { countPendingQueueJobs, parseQueueJobEnvelope, QUEUE_HIGH_KEY, QUEUE_LIST_KEY, QUEUE_LOW_KEY, QueueWorker, queueKeyForPriority, RedisQueue, };

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

@@ -0,0 +1,9 @@
+import type FailedJobService from "./failedJobService";
+import type { Job, Queue } from "./index";
+declare class ResilientQueue implements Queue {
+    private readonly failedJobs;
+    private readonly asyncDispatch;
+    constructor(failedJobs: FailedJobService, asyncDispatch?: boolean);
+    dispatch<TPayload extends object>(job: Job<TPayload>, payload: TPayload): Promise<void>;
+}
+export { ResilientQueue };

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

@@ -0,0 +1,8 @@
+interface FailedJobRecord {
+    id: number;
+    job_name: string;
+    payload: Record<string, unknown>;
+    exception: string;
+    failed_at: Date;
+}
+export type { FailedJobRecord };

package/dist/core/scheduler/schedule.d.ts

@@ -0,0 +1,15 @@
+type ScheduledTask = {
+    expression: string;
+    name: string;
+    run: () => void | Promise<void>;
+};
+declare class Schedule {
+    private readonly tasks;
+    command(expression: string, name: string, run: () => void | Promise<void>): this;
+    dueTasks(now?: Date): ScheduledTask[];
+    tasksList(): ScheduledTask[];
+}
+declare const appSchedule: Schedule;
+declare function runDueScheduledTasks(schedule?: Schedule, now?: Date): Promise<number>;
+export type { ScheduledTask };
+export { appSchedule, runDueScheduledTasks, Schedule };

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

@@ -0,0 +1,8 @@
+declare const DEFAULT_FETCH_TIMEOUT_MS = 10000;
+interface SafeFetchOptions {
+    timeoutMs?: number;
+    maxRedirects?: number;
+}
+declare function safeFetch(input: string, init?: RequestInit, options?: SafeFetchOptions): Promise<Response>;
+export type { SafeFetchOptions };
+export { DEFAULT_FETCH_TIMEOUT_MS, safeFetch };

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

@@ -0,0 +1,5 @@
+declare function isBlockedHostname(hostname: string): boolean;
+declare function assertSafeOutboundUrl(rawUrl: string, options?: {
+    allowHttp?: boolean;
+}): URL;
+export { assertSafeOutboundUrl, isBlockedHostname };

package/dist/core/view/etaViewEngine.d.ts

@@ -0,0 +1,15 @@
+import type { ViewEngine } from "./viewEngine";
+declare const DEFAULT_VIEWS_DIRECTORY: string;
+declare const DEFAULT_LAYOUT = "layouts/app.eta";
+interface RenderOptions {
+    layout?: string | false;
+}
+type LayoutDataResolver = () => Promise<Record<string, unknown>>;
+declare class EtaViewEngine implements ViewEngine {
+    private readonly eta;
+    private readonly resolveLayoutData?;
+    constructor(viewsDirectory?: string, resolveLayoutData?: LayoutDataResolver);
+    render(name: string, data?: Record<string, unknown>, options?: RenderOptions): Promise<string>;
+}
+export type { RenderOptions };
+export { DEFAULT_LAYOUT, DEFAULT_VIEWS_DIRECTORY, EtaViewEngine };

package/dist/core/view/htmlResponse.d.ts

@@ -0,0 +1,6 @@
+declare function htmlResponse(html: string, init?: {
+    status?: number;
+    statusText?: string;
+}): Response;
+declare function isHtmxRequest(request: Request): boolean;
+export { htmlResponse, isHtmxRequest };

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

@@ -0,0 +1,5 @@
+export { DEFAULT_VIEWS_DIRECTORY, EtaViewEngine } from "./etaViewEngine";
+export { htmlResponse, isHtmxRequest } from "./htmlResponse";
+export type { ViewEngine } from "./viewEngine";
+export type { WebLayoutAuthUser, WebLayoutData } from "./webLayoutData";
+export { resolveWebLayoutData } from "./webLayoutData";

package/dist/core/view/viewEngine.d.ts

@@ -0,0 +1,6 @@
+interface ViewEngine {
+    render(name: string, data?: Record<string, unknown>, options?: {
+        layout?: string | false;
+    }): Promise<string>;
+}
+export type { ViewEngine };

package/dist/core/view/webLayoutData.d.ts

@@ -0,0 +1,17 @@
+import type { ServiceContainer } from "../../bootstrap/contracts";
+interface WebLayoutAuthUser {
+    id: number;
+    email: string;
+    role: string;
+}
+interface WebLayoutData {
+    authUser: WebLayoutAuthUser | null;
+    csrfToken: string;
+    flash: {
+        level: string;
+        message: string;
+    } | null;
+}
+declare function resolveWebLayoutData(container: ServiceContainer, request?: Request): Promise<Record<string, unknown>>;
+export type { WebLayoutAuthUser, WebLayoutData };
+export { resolveWebLayoutData };