@drhomet/mithaq 0.0.0-stage → 0.1.1

package/dist/drizzle/index.js

@@ -0,0 +1,832 @@
+import { and, asc, count as sqlCount, desc, eq, getTableColumns, getTableName, gt, gte, ilike, inArray, isNotNull, isNull, lt, lte, ne, notInArray, or, sql } from 'drizzle-orm';
+import { drizzle } from 'drizzle-orm/node-postgres';
+import { boolean as pgBoolean, index, integer as pgInteger, isPgEnum, jsonb, timestamp, uuid as pgUuid, pgEnum, pgSchema, pgTable, primaryKey, unique as uniqueConstraint, uniqueIndex, } from 'drizzle-orm/pg-core';
+import { isPlainIdentifier, snakeCase, uniqueRuleIndexes, versionsTableOf } from '../mithaq/resolve.js';
+import { implementationOf } from '../mithaq/rukn.js';
+import { conflict, localizedQuery } from '../asas/runner/errors.js';
+import { Refusal } from '../mithaq/refusal.js';
+import { providerOf } from '../base/rules.js';
+import { idKinds as drizzleIdKinds, kinds as drizzleKinds } from './kinds.js';
+import { rules as drizzleRules } from './rules.js';
+const modifiable = (column) => {
+    for (const method of ['default', 'notNull', 'primaryKey', 'unique']) {
+        if (typeof Reflect.get(column, method) !== 'function') {
+            throw new Error(`The drizzle column builder has no ${method} modifier.`);
+        }
+    }
+    return column;
+};
+// A localized field is one column per locale, `<column>_<locale>`, each the same field
+// renamed, so every builder and rule runs per locale. An override is its one column.
+const columnsOfField = (store) => (field) => 
+// A `hasMany` field's set lives in its join table, and a `join` field's id is the child's column.
+field.hasMany || field.kind === 'join'
+    ? []
+    : !field.rules?.localized || field.targets?.[store]
+        ? [field]
+        : field.locales.map((locale) => ({
+            ...field,
+            name: `${field.name}_${locale}`,
+            column: `${field.column}_${locale}`,
+        }));
+// One table per `hasMany` field, `courses_tags`, the same string as its SQL name and
+// its key on `tables`, so the push and `mithaq migrate` reach it unchanged.
+export const joinTableOf = (kayan, field) => `${kayan.table}_${snakeCase(field.name)}`;
+/** The fields of one kayan the store holds as a join table rather than a column. */
+export const manyFields = (kayan) => Object.values(kayan?.fields ?? {}).filter((field) => field.hasMany);
+// Read off the global symbol drizzle keeps it under, so an override that is no
+// table answers `public` and is refused by name rather than as a `TypeError`.
+export const schemaOf = (table) => table?.[Symbol.for('drizzle:Schema')] ?? 'public';
+// A lowercase plain identifier needs no quoting anywhere and names the schema module's
+// export. Postgres keeps `pg_*` and `information_schema`; mithaq's history is in `drizzle`.
+const refusedSchema = (name) => typeof name !== 'string' || !isPlainIdentifier(name) || name !== name.toLowerCase()
+    ? 'which is not a lowercase SQL identifier: lowercase letters, digits and underscores, not starting with a digit, at most 63 bytes.'
+    : name.startsWith('pg_') || name === 'information_schema'
+        ? 'which Postgres keeps for itself.'
+        : name === migrationsTable.schema
+            ? 'where mithaq keeps its migration history.'
+            : undefined;
+// A plain `Error`: what reaches here is a `where` an access callback returned, the
+// project's own bug; the read layer refuses a caller's first.
+const refuseLocalized = (kayan, field, what, locales) => new Error(localizedQuery({ kayan, field, what, locales }));
+// Postgres answers `23503`, refused as a conflict naming which kayan points at the
+// row, never which row. Read by schema too: another tool may share a table name.
+const referenced = ({ thrown, name, kayans, tables }) => {
+    const held = thrown;
+    const error = held?.code === '23503' ? held : held?.cause?.code === '23503' ? held.cause : undefined;
+    if (!error)
+        return thrown;
+    // A kayan's join tables are built in its own table's schema.
+    const by = [...kayans].find(([key, kayan]) => schemaOf(tables[key]) === error.schema &&
+        (kayan.table === error.table || manyFields(kayan).some((field) => joinTableOf(kayan, field) === error.table)))?.[1].name;
+    return conflict({ message: `A "${name}" row is still pointed at by another row, so it is not deleted.`, key: 'error.conflict.referenced', params: { kayan: name, ...(by && { by }) }, cause: thrown });
+};
+// Read by SQLSTATE `23505` on the driver error's cause, not by its locale-dependent
+// message; every other failure is rethrown as it was.
+// The cause's `detail` names the collided value, so it must never be serialized.
+const collision = (thrown, name) => {
+    const held = thrown;
+    if (held?.code !== '23505' && held?.cause?.code !== '23505')
+        return thrown;
+    return conflict({
+        message: `A "${name}" row already holds one of the unique values this write carries.`,
+        key: 'error.conflict.unique',
+        params: { kayan: name },
+        cause: thrown,
+    });
+};
+// Every `text` member of Lexical's tree as one JSON array, so a search runs over what
+// a reader sees, never a key or a node type.
+const textOf = (column) => sql `jsonb_path_query_array(${column}, 'strict $.**.text')::text`;
+const pattern = (value) => `%${value.replace(/[\\%_]/g, '\\$&')}%`;
+const splitNulls = (value) => {
+    const values = value;
+    return { hasNull: values.some((one) => one === null), values: values.filter((one) => one !== null) };
+};
+// The column is the caller's: this table's, or a join table's for a `hasMany` field.
+const conditionsOf = (column, rules) => {
+    const checks = Object.entries(rules).map(([operator, value]) => {
+        switch (operator) {
+            case 'contains':
+                return ilike(column, pattern(String(value)));
+            case 'like':
+                return and(...String(value).trim().split(/\s+/).filter(Boolean).map((word) => ilike(column, pattern(word))));
+            case 'equals':
+                return value === null ? isNull(column) : eq(column, value);
+            case 'exists':
+                return value ? isNotNull(column) : isNull(column);
+            case 'greater_than':
+                return gt(column, value);
+            case 'greater_than_equal':
+                return gte(column, value);
+            case 'in': {
+                const split = splitNulls(value);
+                const nonNull = split.values.length ? inArray(column, split.values) : sql `false`;
+                return split.hasNull ? or(isNull(column), nonNull) : nonNull;
+            }
+            case 'less_than':
+                return lt(column, value);
+            case 'less_than_equal':
+                return lte(column, value);
+            case 'not_equals':
+                return value === null ? isNotNull(column) : ne(column, value);
+            case 'not_in': {
+                const split = splitNulls(value);
+                const nonNull = split.values.length ? notInArray(column, split.values) : sql `true`;
+                return split.hasNull ? and(isNotNull(column), nonNull) : nonNull;
+            }
+        }
+        // Unreachable, but a value past both checks would otherwise be left out of a `where`,
+        // which carries an access constraint.
+        throw new Error(`Unsupported where operator "${operator}".`);
+    });
+    return checks.length === 1 ? checks[0] : and(...checks);
+};
+const whereOf = (db, tables, kayanByName, name, where) => {
+    const table = tables[name];
+    const kayan = kayanByName.get(name);
+    const parts = [];
+    const conjunction = where.and;
+    if (Array.isArray(conjunction))
+        parts.push(and(...conjunction.map((one) => whereOf(db, tables, kayanByName, name, one))));
+    const disjunction = where.or;
+    if (Array.isArray(disjunction))
+        parts.push(or(...disjunction.map((one) => whereOf(db, tables, kayanByName, name, one))));
+    for (const [field, rules] of Object.entries(where)) {
+        if (field === 'and' || field === 'or')
+            continue;
+        const [ownField, relatedField] = field.split('.');
+        const relationField = kayan.fields[ownField];
+        // A `hasMany` field has no column here, so the join table is filtered and its
+        // parent ids filter this table.
+        if (relationField?.hasMany) {
+            const join = tables[joinTableOf(kayan, relationField)];
+            const target = tables[relationField.target.name];
+            const column = relatedField ? target[relatedField] : join.target;
+            const own = conditionsOf(column, rules);
+            const parents = relatedField
+                ? db.select({ id: join.parent }).from(join).where(inArray(join.target, db.select({ id: target.id }).from(target).where(own)))
+                : db.select({ id: join.parent }).from(join).where(own);
+            parts.push(inArray(table.id, parents));
+            continue;
+        }
+        // A locale named as the second segment is one column of this same table.
+        const locale = relatedField && relationField?.locales?.includes(relatedField) && !relationField.targets?.[kayan.store]
+            ? `${ownField}_${relatedField}`
+            : undefined;
+        const hop = locale ? undefined : relatedField;
+        const relationTo = relationField?.relationTo;
+        const relationName = relationField?.target?.name ?? (typeof relationTo === 'function' ? relationTo().name : relationTo);
+        // A localized field named alone is several columns, and nothing here may pick a locale.
+        // Asked of the field the path lands on, which across a hop is the related kayan's.
+        const named = hop ? (relationField?.target ? relationField.target.fields[hop] : relationField) : relationField;
+        if (!locale && named?.rules?.localized) {
+            throw refuseLocalized(hop && relationField?.target ? relationName : name, named.name, 'filter', named.locales);
+        }
+        // Only a direct store call or a language's own `authorize` reaches here; the
+        // lookup below would otherwise index `tables[undefined]`.
+        if (hop && !relationField?.target) {
+            throw new Error(`Kayan "${name}" field "${ownField}" names no relationship, so the path "${field}" reaches no second table.`);
+        }
+        // Typed as drizzle's comparison operators take, so `eq` resolves its untyped overload.
+        const column = hop ? tables[relationName][hop] : table[locale ?? field];
+        const own = conditionsOf(named?.kind === 'richText' ? textOf(column) : column, rules);
+        if (!hop) {
+            parts.push(own);
+            continue;
+        }
+        const target = tables[relationName];
+        const ids = db.select({ id: target.id }).from(target).where(own);
+        parts.push(inArray(table[ownField], ids));
+    }
+    return parts.length === 1 ? parts[0] : and(...parts);
+};
+const idWhere = (db, tables, kayanByName, name, id, where) => {
+    const table = tables[name];
+    const byId = eq(table.id, id);
+    return where ? and(byId, whereOf(db, tables, kayanByName, name, where)) : byId;
+};
+// A name no migration folder can carry: drizzle matches a folder to a history row by
+// `name` alone. It refuses the first migration against a database only ever pushed.
+export const devPushMarker = 'mithaq_dev_push';
+// A table of mithaq's own, so a default history table holding another tool's rows is
+// never read as this project's.
+export const migrationsTable = { schema: 'drizzle', table: '__mithaq_migrations' };
+// drizzle-kit filters tables by name across every schema in its filter, so a push would
+// drop another tool's table sharing a name with ours, rows and all. Refused by name first.
+export const refuseStrangers = async ({ db, tables, by }) => {
+    const built = Object.values(tables);
+    if (!built.length)
+        return;
+    const own = new Set(built.map((table) => `${schemaOf(table)}.${getTableName(table)}`));
+    const listed = (values) => sql.join([...new Set(values)].map((value) => sql `${value}`), sql `, `);
+    const { rows } = await db.execute(sql `select nspname, relname from pg_catalog.pg_class
+    join pg_catalog.pg_namespace on pg_namespace.oid = relnamespace
+    where relkind in ('r', 'p', 'v', 'm')
+      and nspname in (${listed(built.map(schemaOf))})
+      and relname in (${listed(built.map((table) => getTableName(table)))})`);
+    const found = rows.map((row) => `${row.nspname}.${row.relname}`).filter((pair) => !own.has(pair)).sort();
+    if (!found.length)
+        return;
+    const one = found.length === 1;
+    throw new Refusal(`${found.join(', ')} ${one ? 'is not a table' : 'are not tables'} of this language, and drizzle-kit filters tables by name across the schemas this language uses, so ${by === 'push' ? 'this push' : 'the first migration after this baseline'} would drop ${one ? 'it' : 'them'}. Rename the kayan's table, or move the other ${one ? 'table' : 'tables'}. Where ${one ? 'it is' : 'one is'} this language's own table from before a kayan's schemaName changed, run \`mithaq migrate\`, which asks whether that is a move; on a development database, drop its tables instead, or move the table by hand with \`ALTER TABLE … SET SCHEMA\`. Nothing was written.`);
+};
+const enumsOf = (tables) => {
+    const enums = Object.create(null);
+    for (const table of Object.values(tables)) {
+        for (const { enum: used } of Object.values(getTableColumns(table))) {
+            if (isPgEnum(used))
+                enums[`${used.schema ?? 'public'}.${used.enumName}`] = used;
+        }
+    }
+    return enums;
+};
+// Each schema and every enum already in those schemas is handed over: drizzle-kit
+// otherwise plans a `DROP` for what it is not handed, or throws asking about a rename.
+export const pushInput = ({ tables, schemas, held = [] }) => {
+    const enums = new Map(held.map(({ schema, name, labels }) => [`${schema}.${name}`, schema === 'public' ? pgEnum(name, labels) : schemas[schema].enum(name, labels)]));
+    for (const [key, used] of Object.entries(enumsOf(tables))) {
+        const schema = used.schema ?? 'public';
+        if (!(schema in schemas))
+            throw new Error(`A column uses the enum "${key}", in a schema no kayan is built in, so the push could not tell on its second run that it exists. Build the enum in the schemaName of a kayan.`);
+        const other = held.find((one) => one.schema === schema && one.name === used.enumName);
+        if (other && !other.owned && other.labels.join() !== used.enumValues.join()) {
+            throw new Error(`The enum "${schema}"."${used.enumName}" is already in the database with the labels ${other.labels.join(', ')}, and no table of this language uses it, so it is another tool's. Giving it the labels ${used.enumValues.join(', ')} would alter it. Give the column's enum another name or, if it is this language's own, left behind by a dropped table, drop the type with DROP TYPE "${schema}"."${used.enumName}".`);
+        }
+        enums.set(key, used);
+    }
+    return {
+        imports: {
+            ...tables,
+            ...Object.fromEntries(Object.entries(schemas).flatMap(([name, schema]) => (schema ? [[`${name}Schema`, schema]] : []))),
+            ...Object.fromEntries([...enums].map(([key, one]) => [`${key}Enum`, one])),
+        },
+        filter: {
+            schemas: Object.keys(schemas),
+            tables: Object.values(tables).map((table) => getTableName(table)),
+            entities: undefined,
+            extensions: [],
+        },
+    };
+};
+/** The history table as SQL, for the statements that read and write it. */
+export const historyTable = sql `${sql.identifier(migrationsTable.schema)}.${sql.identifier(migrationsTable.table)}`;
+/**
+ * The one lock every writer of the history takes, a production boot running drizzle's migrator
+ * and a connect making the table, since both create the `drizzle` schema. Keyed as a boot has
+ * always keyed it, so an instance of an older release booting beside this one still waits.
+ */
+export const historyLock = sql `select pg_advisory_xact_lock(hashtext(${`${migrationsTable.schema}.${migrationsTable.table}`}))`;
+// Under an advisory lock, because two connects against a fresh database both pass `if not exists`
+// and the loser fails on Postgres's unique index over schema names. The DDL is drizzle's own,
+// because mithaq writes into the table before drizzle does; any other shape would make the next
+// `drizzle-kit migrate` refuse every row.
+export const createHistory = (db) => db.transaction(async (tx) => {
+    await tx.execute(historyLock);
+    await tx.execute(sql `create schema if not exists ${sql.identifier(migrationsTable.schema)}`);
+    await tx.execute(sql `create table if not exists ${historyTable} (
+      id serial primary key,
+      hash text not null,
+      created_at bigint,
+      name text,
+      applied_at timestamp with time zone default now()
+    )`);
+});
+// One statement, so a run killed between a delete and an insert cannot leave the table
+// with neither: a data-modifying `with` runs once and to completion.
+export const recordMigration = async ({ db, hash, createdAt, name }) => {
+    await createHistory(db);
+    await db.execute(sql `with gone as (delete from ${historyTable} where name = ${devPushMarker})
+    insert into ${historyTable} (hash, created_at, name) values (${hash}, ${createdAt}, ${name})`);
+};
+/** The drizzle store target's maps: a map per kind and a map per rule. */
+export const drizzleTarget = { capability: 'store', type: 'drizzle', idKinds: drizzleIdKinds, kinds: drizzleKinds, rules: drizzleRules };
+export const drizzleAdapter = ({ db: ready, connectionString, kinds, rules, idKinds = drizzleIdKinds, push: named, prodMigrations, }) => {
+    if (prodMigrations && prodMigrations.pending !== 'run' && prodMigrations.pending !== 'refuse') {
+        throw new Error(`drizzleAdapter's prodMigrations.pending is 'run' or 'refuse', not ${JSON.stringify(prodMigrations.pending)}.`);
+    }
+    // `prodMigrations` is read only where the push is off, so beside `push: true` it would be unread.
+    if (named === true && prodMigrations) {
+        throw new Error("drizzleAdapter takes `push: true` or `prodMigrations`, never both: a production connect() reads prodMigrations only with the push off. Leave `push` out, which pushes outside production alone.");
+    }
+    const push = named ?? process.env.NODE_ENV !== 'production';
+    if (ready && connectionString) {
+        throw new Error('drizzleAdapter takes a `db` or a `connectionString`, never both.');
+    }
+    if (!ready && !connectionString) {
+        throw new Error('drizzleAdapter needs either a `db` or a `connectionString`.');
+    }
+    // Made here, not in `init`, so `asas.targets.drizzle.db` is reachable from the start;
+    // node-postgres opens no socket until the first query.
+    const opened = connectionString ? drizzle(connectionString) : undefined;
+    const db = ready ?? opened;
+    const config = { ready, opened, db, connectionString, kinds, rules, idKinds, push, prodMigrations };
+    // Each build gets a store of its own, so a refused or renamed kayan of one build is
+    // never in the next. Every one shares the one client.
+    const every = stateOf();
+    // A push or a diff of the merged tables would build or keep a table no build has.
+    const merged = () => {
+        throw new Refusal('The drizzle store the language holds keeps every build\'s tables merged, an earlier build\'s among them, so it neither pushes nor migrates them: connect a build, `asas.connect()`, or run the command on `asas.targets.drizzle`.');
+    };
+    const adapter = { ...storeOf({ ...config, state: every }), connect: async () => merged(), commands: { migrate: async () => merged() } };
+    adapter.init = function (kayanList) {
+        // A target that spreads this adapter and overrides a member would hand the build a store
+        // without the override: refused rather than dropped in silence.
+        if (this !== undefined && this !== adapter) {
+            throw new Error('A target wraps the drizzle store and not its init, and each build uses the store init returns, so what the wrapper overrides would reach no build. Return the wrapped store from init too.');
+        }
+        const state = stateOf();
+        const built = storeOf({ ...config, state });
+        built.init(kayanList);
+        Object.assign(every.tables, state.tables);
+        Object.assign(every.schemas, state.schemas);
+        Object.assign(every.enums, state.enums);
+        for (const [name, kayan] of state.kayanByName)
+            every.kayanByName.set(name, kayan);
+        return built;
+    };
+    return adapter;
+};
+/** What one store builds and reads by: its tables, their schemas and enums, and its kayan by table key. */
+const stateOf = () => ({
+    // No prototype, so no kayan or join table name finds an inherited answer.
+    tables: Object.create(null),
+    schemas: Object.create(null),
+    enums: Object.create(null),
+    kayanByName: new Map(),
+});
+const storeOf = ({ ready, opened, db, connectionString, kinds, rules, idKinds, push, prodMigrations, state }) => {
+    const { tables, schemas, enums, kayanByName } = state;
+    // `pgSchema('public')` throws, so `public` is `pgTable`. A kayan's join and versions
+    // tables are built in its own table's schema.
+    const tableIn = (schemaName) => schemaName === undefined || schemaName === 'public' ? pgTable : (schemas[schemaName] ??= pgSchema(schemaName)).table;
+    /** The fields of one kayan that this store holds as several columns. */
+    const localizedOf = (name) => {
+        const kayan = kayanByName.get(name);
+        return Object.values(kayan?.fields ?? {}).filter((field) => field.rules?.localized && !field.targets?.[kayan.store]);
+    };
+    // A field the write names is written whole, every locale column of it, so no write reads the row first.
+    const flatten = (name, values) => {
+        const fields = localizedOf(name);
+        if (!fields.length)
+            return values;
+        const flat = { ...values };
+        for (const field of fields) {
+            if (!(field.name in flat))
+                continue;
+            const given = flat[field.name];
+            delete flat[field.name];
+            for (const locale of field.locales)
+                flat[`${field.name}_${locale}`] = given?.[locale] ?? null;
+        }
+        return flat;
+    };
+    // A field whose every locale column is null is one null, which matches the derived row shape.
+    const expand = (name, row) => {
+        const fields = localizedOf(name);
+        if (!fields.length)
+            return row;
+        const held = { ...row };
+        for (const field of fields) {
+            const keys = field.locales.map((locale) => `${field.name}_${locale}`);
+            if (!keys.some((key) => key in held))
+                continue;
+            const value = Object.fromEntries(field.locales.map((locale, at) => [locale, held[keys[at]] ?? null]));
+            for (const key of keys)
+                delete held[key];
+            held[field.name] = Object.values(value).every((one) => one === null) ? null : value;
+        }
+        return held;
+    };
+    // A field the write does not name is left alone, so a soft delete never touches a set.
+    const withoutSets = (name, values) => {
+        const fields = manyFields(kayanByName.get(name));
+        if (!fields.length)
+            return { columns: values, sets: {} };
+        const columns = { ...values };
+        const sets = Object.create(null);
+        for (const field of fields) {
+            if (!(field.name in columns))
+                continue;
+            const given = columns[field.name];
+            delete columns[field.name];
+            // `null` is the empty set written out.
+            sets[field.name] = Array.isArray(given) ? given : [];
+        }
+        return { columns, sets };
+    };
+    // The whole array replaces the set. Deduplicated: two join rows for one pair would read
+    // back as the id twice.
+    const writeSets = async (tx, name, id, sets) => {
+        const kayan = kayanByName.get(name);
+        for (const [field, given] of Object.entries(sets)) {
+            const join = tables[joinTableOf(kayan, kayan.fields[field])];
+            await tx.delete(join).where(eq(join.parent, id));
+            const values = [...new Set(given)].map((target, at) => ({ parent: id, target, order: at }));
+            if (values.length)
+                await tx.insert(join).values(values);
+        }
+    };
+    // One query per `hasMany` field however many rows are asked about. A row with no join
+    // row gets the empty array, so the key is always there.
+    const readSets = async (client, name, ids) => {
+        const kayan = kayanByName.get(name);
+        const fields = manyFields(kayan);
+        const held = new Map(ids.map((id) => [String(id), Object.fromEntries(fields.map((field) => [field.name, []]))]));
+        if (!fields.length || !ids.length)
+            return held;
+        for (const field of fields) {
+            const join = tables[joinTableOf(kayan, field)];
+            const rows = await client
+                .select()
+                .from(join)
+                .where(inArray(join.parent, ids))
+                .orderBy(asc(join.order));
+            for (const row of rows) {
+                held.get(String(row.parent))?.[field.name].push(row.target);
+            }
+        }
+        return held;
+    };
+    /** One row, with its sets read back off the join tables beside its columns. */
+    const withSets = async (client, name, row) => {
+        if (!manyFields(kayanByName.get(name)).length)
+            return row;
+        const held = await readSets(client, name, [row.id]);
+        return { ...row, ...held.get(String(row.id)) };
+    };
+    return {
+        capability: 'store',
+        type: 'drizzle',
+        sql: 'drizzle',
+        idKinds,
+        kinds,
+        rules,
+        db,
+        tables,
+        schemas,
+        enums,
+        connectionString,
+        commands: {
+            // Imported here, so an app that never migrates loads neither `node:child_process` nor `drizzle-kit`.
+            migrate: async ({ flags }) => (await import('./migrate.js')).run({ target: { db, tables, schemas, enums, connectionString, kayan: [...kayanByName.values()] }, flags }),
+        },
+        init(kayanList) {
+            const indexNames = [];
+            for (const kayan of kayanList) {
+                kayanByName.set(kayan.name, kayan);
+                // Under the kayan's own store's name, whatever the build calls it.
+                const override = kayan.targets?.[kayan.store];
+                if (override && kayan.schemaName !== undefined) {
+                    throw new Error(`Kayan "${kayan.name}" writes schemaName beside a whole-table targets.drizzle, which names its own schema through its own pgSchema. Remove one of the two.`);
+                }
+                if (override && kayan.indexes.length) {
+                    throw new Error(`Kayan "${kayan.name}" asks for indexes, its own or a unique field's, beside a whole-table targets.drizzle, which builds its own table and its indexes in its third argument. Build them there, and write indexes: () => [].`);
+                }
+                if (override) {
+                    tables[kayan.name] = override;
+                    continue;
+                }
+                const refused = kayan.schemaName === undefined ? undefined : refusedSchema(kayan.schemaName);
+                if (refused) {
+                    throw new Error(`Kayan "${kayan.name}" asks for the schema ${JSON.stringify(kayan.schemaName)}, ${refused} Give the kayan another schemaName.`);
+                }
+                const built = Object.create(null);
+                const columns = Object.values(kayan.fields).flatMap(columnsOfField(kayan.store));
+                // `pgTable` keys on the field name, so a localized `title` and a plain `titleAr` would
+                // both ask for `title_ar` and one field would end with no column.
+                const asked = new Set();
+                const keyed = new Set();
+                for (const field of columns) {
+                    if (asked.has(field.column)) {
+                        throw new Error(`Kayan "${kayan.name}" field "${field.name}" asks for column "${field.column}", which another field of the same kayan already holds. Rename one of the two, or give one a dbName of its own.`);
+                    }
+                    // A `dbName` walks a plain field past the guard above while leaving its table key,
+                    // which would overwrite the locale's entry.
+                    if (keyed.has(field.name)) {
+                        throw new Error(`Kayan "${kayan.name}" field "${field.name}" asks for the table key "${field.name}", which another field of the same kayan already holds. Rename one of the two; a dbName changes the column and not this key.`);
+                    }
+                    asked.add(field.column);
+                    keyed.add(field.name);
+                }
+                for (const field of columns) {
+                    // The field's entry under its kayan's own store is the whole column, rules skipped.
+                    if (field.targets?.[kayan.store]) {
+                        built[field.name] = field.targets[kayan.store];
+                        continue;
+                    }
+                    // A kayan that keeps drafts makes a row before its rules hold, so no client column
+                    // carries a length or a precision; the runner holds a publish to the rules instead.
+                    const drafted = kayan.versions?.drafts && providerOf(field, 'create') === 'client';
+                    // The project's own entry, then the kind's own, then the shipped table.
+                    const build = implementationOf({ table: kinds, shipped: drizzleKinds, name: field.kind, own: field.kindTargets, type: 'drizzle' });
+                    let column = modifiable(build(drafted ? { ...field, rules: { ...field.rules, maxLength: undefined, precision: undefined, scale: undefined } } : field, tables));
+                    if (field.name === 'id') {
+                        column = rules.primary({ column, value: undefined, field });
+                    }
+                    for (const [rule, apply] of Object.entries(rules)) {
+                        // A draft is made before its rules hold, so no client column is `not null`; the runner
+                        // holds a published row to `required` instead.
+                        if (rule === 'required' && drafted)
+                            continue;
+                        if (rule in (field.rules ?? {})) {
+                            column = apply({ column, value: field.rules[rule], field });
+                        }
+                    }
+                    built[field.name] = column;
+                }
+                const indexed = columns.filter((field) => field.rules?.index);
+                // A unique rule's own index over one column is that column's UNIQUE, the constraint a unique
+                // field has always built, so a shared kayan's table is the one it was.
+                const ownUnique = (index) => uniqueRuleIndexes.has(index) && index.fields.length === 1;
+                for (const index of kayan.indexes.filter(ownUnique))
+                    built[index.fields[0]] = built[index.fields[0]].unique();
+                // Named `<table>_<columns>_idx`, the same on every build whatever the kayan order; a
+                // name past 63 bytes is refused, not cut short as Postgres would cut it in silence.
+                // `nullsNotDistinct` is a unique constraint: drizzle's pg index builder has no NULLS NOT DISTINCT.
+                const compound = kayan.indexes.flatMap((index, at) => {
+                    if (ownUnique(index))
+                        return [];
+                    const { fields, unique, nullsNotDistinct } = index;
+                    const name = `${kayan.table}_${fields.map((field) => kayan.fields[field].column).join('_')}_${nullsNotDistinct ? 'unique' : 'idx'}`;
+                    if (!isPlainIdentifier(name)) {
+                        throw new Error(`Kayan "${kayan.name}" indexes[${at}] is named ${JSON.stringify(name)}, which is longer than the 63 bytes Postgres keeps of a name, or holds a character other than a letter, a digit or an underscore. Give the kayan or its fields a shorter dbName.`);
+                    }
+                    indexNames.push({ where: `Kayan "${kayan.name}" indexes[${at}]`, kayan: kayan.name, name });
+                    return [{ name, fields, unique, nullsNotDistinct }];
+                });
+                tables[kayan.name] = tableIn(kayan.schemaName)(kayan.table, built, (table) => [
+                    ...indexed.map((field) => index().on(table[field.name])),
+                    ...compound.map(({ name, fields: [first, ...rest], unique, nullsNotDistinct }) => {
+                        const on = [table[first], ...rest.map((field) => table[field])];
+                        return nullsNotDistinct ? uniqueConstraint(name).on(...on).nullsNotDistinct() : (unique ? uniqueIndex : index)(name).on(...on);
+                    }),
+                ]);
+            }
+            // In a pass of their own, so the collision check below sees every kayan's own key.
+            for (const kayan of kayanList) {
+                for (const field of manyFields(kayan)) {
+                    const name = joinTableOf(kayan, field);
+                    if (tables[name]) {
+                        throw new Error(`Kayan "${kayan.name}" field "${field.name}" needs the join table "${name}", which is already the table of kayan "${name}". Rename one of the two, or give the kayan a dbName of its own.`);
+                    }
+                    // Each end takes the type of the id it points at. `cascade` on both: the row belongs to
+                    // the pair. An upload's own builder answers `restrict`.
+                    const reference = (build, column, target) => modifiable(build({ ...field, name: column, column: `${column}_id`, target, rules: { onDelete: 'cascade' } }, tables)).notNull();
+                    // Named, so the check below holds them to the schema's one namespace.
+                    const key = `${name}_pkey`;
+                    const targetIndex = `${name}_target_id_index`;
+                    // A name that is no plain identifier is refused below, so only the length is left here.
+                    for (const [what, named] of [['key', key], ['index', targetIndex]]) {
+                        if (isPlainIdentifier(name) && !isPlainIdentifier(named)) {
+                            throw new Error(`Kayan "${kayan.name}" field "${field.name}" builds the join table "${name}", whose ${what} "${named}" is longer than the 63 bytes Postgres keeps of a name. Rename the field, or give the kayan a shorter dbName.`);
+                        }
+                        indexNames.push({ where: `Kayan "${kayan.name}" field "${field.name}" join table ${what}`, kayan: kayan.name, name: named });
+                    }
+                    tables[name] = tableIn(schemaOf(tables[kayan.name]))(name, {
+                        parent: reference(kinds.relationship, 'parent', kayan),
+                        target: reference(implementationOf({ table: kinds, shipped: drizzleKinds, name: field.kind, own: field.kindTargets, type: 'drizzle' }), 'target', field.target),
+                        // The only order a set of ids has.
+                        order: pgInteger('order').notNull(),
+                    }, (table) => [
+                        primaryKey({ name: key, columns: [table.parent, table.order] }),
+                        index().on(table.parent),
+                        index(targetIndex).on(table.target),
+                    ]);
+                }
+            }
+            // The name must not be a table already built.
+            for (const kayan of kayanList) {
+                if (!kayan.versions)
+                    continue;
+                const name = versionsTableOf(kayan);
+                if (tables[name]) {
+                    throw new Error(`Kayan "${kayan.name}" keeps versions in the table "${name}", which is already the table of kayan "${name}". Rename one of the two, or give the kayan a dbName of its own.`);
+                }
+                // So a filter naming `parent` reaches the row it belongs to.
+                kayanByName.set(name, kayan.versions.kayan);
+                const moment = (column) => timestamp(column, { precision: 3, withTimezone: true, mode: 'date' }).notNull().defaultNow();
+                // The row it belongs to cascades: deleting the row deletes its versions, and a soft delete keeps them.
+                tables[name] = tableIn(schemaOf(tables[kayan.name]))(name, {
+                    id: pgUuid('id').defaultRandom().primaryKey(),
+                    parent: modifiable(kinds.relationship({ ...kayan.versions.kayan.fields.parent, rules: { onDelete: 'cascade' } }, tables)).notNull(),
+                    version: jsonb('version').notNull(),
+                    latest: pgBoolean('latest').notNull().default(false),
+                    autosave: pgBoolean('autosave').notNull().default(false),
+                    createdAt: moment('created_at'),
+                    updatedAt: moment('updated_at'),
+                }, (table) => [index().on(table.parent), index().on(table.latest)]);
+            }
+            // Every name the push and the pull hand drizzle-kit as a glob passes here once, built.
+            for (const [key, table] of Object.entries(tables)) {
+                const name = getTableName(table);
+                if (typeof name !== 'string' || isPlainIdentifier(name))
+                    continue;
+                const made = kayanList.flatMap((kayan) => [
+                    ...manyFields(kayan)
+                        .filter((field) => joinTableOf(kayan, field) === name)
+                        .map((field) => [`Kayan "${kayan.name}" field "${field.name}" builds the join table`, 'Rename the field.']),
+                    ...(kayan.versions && versionsTableOf(kayan) === name
+                        ? [[`Kayan "${kayan.name}" builds the versions table`, 'Give the kayan a shorter dbName.']]
+                        : []),
+                ])[0] ?? [`Kayan "${key}" whole-table targets.drizzle is the table`, 'Rename the table in targets.drizzle.'];
+                throw new Error(`${made[0]} ${JSON.stringify(name)}, which is not a plain SQL identifier: letters, digits and underscores, not starting with a digit, at most 63 bytes. ${made[1]}`);
+            }
+            // Postgres keeps tables and indexes under one name per schema, so a kayan index named as
+            // a table or another index would pass the build and fail the migration.
+            const named = new Map();
+            for (const table of Object.values(tables)) {
+                const name = getTableName(table);
+                if (typeof name === 'string')
+                    named.set(`${schemaOf(table)}.${name}`, `the table "${name}"`);
+            }
+            for (const { where, kayan, name } of indexNames) {
+                const schema = schemaOf(tables[kayan]);
+                const taken = named.get(`${schema}.${name}`);
+                if (taken) {
+                    throw new Error(`${where} is named "${name}", which is already ${taken} in the schema "${schema}", and Postgres keeps one name per schema for tables and indexes alike. Rename one of the two through a dbName.`);
+                }
+                named.set(`${schema}.${name}`, `the name of ${where.replace('Kayan ', 'kayan ')}`);
+            }
+            // Read off every table built, so a whole-table override in its own `pgSchema` is held to the same rule.
+            for (const [key, table] of Object.entries(tables)) {
+                if (typeof getTableName(table) !== 'string')
+                    continue;
+                const name = schemaOf(table);
+                const refused = refusedSchema(name);
+                if (refused)
+                    throw new Error(`Kayan "${key}" whole-table targets.drizzle is built in the schema ${JSON.stringify(name)}, ${refused} Build it in another schema.`);
+                if (!(name in schemas))
+                    schemas[name] = name === 'public' ? null : pgSchema(name);
+            }
+            for (const name of Object.keys(schemas)) {
+                if (name !== 'public' && `${name}Schema` in tables) {
+                    throw new Error(`The table key "${name}Schema" is the name the schema module exports the schema "${name}" by. Rename the kayan.`);
+                }
+            }
+            Object.assign(enums, enumsOf(tables));
+        },
+        async connect({ readOnly } = {}) {
+            // The `devPushMarker` row tells a pushed database from a migrated one, since `push` writes
+            // no history; without it the first `mithaq migrate` would recreate every table.
+            if (readOnly)
+                return;
+            if (!push) {
+                // Outside production nothing is checked: the dev push is that path.
+                if (process.env.NODE_ENV === 'production')
+                    await (await import('./migrate.js')).bootMigrations({ db, prodMigrations });
+                return;
+            }
+            // Without the filter a table the kayan do not describe would be dropped. drizzle-kit reads
+            // an empty filter as none, so no tables means nothing to push.
+            const tablesFilter = Object.values(tables).map((table) => getTableName(table));
+            if (!tablesFilter.length)
+                return;
+            await refuseStrangers({ db, tables, by: 'push' });
+            // `drizzle-kit/api-postgres` imports every driver drizzle speaks, so webpack and Turbopack
+            // are told to leave the import to the runtime.
+            const { pushSchema } = await import(/* webpackIgnore: true */ 'drizzle-kit/api-postgres');
+            // `owned`: a column of a table of the language has the type, which makes it the language's own.
+            const listed = (values) => sql.join(values.map((value) => sql `${value}`), sql `, `);
+            const { rows } = await db.execute(sql `select nspname as schema, typname as name, array_agg(enumlabel::text order by enumsortorder) as labels,
+          exists (select 1 from pg_catalog.pg_attribute
+            join pg_catalog.pg_class on pg_class.oid = attrelid
+            join pg_catalog.pg_namespace as tables on tables.oid = relnamespace
+            where atttypid in (pg_type.oid, pg_type.typarray) and not attisdropped and tables.nspname in (${listed(Object.keys(schemas))}) and relname in (${listed(tablesFilter)})) as owned
+        from pg_catalog.pg_enum
+        join pg_catalog.pg_type on pg_type.oid = enumtypid
+        join pg_catalog.pg_namespace on pg_namespace.oid = typnamespace
+        where nspname in (${listed(Object.keys(schemas))})
+        group by nspname, typname, pg_type.oid`);
+            const { imports, filter } = pushInput({ tables, schemas, held: rows });
+            let planned;
+            try {
+                planned = await pushSchema(imports, db, filter);
+            }
+            catch (error) {
+                // A rename is a question drizzle-kit asks through hints the push cannot answer, and it throws.
+                if (error instanceof Error && error.message.includes('was called without a HintsHandler')) {
+                    throw new Error("The push met a rename it cannot ask about, such as a field's column renamed. Run `mithaq migrate`, which asks, or drop the dev database's tables.", { cause: error });
+                }
+                throw error;
+            }
+            const { sqlStatements, hints } = planned;
+            // Refused outright: there is no terminal to answer in a test or a deploy, and a silent
+            // yes is how a column goes missing.
+            const dataLoss = hints.filter(({ statement }) => statement);
+            if (dataLoss.length) {
+                throw new Error(`Refusing to push the schema, because it would lose data:\n\n${dataLoss.map(({ hint }) => hint).join('\n')}`);
+            }
+            if (hints.length)
+                console.warn(`Schema push warnings:\n${hints.map(({ hint }) => hint).join('\n')}`);
+            // The drop is held back below, so recreating an enum would fail on a type that exists.
+            for (const statement of sqlStatements) {
+                const dropped = /^DROP TYPE (?:"(.+)"\.)?"(.+)";$/.exec(statement);
+                if (dropped && sqlStatements.some((one) => one.startsWith(`CREATE TYPE ${statement.slice(10, -1)} `))) {
+                    throw new Error(`The push would recreate the enum "${dropped[1] ?? 'public'}"."${dropped[2]}", because a label of it was removed or reordered, and it never drops a type. Drop the dev table and the type with DROP TYPE "${dropped[1] ?? 'public'}"."${dropped[2]}", or keep the labels as they are. Nothing was written.`);
+                }
+            }
+            // drizzle-kit plans to drop every enum, sequence and schema it is not handed, another
+            // tool's included, so no `DROP TYPE`, `DROP SEQUENCE` or `DROP SCHEMA` runs.
+            const statements = sqlStatements.filter((statement) => !/^DROP (TYPE|SEQUENCE|SCHEMA) /.test(statement));
+            // drizzle-kit's own `apply` runs statement by statement with no transaction; Postgres
+            // DDL is transactional, so the push and its marker commit together or not at all.
+            // The history lock before any table lock, the order a boot takes them in, so the two never deadlock.
+            await db.transaction(async (tx) => {
+                await tx.execute(historyLock);
+                for (const statement of statements)
+                    await tx.execute(sql.raw(statement));
+                // Deleted and written again, so the marker stays one row.
+                await recordMigration({ db: tx, hash: devPushMarker, createdAt: Date.now(), name: devPushMarker });
+            });
+        },
+        // Kept as drizzle's own callback: the runner passes `tx` down the list.
+        async transaction(run) {
+            return db.transaction((tx) => run(tx));
+        },
+        async insert({ tx, kayan: name, data: values }) {
+            const { columns, sets } = withoutSets(name, values);
+            let result;
+            try {
+                result = await tx.insert(tables[name]).values(flatten(name, columns)).returning();
+            }
+            catch (thrown) {
+                throw collision(thrown, name);
+            }
+            if (!Array.isArray(result))
+                throw new Error('The drizzle store expected insert to return rows.');
+            const [row] = result;
+            const held = expand(name, row);
+            // In the write's own transaction, so a set that cannot be written takes its row down.
+            await writeSets(tx, name, held.id, sets);
+            return withSets(tx, name, held);
+        },
+        async update({ tx, kayan: name, id, data: values, where }) {
+            const { columns, sets } = withoutSets(name, values);
+            const flat = flatten(name, columns);
+            const matched = idWhere(tx, tables, kayanByName, name, id, where);
+            let result;
+            try {
+                // drizzle refuses an empty `set`, so a write naming only sets locks the row instead.
+                result = Object.keys(flat).length
+                    ? await tx.update(tables[name]).set(flat).where(matched).returning()
+                    : await tx.select().from(tables[name]).where(matched).for('update');
+            }
+            catch (thrown) {
+                throw collision(thrown, name);
+            }
+            if (!Array.isArray(result))
+                throw new Error('The drizzle store expected update to return rows.');
+            const [row] = result;
+            // An update that matched nothing did not happen; an `undefined` row answer would hide it.
+            if (!row)
+                throw new Error(`No "${name}" row with id ${String(id)} to update.`);
+            const held = expand(name, row);
+            // After the row, so a `where` that admitted no row refuses before any set is touched.
+            await writeSets(tx, name, held.id, sets);
+            return withSets(tx, name, held);
+        },
+        async remove({ tx, kayan: name, id, where }) {
+            // Read before the delete: the join rows cascade with it.
+            const sets = await withSets(tx, name, { id });
+            let result;
+            try {
+                result = await tx
+                    .delete(tables[name])
+                    .where(idWhere(tx, tables, kayanByName, name, id, where))
+                    .returning();
+            }
+            catch (thrown) {
+                throw referenced({ thrown, name, kayans: kayanByName, tables });
+            }
+            if (!Array.isArray(result))
+                throw new Error('The drizzle store expected delete to return rows.');
+            const [row] = result;
+            if (!row)
+                throw new Error(`No "${name}" row with id ${String(id)} to delete.`);
+            return { ...sets, ...expand(name, row) };
+        },
+        async find({ kayan: name, args: { limit, lock, page, sort, where }, tx }) {
+            const client = (tx ?? db);
+            const table = tables[name];
+            if (kayanByName.get(name)?.fields[sort.field]?.rules?.localized) {
+                throw refuseLocalized(name, sort.field, 'sort');
+            }
+            const condition = where ? whereOf(client, tables, kayanByName, name, where) : undefined;
+            const column = table[sort.field];
+            const id = table.id;
+            const direction = sort.direction === 'desc' ? desc : asc;
+            // Each clause only for a column the table has: a table override may lack `id`, and a
+            // clause from the absent column is a syntax error. The unique id makes page boundaries total.
+            const orderBy = [
+                ...(column ? [direction(column)] : []),
+                ...(id && sort.field !== 'id' ? [direction(id)] : []),
+            ];
+            const offset = limit > 0 ? (page - 1) * limit : 0;
+            // `$dynamic()` keeps each branch one type, so drizzle checks `orderBy` against the table.
+            const query = client.select().from(table).$dynamic().where(condition);
+            const locked = tx && lock === 'update' ? query.for('update') : query;
+            const ordered = locked.orderBy(...orderBy).offset(offset);
+            const docs = limit > 0 ? await ordered.limit(limit) : await ordered;
+            const rows = await client.select({ totalDocs: sqlCount() }).from(table).where(condition);
+            const held = docs.map((row) => expand(name, row));
+            const sets = await readSets(client, name, held.map((row) => row.id));
+            return {
+                docs: held.map((row) => ({ ...row, ...sets.get(String(row.id)) })),
+                totalDocs: Number(rows[0]?.totalDocs ?? 0),
+            };
+        },
+        async count({ kayan: name, args: { where }, tx }) {
+            const client = (tx ?? db);
+            // The relationship filters use subqueries, so there are no joins to deduplicate.
+            const rows = await client.select({ totalDocs: sqlCount() }).from(tables[name]).where(where ? whereOf(client, tables, kayanByName, name, where) : undefined);
+            return Number(rows[0]?.totalDocs ?? 0);
+        },
+        async destroy() {
+            // Only a pool this adapter opened: a `db` the developer passed is theirs to end.
+            if (ready)
+                return;
+            await opened.$client.end();
+        },
+    };
+};