@elysiumjs/drizzle 0.0.0-stage → 0.1.0

package/dist/pithos.d.ts

@@ -0,0 +1,301 @@
+import type { FileCondition, FilePatch, FileRecord, FileStatus, FileStoreDriver } from '@elysiumjs/olympus/pithos';
+import type { DrizzleStoreOptions, StoreTable } from './moirai';
+declare module '@elysiumjs/olympus' {
+    interface PortDrivers {
+        'file-store:drizzle': typeof DrizzleFileStore;
+    }
+}
+/**
+ * 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) => import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: string;
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgBuildColumn<string, import("drizzle-orm/pg-core").SetIsPrimaryKey<import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>>, {
+            name: string;
+            tableName: string;
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        purpose: import("drizzle-orm/pg-core").PgBuildColumn<string, import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>>, {
+            name: string;
+            tableName: string;
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        disk: import("drizzle-orm/pg-core").PgBuildColumn<string, import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>>, {
+            name: string;
+            tableName: string;
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        key: import("drizzle-orm/pg-core").PgBuildColumn<string, import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>>, {
+            name: string;
+            tableName: string;
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        contentType: import("drizzle-orm/pg-core").PgBuildColumn<string, import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>>, {
+            name: string;
+            tableName: string;
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        size: import("drizzle-orm/pg-core").PgBuildColumn<string, import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgBigInt53Builder>, {
+            name: string;
+            tableName: string;
+            dataType: "number int53";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        ownerType: import("drizzle-orm/pg-core").PgBuildColumn<string, import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>>, {
+            name: string;
+            tableName: string;
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        ownerId: import("drizzle-orm/pg-core").PgBuildColumn<string, import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>>, {
+            name: string;
+            tableName: string;
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        createdBy: import("drizzle-orm/pg-core").PgBuildColumn<string, import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>, {
+            name: string;
+            tableName: string;
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        status: import("drizzle-orm/pg-core").PgBuildColumn<string, import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").Set$Type<import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>, FileStatus>>, {
+            name: string;
+            tableName: string;
+            dataType: "string";
+            data: FileStatus;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        createdAt: import("drizzle-orm/pg-core").PgBuildColumn<string, import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgTimestampBuilder>, {
+            name: string;
+            tableName: string;
+            dataType: "object date";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        readyAt: import("drizzle-orm/pg-core").PgBuildColumn<string, import("drizzle-orm/pg-core").PgTimestampBuilder, {
+            name: string;
+            tableName: string;
+            dataType: "object date";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        claimedAt: import("drizzle-orm/pg-core").PgBuildColumn<string, import("drizzle-orm/pg-core").PgTimestampBuilder, {
+            name: string;
+            tableName: string;
+            dataType: "object date";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        releasedAt: import("drizzle-orm/pg-core").PgBuildColumn<string, import("drizzle-orm/pg-core").PgTimestampBuilder, {
+            name: string;
+            tableName: string;
+            dataType: "object date";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        expiresAt: import("drizzle-orm/pg-core").PgBuildColumn<string, import("drizzle-orm/pg-core").PgTimestampBuilder, {
+            name: string;
+            tableName: string;
+            dataType: "object date";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        deletedAt: import("drizzle-orm/pg-core").PgBuildColumn<string, import("drizzle-orm/pg-core").PgTimestampBuilder, {
+            name: string;
+            tableName: string;
+            dataType: "object date";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        rejection: import("drizzle-orm/pg-core").PgBuildColumn<string, import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>, {
+            name: string;
+            tableName: string;
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+    };
+    dialect: 'pg';
+}>;
+/** The table `filesTable()` builds. */
+export type FilesTable = ReturnType<typeof filesTable>;
+/**
+ * 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[]>;
+}

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,69 @@
+import type { AnyPgColumnBuilder, PgTableWithColumns } from 'drizzle-orm/pg-core';
+/**
+ * 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) => PgTableWithColumns<{
+    name: TTableName;
+    schema: undefined;
+    columns: { [Key in keyof TColumns]: import("drizzle-orm/pg-core").PgBuildColumn<TTableName, TColumns[Key], {
+        name: string;
+        tableName: TTableName;
+        dataType: TColumns[Key]["_"]["dataType"];
+        data: TColumns[Key]["_"]["dimensions"] extends 1 | 2 | 3 | 4 | 5 ? TColumns[Key]["_"]["dimensions"] extends infer T ? T extends TColumns[Key]["_"]["dimensions"] ? T extends 1 ? (TColumns[Key]["_"] extends infer T_1 ? T_1 extends TColumns[Key]["_"] ? T_1 extends {
+            $type: infer U;
+        } ? U : T_1 extends {
+            data: infer D;
+        } ? D : unknown : never : never)[] : T extends 2 ? (TColumns[Key]["_"] extends infer T_1 ? T_1 extends TColumns[Key]["_"] ? T_1 extends {
+            $type: infer U;
+        } ? U : T_1 extends {
+            data: infer D;
+        } ? D : unknown : never : never)[][] : T extends 3 ? (TColumns[Key]["_"] extends infer T_1 ? T_1 extends TColumns[Key]["_"] ? T_1 extends {
+            $type: infer U;
+        } ? U : T_1 extends {
+            data: infer D;
+        } ? D : unknown : never : never)[][][] : T extends 4 ? (TColumns[Key]["_"] extends infer T_1 ? T_1 extends TColumns[Key]["_"] ? T_1 extends {
+            $type: infer U;
+        } ? U : T_1 extends {
+            data: infer D;
+        } ? D : unknown : never : never)[][][][] : T extends 5 ? (TColumns[Key]["_"] extends infer T_1 ? T_1 extends TColumns[Key]["_"] ? T_1 extends {
+            $type: infer U;
+        } ? U : T_1 extends {
+            data: infer D;
+        } ? D : unknown : never : never)[][][][][] : TColumns[Key]["_"] extends infer T_1 ? T_1 extends TColumns[Key]["_"] ? T_1 extends {
+            $type: infer U;
+        } ? U : T_1 extends {
+            data: infer D;
+        } ? D : unknown : never : never : never : never : TColumns[Key]["_"] extends infer T_1 ? T_1 extends TColumns[Key]["_"] ? T_1 extends {
+            $type: infer U;
+        } ? U : T_1 extends {
+            data: infer D;
+        } ? D : unknown : never : never;
+        driverParam: TColumns[Key]["_"]["dimensions"] extends 1 | 2 | 3 | 4 | 5 ? string | (TColumns[Key]["_"]["dimensions"] extends infer T_2 ? T_2 extends TColumns[Key]["_"]["dimensions"] ? T_2 extends 1 ? TColumns[Key]["_"]["driverParam"][] : T_2 extends 2 ? TColumns[Key]["_"]["driverParam"][][] : T_2 extends 3 ? TColumns[Key]["_"]["driverParam"][][][] : T_2 extends 4 ? TColumns[Key]["_"]["driverParam"][][][][] : T_2 extends 5 ? TColumns[Key]["_"]["driverParam"][][][][][] : TColumns[Key]["_"]["driverParam"] : never : never) : TColumns[Key]["_"]["driverParam"];
+        notNull: TColumns[Key]["_"]["notNull"] extends true ? true : false;
+        hasDefault: TColumns[Key]["_"]["hasDefault"] extends true ? true : false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: TColumns[Key]["_"] extends infer T_3 ? T_3 extends TColumns[Key]["_"] ? T_3 extends {
+            enumValues: infer E extends string[];
+        } ? E : undefined : never : never;
+        identity: TColumns[Key]["_"]["identity"] extends "always" | "byDefault" ? TColumns[Key]["_"]["identity"] : undefined;
+        generated: TColumns[Key]["_"]["generated"] extends true ? true : undefined;
+    }>; };
+    dialect: 'pg';
+}>;

package/dist/tenancy.d.ts

@@ -0,0 +1,105 @@
+import type { TenancyStrategy } from '@elysiumjs/olympus/mnemosyne';
+import type { AnyPgColumnBuilder, PgAsyncTransaction, PgSchema, PgTable } from 'drizzle-orm/pg-core';
+import type { DrizzleConnection } from './database';
+/**
+ * Returns the Drizzle `PgSchema` for the given tenant, creating it if needed.
+ * @author Axel Nana <ax.lnana@outlook.com>
+ * @param tenant The tenant identifier.
+ * @returns The tenant's PostgreSQL schema.
+ * @throws {Error} If the tenant identifier is malformed.
+ */
+export declare const getTenantSchema: (tenant: string) => PgSchema;
+/**
+ * Registers a new tenant schema in the registry.
+ * @author Axel Nana <ax.lnana@outlook.com>
+ * @param tenant The tenant identifier.
+ * @returns The newly registered (or existing) `PgSchema`.
+ * @throws {Error} If the tenant identifier is malformed.
+ */
+export declare const registerTenantSchema: (tenant: string) => PgSchema;
+/**
+ * Wraps a table definition in a tenant-specific schema.
+ *
+ * For the `'public'` tenant, returns a standard `pgTable`.
+ * For other tenants, creates a schema-qualified table and caches it.
+ *
+ * @author Axel Nana <ax.lnana@outlook.com>
+ * @param tenant The tenant identifier.
+ * @param tableName The table name.
+ * @param columns The column definitions.
+ * @returns A tenant-scoped `PgTable`.
+ * @throws {Error} If the tenant identifier is malformed.
+ */
+export declare const wrapTenantSchema: <TTableName extends string, TColumnsMap extends Record<string, AnyPgColumnBuilder>>(tenant: string, tableName: TTableName, columns: TColumnsMap) => PgTable;
+/**
+ * Executes a callback within an RLS-scoped transaction for the given tenant.
+ *
+ * The transaction is registered in the async context, so repositories and
+ * `Database.getConnection()` use it inside the callback. When a transaction is already open on the
+ * connection, the callback joins it if it is bound to the same tenant. Work for several tenants
+ * (such as an admin fan-out) must use one `withRLS()` per tenant, outside any transaction.
+ * @author Axel Nana <ax.lnana@outlook.com>
+ * @param tenant The tenant identifier (or `null` for 'public').
+ * @param callback The function to execute within the transaction.
+ * @param connectionName The database connection name.
+ * @returns The return value of the callback.
+ * @throws {TenantMismatchError} If the open transaction is bound to another tenant.
+ */
+export declare const withRLS: <T>(tenant: string | null, callback: (tx: PgAsyncTransaction<any, any>) => Promise<T>, connectionName?: string) => Promise<T>;
+/**
+ * Reads the current tenant from the PostgreSQL tenant variable, on the open transaction when
+ * there is one.
+ * @author Axel Nana <ax.lnana@outlook.com>
+ * @param connectionName The database connection name.
+ * @returns The current tenant identifier, or `null`.
+ */
+export declare const getSessionTenant: (connectionName?: string) => Promise<string | null>;
+/**
+ * Creates an RLS policy for tenant isolation on a table.
+ * @author Axel Nana <ax.lnana@outlook.com>
+ * @param tableName The table name.
+ * @param columnName The tenant column name (defaults to config or 'tenant_id').
+ * @param policyName The policy name (defaults to `{tableName}_tenant_isolation`).
+ * @returns A Drizzle `PgPolicy` instance.
+ */
+export declare const createRLSPolicy: (tableName: string, columnName?: string, policyName?: string) => import("drizzle-orm/pg-core").PgPolicy;
+/**
+ * Schema-based tenancy strategy for Drizzle.
+ *
+ * Each tenant gets its own PostgreSQL schema. Table resolution maps
+ * the base table to a schema-qualified equivalent.
+ *
+ * @author Axel Nana <ax.lnana@outlook.com>
+ */
+export declare class DrizzleSchemaTenancy implements TenancyStrategy<PgTable, DrizzleConnection> {
+    readonly mode = "schema";
+    resolveTable(table: PgTable, tenant: string): PgTable;
+    withIsolation<T>(_connection: DrizzleConnection, _tenant: string, callback: () => Promise<T>): Promise<T>;
+}
+/**
+ * Row-Level Security tenancy strategy for Drizzle.
+ *
+ * All tenants share the same schema. Isolation is achieved via
+ * PostgreSQL RLS policies and a session variable set in each transaction.
+ *
+ * @author Axel Nana <ax.lnana@outlook.com>
+ */
+export declare class DrizzleRLSTenancy implements TenancyStrategy<PgTable, DrizzleConnection> {
+    readonly mode = "rls";
+    resolveTable(table: PgTable, _tenant: string): PgTable;
+    /**
+     * Runs a callback in a transaction scoped to the given tenant.
+     *
+     * The transaction is bound to the tenant for its whole life, registered in the async context
+     * for the connection, and the tenant set as the current tenant, for the duration of the
+     * callback. When a transaction is already open on the connection, the callback joins it, which
+     * is only allowed when that transaction is bound to the same tenant.
+     * @author Axel Nana <ax.lnana@outlook.com>
+     * @param connection The base connection (see `Database.getBaseConnection`).
+     * @param tenant The tenant identifier.
+     * @param callback The function to execute within the isolated context.
+     * @returns The return value of the callback.
+     * @throws {TenantMismatchError} If the open transaction is bound to another tenant.
+     */
+    withIsolation<T>(connection: DrizzleConnection, tenant: string, callback: () => Promise<T>): Promise<T>;
+}