@elysiumjs/drizzle 0.0.0-stage → 0.1.1

package/dist/migration.d.ts

@@ -0,0 +1,120 @@
+import type { SQL } from 'drizzle-orm';
+import { Service } from '@elysiumjs/olympus';
+/**
+ * Where `migration:run` runs SQL: a transaction, or the connection outside of one. Every driver
+ * gives one through `DrizzleDriver.migrations()`.
+ * @author Axel Nana <ax.lnana@outlook.com>
+ */
+export interface MigrationDatabase {
+    /**
+     * Runs one statement, with its parameters.
+     * @param query The statement, from the `sql` template of Drizzle.
+     * @returns The rows of the statement.
+     */
+    execute<T = Record<string, unknown>>(query: SQL): Promise<T[]>;
+    /**
+     * Runs a script of several statements, without parameters, such as a migration file.
+     * @param text The script.
+     */
+    script(text: string): Promise<void>;
+}
+/**
+ * The connection `migration:run` works on, from the driver of a Drizzle connection.
+ * @author Axel Nana <ax.lnana@outlook.com>
+ */
+export interface MigrationConnection extends MigrationDatabase {
+    /**
+     * Runs a function in a transaction, committed when it resolves and rolled back when it
+     * throws.
+     * @param fn Receives the transaction.
+     */
+    transaction<T>(fn: (db: MigrationDatabase) => Promise<T>): Promise<T>;
+}
+/**
+ * A run of `migration:run`, as its hooks see it.
+ * @author Axel Nana <ax.lnana@outlook.com>
+ */
+export type MigrationRun = {
+    /** The transaction of the run. */
+    readonly db: MigrationDatabase;
+    /** The tenant the migrations run in: the schema set as `search_path`. */
+    readonly tenant: string;
+    /** The name of the connection the migrations run on. */
+    readonly connection: string;
+    /** The batch number of the migrations applied by this run. */
+    readonly batch: number;
+    /** The names of the migrations this run applies, in order. Empty when none is pending. */
+    readonly pending: readonly string[];
+    /** The names of the migrations applied so far by this run, in order. */
+    readonly applied: readonly string[];
+};
+/**
+ * One migration of a run, as the hooks see it.
+ * @author Axel Nana <ax.lnana@outlook.com>
+ */
+export type MigrationStep = {
+    /** The transaction of the run. */
+    readonly db: MigrationDatabase;
+    /** The name of the migration. */
+    readonly name: string;
+    /** The absolute path of the migration file. */
+    readonly path: string;
+    /** The run the migration is part of. */
+    readonly run: MigrationRun;
+};
+/**
+ * Runs SQL around the migrations of `migration:run`, inside its transaction and after its lock:
+ * what fails rolls the whole run back. Every method is optional.
+ * @author Axel Nana <ax.lnana@outlook.com>
+ */
+export interface MigrationHook {
+    /**
+     * Runs before the pending migrations, once the tenant schema and the migrations table exist.
+     * @param run The run.
+     */
+    before?(run: MigrationRun): Promise<void> | void;
+    /**
+     * Runs before each migration.
+     * @param step The migration about to be applied.
+     */
+    beforeEach?(step: MigrationStep): Promise<void> | void;
+    /**
+     * Runs after each migration, once it is recorded, before the next one.
+     * @param step The migration just applied.
+     */
+    afterEach?(step: MigrationStep): Promise<void> | void;
+    /**
+     * Runs after the pending migrations, also when there is none.
+     * @param run The run.
+     */
+    after?(run: MigrationRun): Promise<void> | void;
+}
+/**
+ * Migrations: the hooks that `migration:run` calls around them.
+ * @author Axel Nana <ax.lnana@outlook.com>
+ */
+export declare namespace Migration {
+    /**
+     * The tag of the migration hooks.
+     */
+    const Hooks: import("@elysiumjs/olympus").ServiceTag<MigrationHook>;
+    /**
+     * Registers a service as a migration hook. Hooks run in the order the modules register them,
+     * for every tenant: read `run.tenant` to act on some of them only.
+     * @example
+     * ```ts
+     * @Migration.hook()
+     * export class GrantsHook implements MigrationHook {
+     * 	public async after({ db, tenant }: MigrationRun) {
+     * 		await db.execute(sql`GRANT USAGE ON SCHEMA ${sql.identifier(tenant)} TO app`);
+     * 	}
+     * }
+     * ```
+     * @author Axel Nana <ax.lnana@outlook.com>
+     * @param props The service options.
+     */
+    const hook: (props?: Parameters<typeof Service.register>[0]) => (target: {
+        new (...arguments_: any[]): any;
+        prototype: Pick<any, string | number | symbol>;
+    }) => void;
+}

package/dist/migrations.d.ts

@@ -0,0 +1,45 @@
+/** A migration recorded as applied in `elysium_migrations`. */
+export type AppliedMigration = {
+    name: string;
+    appliedAt: Date;
+};
+/** The migrations to run, and the applied records to rename to their new names. */
+export type MigrationPlan = {
+    pending: string[];
+    renames: {
+        from: string;
+        to: string;
+    }[];
+};
+/**
+ * Gets the name under which a migration file is tracked. Drizzle Kit 1.0 stores each migration
+ * as `<folder>/migration.sql`, in which case the folder name identifies the migration.
+ * @author Axel Nana <ax.lnana@outlook.com>
+ * @param path The path of the migration file.
+ */
+export declare const getMigrationName: (path: string) => string;
+/**
+ * Decides which migration files to run.
+ *
+ * `drizzle-kit up` moves each flat `<prefix>_<name>.sql` file into a
+ * `<timestamp>_<name>/migration.sql` folder, where the timestamp is when the migration was
+ * generated. An applied record whose flat file is gone is matched, in order, to a folder with
+ * the same `<name>` generated before the record was applied; that folder is not run again and
+ * the record is renamed. Folders generated later are new migrations and run.
+ * @author Axel Nana <ax.lnana@outlook.com>
+ * @param files The paths of the migration files.
+ * @param applied The applied migrations.
+ */
+export declare const planMigrations: (files: string[], applied: AppliedMigration[]) => MigrationPlan;
+/**
+ * Removes the `"public".` qualifier Drizzle Kit writes before identifiers, so that a migration
+ * runs in the schema selected by the `search_path` (the tenant schema).
+ *
+ * Only identifier qualifiers are changed: string literals, dollar-quoted bodies (functions, `DO`
+ * blocks), comments and other quoted identifiers are kept as is. Qualifiers inside a `DO` block
+ * are therefore kept: such blocks are not rewritten, since their contents are not parsed here.
+ * @author Axel Nana <ax.lnana@outlook.com>
+ * @param sql The migration SQL.
+ * @returns The SQL without the public schema qualifiers.
+ */
+export declare const stripPublicSchema: (sql: string) => string;

package/dist/model.d.ts

@@ -0,0 +1,62 @@
+import type { ModelAdapter } from '@elysiumjs/olympus/mnemosyne';
+import type { PgTable, PgTableWithColumns } from 'drizzle-orm/pg-core';
+/**
+ * Drizzle-specific model adapter.
+ *
+ * Bridges Drizzle's `PgTableWithColumns` to the framework's
+ * normalized model metadata.
+ *
+ * @author Axel Nana <ax.lnana@outlook.com>
+ */
+export declare const drizzleAdapter: ModelAdapter<PgTableWithColumns<any>>;
+/**
+ * Creates Elysia validation schemas from a Drizzle table.
+ *
+ * This is a convenience wrapper around `createSchemaFromModel` that
+ * automatically extracts column metadata via the `drizzleAdapter`.
+ *
+ * @author Axel Nana <ax.lnana@outlook.com>
+ * @param table The Drizzle table to generate schemas for.
+ * @param opts Schema generation options.
+ * @returns An Elysia validation schema.
+ */
+export declare const createSchemaFromDrizzle: (table: PgTableWithColumns<any>, opts?: {
+    mode?: 'create' | 'update' | 'select';
+}) => import("typebox").TObject<{}>;
+/**
+ * Options for creating a DrizzleModel.
+ */
+export interface DrizzleModelOptions {
+    /**
+     * Enable tenant schema support for this model.
+     * @default false
+     */
+    supportTenancy?: boolean;
+}
+/**
+ * Creates a model class backed by a Drizzle pgTable.
+ *
+ * @author Axel Nana <ax.lnana@outlook.com>
+ * @param table The Drizzle table (created with enhanced pgTable).
+ * @param options Model configuration options.
+ * @returns A model class with Drizzle-backed static metadata.
+ */
+export declare const DrizzleModel: <TTable extends PgTable>(table: TTable, options?: DrizzleModelOptions) => {
+    new (): {};
+    readonly $inferSelect: unknown;
+    readonly $inferInsert: unknown;
+    readonly $inferUpdate: unknown;
+    readonly table: TTable;
+    readonly tableName: string;
+    readonly columns: Record<string, import("drizzle-orm/pg-core").AnyPgColumnBuilder>;
+    readonly insertSchema: import("typebox").TObject<{}>;
+    readonly updateSchema: import("typebox").TObject<{}>;
+    readonly selectSchema: import("typebox").TObject<{}>;
+    readonly supportTenancy: boolean;
+    readonly adapter: ModelAdapter<TTable>;
+} & {
+    readonly $inferSelect: { [Key in keyof TTable["_"]["columns"] & string]: TTable["_"]["columns"][Key]["_"]["notNull"] extends true ? TTable["_"]["columns"][Key]["_"]["data"] : TTable["_"]["columns"][Key]["_"]["data"] | null; } extends infer T ? { [K in keyof T]: T[K]; } : never;
+    readonly $inferInsert: { [Key in keyof TTable["_"]["columns"] & string as import("drizzle-orm").RequiredKeyOnly<Key, TTable["_"]["columns"][Key]>]: TTable["_"]["columns"][Key]["_"]["notNull"] extends true ? TTable["_"]["columns"][Key]["_"]["data"] : TTable["_"]["columns"][Key]["_"]["data"] | null; } & { [Key in keyof TTable["_"]["columns"] & string as import("drizzle-orm").OptionalKeyOnly<Key, TTable["_"]["columns"][Key], false>]?: (TTable["_"]["columns"][Key]["_"]["notNull"] extends true ? TTable["_"]["columns"][Key]["_"]["data"] : TTable["_"]["columns"][Key]["_"]["data"] | null) | undefined; } extends infer T_1 ? { [K in keyof T_1]: T_1[K]; } : never;
+    readonly $inferUpdate: Partial<{ [Key in keyof TTable["_"]["columns"] & string as import("drizzle-orm").RequiredKeyOnly<Key, TTable["_"]["columns"][Key]>]: TTable["_"]["columns"][Key]["_"]["notNull"] extends true ? TTable["_"]["columns"][Key]["_"]["data"] : TTable["_"]["columns"][Key]["_"]["data"] | null; } & { [Key in keyof TTable["_"]["columns"] & string as import("drizzle-orm").OptionalKeyOnly<Key, TTable["_"]["columns"][Key], false>]?: (TTable["_"]["columns"][Key]["_"]["notNull"] extends true ? TTable["_"]["columns"][Key]["_"]["data"] : TTable["_"]["columns"][Key]["_"]["data"] | null) | undefined; } extends infer T_1 ? { [K in keyof T_1]: T_1[K]; } : never>;
+    readonly table: TTable;
+};

package/dist/moirai.d.ts

@@ -0,0 +1,193 @@
+import type { EventReadFilter, EventStore, IdempotencyRecord, IdempotencyStore, InboxStore, OutboxClaim, OutboxRow, OutboxStore, ProjectionStorage, StoredEventRecord } from '@elysiumjs/olympus/moirai';
+import type { BuiltPgTable } from './built-table';
+import { PgColumn, PgTable } from 'drizzle-orm/pg-core';
+/**
+ * How `moiraiTables()` builds the tables.
+ * @author Axel Nana <ax.lnana@outlook.com>
+ */
+export type MoiraiTablesOptions = {
+    /**
+     * Partitions `events` by range of `occurred_at` and `outbox` by range of `created_at`: their
+     * primary and unique keys then include that column, and `migration:generate` creates them
+     * with `PARTITION BY RANGE`. The partitions themselves are left to the app, for example in
+     * a migration hook.
+     */
+    partitioned?: boolean;
+};
+/** The columns of `idempotency_keys`. */
+declare const idempotencyKeyColumns: () => {
+    key: import("drizzle-orm/pg-core").SetIsPrimaryKey<import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>>;
+    action: import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>>;
+    requestHash: import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>>;
+    response: import("drizzle-orm/pg-core").PgJsonbBuilder;
+    createdAt: import("drizzle-orm/pg-core").SetHasDefault<import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgTimestampBuilder>>;
+};
+/** The columns of `outbox`; a partitioned table keys its rows with `created_at` too. */
+declare const outboxColumns: (partitioned: boolean) => {
+    id: import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgUUIDBuilder>;
+    kind: import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>>;
+    payload: import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgJsonbBuilder>;
+    createdAt: import("drizzle-orm/pg-core").SetHasDefault<import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgTimestampBuilder>>;
+    availableAt: import("drizzle-orm/pg-core").SetHasDefault<import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgTimestampBuilder>>;
+    attempts: import("drizzle-orm/pg-core").SetHasDefault<import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgIntegerBuilder>>;
+    lastError: import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>;
+    dispatchedAt: import("drizzle-orm/pg-core").PgTimestampBuilder;
+    deadAt: import("drizzle-orm/pg-core").PgTimestampBuilder;
+};
+/** The columns of `inbox`. */
+declare const inboxColumns: () => {
+    messageId: import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>>;
+    consumer: import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>>;
+    recordedAt: import("drizzle-orm/pg-core").SetHasDefault<import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgTimestampBuilder>>;
+};
+/** The columns of `events`; a partitioned table keys its rows with `occurred_at` too. */
+declare const eventColumns: (partitioned: boolean) => {
+    position: import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgBigSerial64Builder>;
+    transactionId: import("drizzle-orm/pg-core").SetHasDefault<import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgCustomColumnBuilder<{
+        dataType: 'custom';
+        data: string;
+        driverParam: unknown;
+    }>>>;
+    aggregateId: import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>>;
+    aggregateType: import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>>;
+    version: import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgIntegerBuilder>;
+    type: import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>>;
+    schemaVersion: import("drizzle-orm/pg-core").SetHasDefault<import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgIntegerBuilder>>;
+    data: import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgJsonbBuilder>;
+    metadata: import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgJsonbBuilder>;
+    occurredAt: import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgTimestampBuilder>;
+};
+/** The columns of `projections`. */
+declare const projectionColumns: () => {
+    name: import("drizzle-orm/pg-core").SetIsPrimaryKey<import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>>;
+    version: import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgIntegerBuilder>;
+    builtAt: import("drizzle-orm/pg-core").SetHasDefault<import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgTimestampBuilder>>;
+};
+/**
+ * The tables `moiraiTables()` builds.
+ * @author Axel Nana <ax.lnana@outlook.com>
+ */
+export type MoiraiTables = {
+    idempotencyKeys: BuiltPgTable<'idempotency_keys', undefined, ReturnType<typeof idempotencyKeyColumns>>;
+    outbox: BuiltPgTable<'outbox', undefined, ReturnType<typeof outboxColumns>>;
+    inbox: BuiltPgTable<'inbox', undefined, ReturnType<typeof inboxColumns>>;
+    events: BuiltPgTable<'events', undefined, ReturnType<typeof eventColumns>>;
+    projections: BuiltPgTable<'projections', undefined, ReturnType<typeof projectionColumns>>;
+};
+/**
+ * Builds the tables of the moirai stores: `idempotency_keys`, `outbox`, `inbox` and `events`, in a schema
+ * when one is given (one set of tables per domain schema, for example). Export them from the
+ * Drizzle schema so that `migration:generate` creates them.
+ * @author Axel Nana <ax.lnana@outlook.com>
+ * @param schema The Postgres schema of the tables. Defaults to the search path.
+ * @param options How the tables are built.
+ */
+export declare const moiraiTables: (schema?: string, options?: MoiraiTablesOptions) => MoiraiTables;
+/**
+ * Where a Drizzle store works: its table, and the connection whose open transaction it joins.
+ * @author Axel Nana <ax.lnana@outlook.com>
+ */
+export type DrizzleStoreOptions<T> = {
+    table: T;
+    connection?: string;
+};
+/**
+ * A table a store accepts: any Postgres table, in any schema, with the columns of the moirai table
+ * `T` under the same property names, such as a table of a domain schema whose key also spans the
+ * partition column.
+ * @author Axel Nana <ax.lnana@outlook.com>
+ */
+export type StoreTable<T extends PgTable> = PgTable & {
+    [K in keyof T['_']['columns']]: PgColumn;
+};
+/**
+ * Keeps idempotency records in a Postgres table, in the action's transaction.
+ * @author Axel Nana <ax.lnana@outlook.com>
+ */
+export declare class DrizzleIdempotencyStore implements IdempotencyStore {
+    private readonly options;
+    constructor(options: DrizzleStoreOptions<StoreTable<MoiraiTables['idempotencyKeys']>>);
+    /** The table, read through the columns of the moirai table, which it has. */
+    private get table();
+    get(key: string): Promise<IdempotencyRecord | undefined>;
+    put(record: IdempotencyRecord): Promise<void>;
+}
+/**
+ * Keeps the outbox in a Postgres table. Claims lock the rows (`FOR UPDATE SKIP LOCKED`) until the
+ * relay's transaction ends, so that concurrent relays share the work.
+ * @author Axel Nana <ax.lnana@outlook.com>
+ */
+export declare class DrizzleOutboxStore implements OutboxStore {
+    #private;
+    private readonly options;
+    constructor(options: DrizzleStoreOptions<StoreTable<MoiraiTables['outbox']>>);
+    /** The table, read through the columns of the moirai table, which it has. */
+    private get table();
+    private get db();
+    insert(rows: readonly OutboxRow[]): Promise<void>;
+    claimDue(claim: OutboxClaim): Promise<readonly OutboxRow[]>;
+    markDispatched(id: string, dispatchedAt: Date): Promise<void>;
+    markFailed(id: string, update: {
+        attempts: number;
+        lastError: string;
+        availableAt: Date;
+    }): Promise<void>;
+    markDead(id: string, update: {
+        attempts: number;
+        lastError: string;
+        deadAt: Date;
+    }): Promise<void>;
+    replacePayload(id: string, payload: unknown): Promise<void>;
+}
+/**
+ * Keeps the inbox in a Postgres table: one row per message and consumer.
+ * @author Axel Nana <ax.lnana@outlook.com>
+ */
+export declare class DrizzleInboxStore implements InboxStore {
+    private readonly options;
+    constructor(options: DrizzleStoreOptions<StoreTable<MoiraiTables['inbox']>>);
+    /** The table, read through the columns of the moirai table, which it has. */
+    private get table();
+    record(messageId: string, consumer: string): Promise<boolean>;
+    /**
+     * Deletes the records older than a date, such as from a daily cron.
+     * @param cutoff The date before which records go.
+     * @returns The number of records deleted.
+     */
+    pruneBefore(cutoff: Date): Promise<number>;
+}
+/**
+ * Keeps event streams in a Postgres table, in the open transaction. An append locks each stream
+ * it writes with an advisory lock held until the transaction ends, and checks that the stream
+ * ends right before the first appended version, so a stale writer gets a
+ * `ConcurrencyConflictError` even when the unique key of the table spans more columns, such as a
+ * partition key. `position` and `transaction_id` are given by Postgres.
+ * @author Axel Nana <ax.lnana@outlook.com>
+ */
+export declare class DrizzleEventStore implements EventStore {
+    private readonly options;
+    constructor(options: DrizzleStoreOptions<StoreTable<MoiraiTables['events']>>);
+    /** The table, read through the columns of the moirai table, which it has. */
+    private get table();
+    private get db();
+    load(aggregateId: string, afterVersion?: number): Promise<readonly StoredEventRecord[]>;
+    readAll(filter: EventReadFilter): Promise<readonly StoredEventRecord[]>;
+    append(records: readonly StoredEventRecord[]): Promise<void>;
+}
+/**
+ * Resets the tables of Drizzle models for projection rebuilds, and keeps the version each
+ * projection was built with in a Postgres table. The reset deletes the rows in the open
+ * transaction, so readers see them until the rebuild commits.
+ * @author Axel Nana <ax.lnana@outlook.com>
+ */
+export declare class DrizzleProjectionStorage implements ProjectionStorage {
+    private readonly options;
+    constructor(options: DrizzleStoreOptions<StoreTable<MoiraiTables['projections']>>);
+    /** The table, read through the columns of the moirai table, which it has. */
+    private get table();
+    private get db();
+    reset(models: readonly object[]): Promise<void>;
+    version(name: string): Promise<number | undefined>;
+    built(name: string, version: number): Promise<void>;
+}
+export {};

package/dist/pithos.d.ts

@@ -0,0 +1,62 @@
+import type { FileCondition, FilePatch, FileRecord, FileStatus, FileStoreDriver } from '@elysiumjs/olympus/pithos';
+import type { BuiltPgTable } from './built-table';
+import type { DrizzleStoreOptions, StoreTable } from './moirai';
+declare module '@elysiumjs/olympus' {
+    interface PortDrivers {
+        'file-store:drizzle': typeof DrizzleFileStore;
+    }
+}
+/** The columns of the files table. */
+declare const fileColumns: () => {
+    id: import("drizzle-orm/pg-core").SetIsPrimaryKey<import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>>;
+    purpose: import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>>;
+    disk: import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>>;
+    key: import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>>;
+    contentType: import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>>;
+    size: import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgBigInt53Builder>;
+    ownerType: import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>>;
+    ownerId: import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>>;
+    createdBy: import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>;
+    status: import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").Set$Type<import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>, FileStatus>>;
+    createdAt: import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgTimestampBuilder>;
+    readyAt: import("drizzle-orm/pg-core").PgTimestampBuilder;
+    claimedAt: import("drizzle-orm/pg-core").PgTimestampBuilder;
+    releasedAt: import("drizzle-orm/pg-core").PgTimestampBuilder;
+    expiresAt: import("drizzle-orm/pg-core").PgTimestampBuilder;
+    deletedAt: import("drizzle-orm/pg-core").PgTimestampBuilder;
+    rejection: import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>;
+};
+/**
+ * Builds the table of the file store, in a schema when one is given. Export it from the Drizzle
+ * schema so that `migration:generate` creates it.
+ * @author Axel Nana <ax.lnana@outlook.com>
+ * @param name The name of the table. Defaults to `files`.
+ * @param schema The Postgres schema of the table. Defaults to the search path.
+ * @example
+ * ```ts
+ * export const files = filesTable();
+ *
+ * PithosModule.with({ disks, files: { store: () => FileStore.for('drizzle', { table: files }) } });
+ * ```
+ */
+export declare const filesTable: (name?: string, schema?: string) => FilesTable;
+/** The table `filesTable()` builds. */
+export type FilesTable = BuiltPgTable<string, undefined, ReturnType<typeof fileColumns>>;
+/**
+ * Keeps file records in a Postgres table, built with `filesTable()` or any table with its
+ * columns. Each transition is one conditional `UPDATE`, so only one of two racing requests wins.
+ * @author Axel Nana <ax.lnana@outlook.com>
+ */
+export declare class DrizzleFileStore implements FileStoreDriver {
+    private readonly options;
+    constructor(options: DrizzleStoreOptions<StoreTable<FilesTable>>);
+    /** The table, read through the columns of the files table, which it has. */
+    private get table();
+    private get db();
+    insert({ owner, ...record }: FileRecord): Promise<void>;
+    find(id: string): Promise<FileRecord | null>;
+    transition(id: string, when: FileCondition, patch: FilePatch): Promise<FileRecord | null>;
+    countPending(createdBy: string, now: Date): Promise<number>;
+    due(now: Date, limit: number): Promise<FileRecord[]>;
+}
+export {};

package/dist/query.d.ts

@@ -0,0 +1,28 @@
+import type { ParsedFilter, ParsedQuery } from '@elysiumjs/olympus/mnemosyne';
+import type { SQL } from 'drizzle-orm';
+import type { PgTableWithColumns } from 'drizzle-orm/pg-core';
+/**
+ * Compiles one filter of a parsed query to a Drizzle condition.
+ * @author Axel Nana <ax.lnana@outlook.com>
+ * @param table The table queried.
+ * @param filter The filter.
+ */
+export declare const compileFilter: (table: PgTableWithColumns<any>, filter: ParsedFilter) => SQL;
+/**
+ * Compiles the condition that keeps the rows after the cursor, in sort order: a keyset condition
+ * over every sort key, the row key last.
+ * @author Axel Nana <ax.lnana@outlook.com>
+ * @param table The table queried.
+ * @param query The parsed query, with `after` set.
+ */
+export declare const compileAfter: (table: PgTableWithColumns<any>, query: ParsedQuery) => SQL | undefined;
+/**
+ * Compiles a parsed query: the `where` condition (filters and cursor) and the `order by`.
+ * @author Axel Nana <ax.lnana@outlook.com>
+ * @param table The table queried.
+ * @param query The parsed query.
+ */
+export declare const compileQuery: (table: PgTableWithColumns<any>, query: ParsedQuery) => {
+    where: SQL<unknown> | undefined;
+    orderBy: SQL<unknown>[];
+};

package/dist/repository.d.ts

@@ -0,0 +1,20 @@
+import type { RepositoryAdapter } from '@elysiumjs/olympus/mnemosyne';
+import type { SQL } from 'drizzle-orm';
+import type { PgTable } from 'drizzle-orm/pg-core';
+import type { DrizzleConnection } from './database';
+declare module '@elysiumjs/olympus/mnemosyne' {
+    interface RepositoryDrivers {
+        drizzle: {
+            table: PgTable;
+            connection: DrizzleConnection;
+            scope: SQL;
+        };
+    }
+}
+/**
+ * The repository adapter of Drizzle: `Repository(Model)` runs on it for the models of
+ * `DrizzleModel()`. Statements join the transaction open on the connection, and honour the
+ * tenant isolation of row-level security.
+ * @author Axel Nana <ax.lnana@outlook.com>
+ */
+export declare const drizzleRepositoryAdapter: RepositoryAdapter<PgTable, DrizzleConnection, SQL>;

package/dist/table-markers.d.ts

@@ -0,0 +1,97 @@
+import type { SQL } from 'drizzle-orm';
+import type { AnyPgColumn, PgTable } from 'drizzle-orm/pg-core';
+/**
+ * A table as the SQL that follows its creation sees it.
+ * @author Axel Nana <ax.lnana@outlook.com>
+ */
+export type CreatedTable = {
+    /** The Postgres schema of the table, `undefined` for `public`. */
+    readonly schema: string | undefined;
+    /** The name of the table. */
+    readonly name: string;
+    /** The quoted, schema-qualified name of the table: `"kernel"."audit"`. */
+    readonly qualified: string;
+};
+/**
+ * A column a partition key is made of: its name in the database, or a function returning the
+ * column of the table.
+ */
+export type PartitionColumn = string | ((table: any) => AnyPgColumn);
+/**
+ * What `migration:generate` adds to the migration that creates a table.
+ * @author Axel Nana <ax.lnana@outlook.com>
+ */
+export type TableMarker = {
+    /** The columns of the range partition key. */
+    readonly range?: readonly PartitionColumn[];
+    /** The SQL to run after the table is created. */
+    readonly afterCreate?: ReadonlyArray<(table: CreatedTable) => string | SQL>;
+};
+/**
+ * Attaches markers to a table, after the ones it already has.
+ * @author Axel Nana <ax.lnana@outlook.com>
+ * @param table The table.
+ * @param markers The markers.
+ * @returns The table.
+ */
+export declare const markTable: <T extends PgTable>(table: T, markers: readonly TableMarker[]) => T;
+/**
+ * Reads the markers of a table.
+ * @author Axel Nana <ax.lnana@outlook.com>
+ * @param table The table.
+ * @returns The markers merged into one, or `undefined` when the table has none.
+ */
+export declare const getTableMarker: (table: object) => TableMarker | undefined;
+/**
+ * Applies the markers of the given tables to the migration that creates them: the partition key
+ * after `CREATE TABLE`, then the SQL to run after it, each as its own statement. A table the
+ * migration does not create is left as it is.
+ * @author Axel Nana <ax.lnana@outlook.com>
+ * @param sql The SQL of the migration, without the `public` qualifiers.
+ * @param tables The tables of the app.
+ * @returns The SQL with the markers applied.
+ */
+export declare const applyTableMarkers: (sql: string, tables: Iterable<PgTable>) => string;
+/**
+ * Drizzle tables: the markers that `migration:generate` applies to the migration creating a table.
+ * @author Axel Nana <ax.lnana@outlook.com>
+ */
+export declare namespace DrizzleTable {
+    /**
+     * Marks a table with what `migration:generate` adds to the migration that creates it. Later
+     * migrations, and tables created before the markers were added, are left as they are.
+     * @example
+     * ```ts
+     * export const audit = DrizzleTable.define(
+     * 	DrizzleTable.partitioned({ range: 'recorded_at' }),
+     * 	DrizzleTable.afterCreate(
+     * 		({ qualified }) =>
+     * 			`CREATE TRIGGER audit_append_only BEFORE UPDATE OR DELETE ON ${qualified} FOR EACH ROW EXECUTE FUNCTION forbid_change()`
+     * 	)
+     * )(
+     * 	kernel.table('audit', { ... }, (t) => [primaryKey({ columns: [t.id, t.recordedAt] })])
+     * );
+     * ```
+     * @author Axel Nana <ax.lnana@outlook.com>
+     * @param markers The markers, from `DrizzleTable.partitioned()` and `DrizzleTable.afterCreate()`.
+     * @returns A function marking the table and returning it.
+     */
+    const define: (...markers: TableMarker[]) => <T extends PgTable>(target: T) => T;
+    /**
+     * Creates the table partitioned by range: `PARTITION BY RANGE (...)` follows its `CREATE TABLE`.
+     * The primary key and the unique constraints of the table must include the partition columns.
+     * @author Axel Nana <ax.lnana@outlook.com>
+     * @param options The partition key: a column name in the database, a function returning the
+     * column, or several of them.
+     */
+    const partitioned: (options: {
+        range: PartitionColumn | readonly PartitionColumn[];
+    }) => TableMarker;
+    /**
+     * Runs SQL right after the table is created, in the same migration: partitions, triggers or
+     * grants that belong to the table.
+     * @author Axel Nana <ax.lnana@outlook.com>
+     * @param build Returns the SQL, as a string or a `sql` template, from the created table.
+     */
+    const afterCreate: (build: (table: CreatedTable) => string | SQL) => TableMarker;
+}

package/dist/table.d.ts

@@ -0,0 +1,21 @@
+import type { AnyPgColumnBuilder, PgTableWithColumns } from 'drizzle-orm/pg-core';
+import type { BuiltPgTable } from './built-table';
+/**
+ * Retrieves the original column builders for a table.
+ * @param table The table created with enhanced pgTable.
+ * @returns The original column builder definitions, or `undefined`.
+ */
+export declare const getTableBuilders: (table: PgTableWithColumns<any>) => Record<string, AnyPgColumnBuilder> | undefined;
+/**
+ * Creates a PostgreSQL table with automatic column builder registration.
+ *
+ * This is an enhanced version of Drizzle's `pgTable` that automatically
+ * registers column builders for tenancy support. It has the exact same
+ * signature and behavior as the original.
+ *
+ * @param tableName The name of the database table.
+ * @param columns The column definitions.
+ * @param extraConfig Optional extra Drizzle table configuration.
+ * @returns A Drizzle PostgreSQL table with registered column builders.
+ */
+export declare const pgTable: <TTableName extends string, TColumns extends Record<string, AnyPgColumnBuilder>>(tableName: TTableName, columns: TColumns, extraConfig?: (table: any) => any) => BuiltPgTable<TTableName, undefined, TColumns>;