@elysiumjs/drizzle 0.0.0-stage → 0.1.0

package/dist/migration-clients.d.ts

@@ -0,0 +1,37 @@
+import type { MigrationConnection } from './migration';
+/** A query of a tagged-template client, which runs once awaited. */
+type UnsafeQuery = PromiseLike<unknown> & {
+    simple?(): PromiseLike<unknown>;
+};
+/**
+ * What `migration:run` uses of a tagged-template client (Bun SQL and postgres.js share it).
+ */
+export type TemplateClient = {
+    unsafe(text: string, params?: unknown[]): UnsafeQuery;
+    begin<T>(fn: (tx: TemplateClient) => Promise<T>): Promise<T>;
+};
+/**
+ * The migration connection of a tagged-template client: Bun SQL or postgres.js.
+ * @author Axel Nana <ax.lnana@outlook.com>
+ * @param client The client.
+ */
+export declare const templateClientMigrations: (client: TemplateClient) => MigrationConnection;
+/** What `migration:run` uses of a node-postgres client. */
+type PgQueryable = {
+    query(text: string, values?: unknown[]): Promise<{
+        rows: unknown[];
+    }>;
+};
+/** What `migration:run` uses of a node-postgres pool. */
+export type PgPool = PgQueryable & {
+    connect(): Promise<PgQueryable & {
+        release(): void;
+    }>;
+};
+/**
+ * The migration connection of a node-postgres pool.
+ * @author Axel Nana <ax.lnana@outlook.com>
+ * @param pool The pool.
+ */
+export declare const nodePostgresMigrations: (pool: PgPool) => MigrationConnection;
+export {};

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