@drhomet/mithaq 0.0.0-stage → 0.2.0

package/dist/drizzle/kinds.d.ts

@@ -0,0 +1,28 @@
+import { integer, text, uuid } from 'drizzle-orm/pg-core';
+import type { ResolvedField } from '../mithaq/types.ts';
+import type { ColumnBuilder } from './index.ts';
+/** Length is a rule, not a kind: without a maximum a string column is `text`. */
+declare const string: (field: ResolvedField) => import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]> | import("drizzle-orm/pg-core").PgVarcharBuilder<[string, ...string[]]>;
+declare const idColumns: {
+    number: typeof integer;
+    text: typeof text;
+    uuid: typeof uuid;
+};
+export declare const idKinds: (keyof typeof idColumns)[];
+/** One column builder per kind. */
+export declare const kinds: {
+    number: (field: ResolvedField) => import("drizzle-orm/pg-core").PgNumericNumberBuilder | import("drizzle-orm/pg-core").PgSerialBuilder;
+    integer: (field: ResolvedField) => import("drizzle-orm/pg-core").PgIntegerBuilder;
+    decimal: (field: ResolvedField) => import("drizzle-orm/pg-core").PgNumericBuilder;
+    text: typeof string;
+    email: typeof string;
+    checkbox: (field: ResolvedField) => import("drizzle-orm/pg-core").PgBooleanBuilder;
+    textArray: (field: ResolvedField) => import("drizzle-orm/pg-core").SetDimensions<import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>, 1>;
+    uuid: (field: ResolvedField) => import("drizzle-orm/pg-core").PgUUIDBuilder;
+    datetime: (field: ResolvedField) => import("drizzle-orm/pg-core").PgTimestampBuilder;
+    date: (field: ResolvedField) => import("drizzle-orm/pg-core").PgDateStringBuilder;
+    join: (field: ResolvedField) => never;
+    json: (field: ResolvedField) => import("drizzle-orm/pg-core").PgJsonbBuilder;
+    relationship: ColumnBuilder;
+};
+export {};

package/dist/drizzle/kinds.js

@@ -0,0 +1,43 @@
+import { boolean, date, integer, jsonb, numeric, serial, text, timestamp, uuid, varchar } from 'drizzle-orm/pg-core';
+/** Length is a rule, not a kind: without a maximum a string column is `text`. */
+const string = (field) => typeof field.rules?.maxLength !== 'number'
+    ? text(field.column)
+    : varchar(field.column, { length: field.rules.maxLength });
+// A foreign key takes the type of the id it points at: Postgres refuses a
+// `text` column referencing a `uuid` key. The keys are the kinds an id may be.
+const idColumns = { number: integer, text, uuid };
+export const idKinds = Object.keys(idColumns);
+const idColumn = (field) => idColumns[field.target.fields.id.kind](field.column);
+const relationship = (field, tables) => idColumn(field).references(() => tables[field.target.name].id, {
+    onDelete: ['cascade', 'restrict', 'set null'].includes(String(field.rules?.onDelete))
+        ? field.rules?.onDelete
+        : undefined,
+});
+/** One column builder per kind. */
+export const kinds = {
+    number: (field) => field.name === 'id' ? serial(field.column) : numeric(field.column, { mode: 'number' }),
+    integer: (field) => integer(field.column),
+    // drizzle's default string mode, so no digit passes through a JS number.
+    decimal: (field) => typeof field.rules?.precision === 'number'
+        ? numeric(field.column, { precision: field.rules.precision, scale: field.rules.scale })
+        : numeric(field.column),
+    text: string,
+    email: string,
+    checkbox: (field) => boolean(field.column),
+    // Length is not a rule this kind binds, so it is never `varchar(n)[]`.
+    textArray: (field) => text(field.column).array(),
+    // Only the primary key gets a random default: any other uuid column holds an
+    // identifier something else chose.
+    uuid: (field) => (field.name === 'id' ? uuid(field.column).defaultRandom() : uuid(field.column)),
+    datetime: (field) => timestamp(field.column, { precision: 3, withTimezone: true, mode: 'date' }),
+    // `mode: 'string'` keeps the day a day: `'date'` mode hands back a `Date` at
+    // local midnight, which another zone reads as the day before.
+    date: (field) => date(field.column, { mode: 'string' }),
+    // Unreachable: `columnsOfField` answers a join with no column before any builder runs.
+    join: (field) => {
+        throw new Error(`Field "${field.name}" is a join, whose rows are held by kayan "${field.target?.name}", so this store builds no column for it.`);
+    },
+    // `jsonb`, as Payload's Postgres adapter stores a json field, so either reads what the other wrote.
+    json: (field) => jsonb(field.column),
+    relationship,
+};

package/dist/drizzle/migrate.d.ts

@@ -0,0 +1,159 @@
+import * as modules from 'node:module';
+import { type NodePgDatabase } from 'drizzle-orm/node-postgres';
+import { type ProdMigrations } from './index.ts';
+import type { ResolvedKayan } from '../mithaq/types.ts';
+export declare const binary: string;
+/**
+ * Resolves each drizzle-orm import made under `kit` from `from` instead. drizzle-kit imports
+ * drizzle-orm without declaring it, so on its own it loads whatever copy the project hoists,
+ * such as a 0.45 beside the one the tables were built with, and fails on it.
+ */
+export declare const holdKitOrm: ({ kit, from }: {
+    kit: string;
+    from: string;
+}) => modules.ModuleHooks;
+/** The drizzle-kit this mithaq installs, and the file its drizzle-orm resolves from. */
+export declare const ownKit: {
+    kit: string;
+    from: string;
+};
+/** Holds this mithaq's drizzle-kit to its own drizzle-orm in this process, once. */
+export declare const holdOwnKit: () => {};
+/**
+ * A module to `--import` that holds `kit`'s drizzle-orm to `from`'s in a child process.
+ * ponytail: only the drizzle-kit mithaq starts is held; `drizzle-kit migrate` run by hand beside a
+ * second drizzle-orm still loads the hoisted one. Ship a `mithaq` word that applies migrations if that bites.
+ */
+export declare const kitOrm: (held: {
+    kit: string;
+    from: string;
+}) => string;
+export declare const header = "// Written by `mithaq migrate`. Commit it.";
+/** One `unresolved` item, and one reply in the hints file, are the same shape. */
+type Hint = {
+    type: string;
+    kind: string;
+    entity: string[];
+    reason?: string;
+};
+type Envelope = {
+    status: 'ok';
+    migration_path?: string;
+    statements?: Statement[];
+} | {
+    status: 'no_changes';
+} | {
+    status: 'missing_hints';
+    unresolved: Hint[];
+} | {
+    status: 'error';
+    error: {
+        code: string;
+        source?: string;
+    };
+};
+type Statement = {
+    type: 'drop_table';
+    table: {
+        schema: string;
+        name: string;
+    };
+} | {
+    type: 'drop_column';
+    column: {
+        schema: string;
+        table: string;
+        name: string;
+    };
+} | {
+    type: 'drop_pk';
+    pk: {
+        schema?: string;
+        table: string;
+        name: string;
+    };
+} | {
+    type: 'drop_view';
+    view: {
+        schema: string;
+        name: string;
+        materialized?: boolean;
+    };
+} | {
+    type: 'recreate_column';
+    diff: {
+        $right: {
+            schema: string;
+            table: string;
+            name: string;
+        };
+    };
+} | {
+    type: string;
+};
+type Losing = {
+    kind: 'table' | 'column' | 'primary_key' | 'view';
+    entity: string[];
+};
+export declare const droppedBy: (statement: Statement) => Losing | undefined;
+/** A guard the database enforces and a migration would drop, in the shape its reply names it. */
+type Guarded = {
+    kind: 'check' | 'enum' | 'column' | 'sequence';
+    entity: string[];
+};
+export declare const guardDroppedBy: (statement: Statement) => Guarded | undefined;
+type Database = {
+    execute(query: unknown): Promise<{
+        rows: unknown[];
+    }>;
+    transaction<T>(run: (tx: {
+        execute(query: unknown): Promise<{
+            rows: unknown[];
+        }>;
+    }) => Promise<T>, config?: {
+        accessMode?: 'read only';
+    }): Promise<T>;
+};
+export declare const bootMigrations: ({ db, prodMigrations }: {
+    db: NodePgDatabase;
+    prodMigrations: ProdMigrations | undefined;
+}) => Promise<void>;
+type Pulled = {
+    status: 'ok';
+    migrationPath: string;
+    snapshotPath: string;
+} | {
+    status: 'error';
+    error: {
+        code: string;
+        source?: string;
+    };
+};
+export declare const baselineOf: ({ envelope, read, tables }: {
+    envelope: Pulled;
+    read: (path: string) => string;
+    /** The language's tables as `<schema>.<name>`. */
+    tables: readonly string[];
+}) => {
+    folder: string;
+    sql: string;
+    snapshot: string;
+};
+export declare const statementsOf: (envelope: Envelope) => Statement[];
+type Target = {
+    db: Database;
+    tables: Record<string, unknown>;
+    schemas: Record<string, unknown>;
+    enums: Record<string, {
+        schema?: string;
+        enumName: string;
+        enumValues: string[];
+    }>;
+    connectionString?: string;
+    kayan: readonly ResolvedKayan[];
+};
+export declare const run: ({ target, flags, }: {
+    target: Target;
+    flags: readonly string[];
+}) => Promise<number>;
+export {};