@deterministic-code/datasources-cli 0.0.0-stage → 0.1.2

package/node_modules/@deterministic-code/datasources-code-generators/dist/sql/common/generate-procedures.js

@@ -0,0 +1,106 @@
+import { content } from "@deterministic-code/generators-common/generate-entry";
+import { DeterministicParser } from "@deterministic-code/deterministic-generators-common/parser";
+import { pkName } from "@deterministic-code/generators-common/spec-types";
+import { createCasing } from "./default-casing.js";
+import { byGroupsFromDatasource } from "./datasource-by-fields.js";
+import { SqlMapping } from "./sql-mapping.js";
+import { mapColumnType, q, renderSql } from "./sql-dialect.js";
+import { buildLiveTables, datasourceSettings, hasAuditColumns, overlayOf, sqlTablesFrom, } from "./sql-schema.js";
+import { procedureSpecs } from "./procedures/driver.js";
+import { createParamFields, pkFieldOf, writableNonAuditFields, } from "./procedures/helpers.js";
+import { createBulkCreateStoredProcedureOf, createBulkDeleteStoredProcedureOf, createBulkUpdateStoredProcedureOf, createCreateStoredProcedureOf, createDeleteStoredProcedureOf, createReadStoredProcedureOf, createUpdateStoredProcedureOf, dropRoutineStatementOf, } from "../statements.js";
+const withNl = (text, casing) => {
+    const out = casing.applyKeywords(text);
+    return out.endsWith("\n") ? out : `${out}\n`;
+};
+const pad = (n) => String(n).padStart(4, "0");
+const payloadType = (dialect) => ({
+    mysql: "JSON",
+    postgres: "jsonb",
+    sqlserver: "NVARCHAR(MAX)",
+    oracle: "CLOB",
+}[dialect] ?? "JSON");
+/** Create / read / update / delete / bulk procedure statements for one live table. */
+export const procedureStatementsForTable = (dialect, t, mapping, casing, groups) => {
+    const table = {
+        name: t.tableName,
+        entityName: t.name,
+        fields: t.fields.map((f) => ({ name: f.name, type: f.type })),
+        pkName: pkName(t, overlayOf(t)),
+    };
+    const pk = pkFieldOf(table);
+    const columnName = (logical) => mapping.columnName(t, logical);
+    const columns = table.fields.map((f) => columnName(f.name));
+    const writable = writableNonAuditFields(table).map((f) => columnName(f.name));
+    const paramType = (field) => mapColumnType(dialect, field);
+    const createdParams = createParamFields(table).map((f) => ({
+        name: columnName(f.name),
+        type: paramType(f),
+    }));
+    const typedColumns = table.fields.map((f) => ({ name: columnName(f.name), type: paramType(f) }));
+    const payload = { name: "payload", type: payloadType(dialect) };
+    const key = columnName(pk.name);
+    const keyType = paramType(pk);
+    const audit = table.fields.some((f) => f.name === "updated") ? columnName("updated") : undefined;
+    const generatedKey = pk.type === "uuid";
+    const quoted = q(dialect, t.tableName);
+    const statements = [];
+    const names = [];
+    for (const proc of procedureSpecs(t.name, groups, casing)) {
+        names.push(proc.name);
+        const by = proc.byProperties.map(columnName);
+        const byParams = proc.byProperties.map((logical) => {
+            const field = table.fields.find((f) => f.name === logical) ?? pk;
+            return { name: columnName(field.name), type: paramType(field) };
+        });
+        const updateParams = [
+            ...byParams,
+            ...writableNonAuditFields(table)
+                .filter((f) => !proc.byProperties.includes(f.name))
+                .map((f) => ({ name: columnName(f.name), type: paramType(f) })),
+            ...(audit === undefined ? [] : [{ name: columnName("new_updated"), type: paramType(table.fields.find((f) => f.name === "updated")) }]),
+        ];
+        statements.push(({
+            create: () => createCreateStoredProcedureOf(proc.name, quoted, columns, createdParams, key, keyType, writable, generatedKey, audit),
+            read: () => createReadStoredProcedureOf(proc.name, quoted, columns, byParams, key, keyType, writable, by, generatedKey, audit),
+            update: () => createUpdateStoredProcedureOf(proc.name, quoted, columns, updateParams, key, keyType, writable, by, generatedKey, audit),
+            delete: () => createDeleteStoredProcedureOf(proc.name, quoted, columns, byParams, key, keyType, writable, by, generatedKey, audit),
+            bulkCreate: () => createBulkCreateStoredProcedureOf(proc.name, quoted, typedColumns, payload, key, keyType),
+            bulkUpdate: () => createBulkUpdateStoredProcedureOf(proc.name, quoted, typedColumns, payload, key, keyType),
+            bulkDelete: () => createBulkDeleteStoredProcedureOf(proc.name, quoted, typedColumns, payload, key, keyType),
+        }[proc.op])());
+    }
+    return { statements, names };
+};
+/** Stored-procedure migration — empty when the driver does not render routines. */
+export const generateProceduresForDialect = async (dialect, ctx, order = 2) => {
+    if (!datasourceSettings(ctx.settings).useStoredProcedures)
+        return [];
+    const spec = await DeterministicParser(ctx.reader).parse(ctx.settings);
+    const types = sqlTablesFrom(spec);
+    const casing = createCasing(ctx.settings);
+    const mapping = new SqlMapping(casing, types);
+    const tables = buildLiveTables(types, mapping).filter(hasAuditColumns);
+    if (tables.length === 0)
+        return [];
+    const byGroups = byGroupsFromDatasource(types);
+    const bodies = [];
+    const drops = [];
+    for (const t of tables) {
+        const { statements, names } = procedureStatementsForTable(dialect, t, mapping, casing, byGroups.get(t.name) ?? []);
+        const created = statements.map((statement) => renderSql(dialect, statement)).filter((sql) => sql !== "");
+        for (const name of names) {
+            const drop = renderSql(dialect, dropRoutineStatementOf(name));
+            if (drop !== "")
+                drops.push(drop);
+        }
+        if (created.length > 0)
+            bodies.push(`-- ${t.name}\n\n${created.join("\n\n")}`);
+    }
+    if (bodies.length === 0)
+        return [];
+    return [
+        content(`${dialect}/migrations/${pad(order)}_stored_procedures_up.sql`, withNl(`-- Stored procedures\n${bodies.join("\n\n")}`, casing)),
+        content(`${dialect}/migrations/${pad(order)}_stored_procedures_down.sql`, withNl(`-- DROP stored procedures\n${drops.join("\n")}`, casing)),
+    ];
+};

package/node_modules/@deterministic-code/datasources-code-generators/dist/sql/common/generate-sql.d.ts

@@ -0,0 +1,5 @@
+import type { GenerateContext } from "@deterministic-code/generators-common/generate-context";
+import { type GenerateEntry } from "@deterministic-code/generators-common/generate-entry";
+import { type SqlDialect } from "./sql-dialect.js";
+/** DDL initial migration (+ optional custom migrations and stored procedures) for one SQL dialect. */
+export declare const generateSqlFor: (dialect: SqlDialect, ctx: GenerateContext) => Promise<GenerateEntry[]>;

package/node_modules/@deterministic-code/datasources-code-generators/dist/sql/common/generate-sql.js

@@ -0,0 +1,116 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import { content } from "@deterministic-code/generators-common/generate-entry";
+import { DeterministicParser } from "@deterministic-code/deterministic-generators-common/parser";
+import { pkName } from "@deterministic-code/generators-common/spec-types";
+import { createCasing } from "./default-casing.js";
+import { SqlMapping } from "./sql-mapping.js";
+import { buildLiveTables, hasAuditColumns, overlayOf, sqlTablesFrom, } from "./sql-schema.js";
+import { renderSql, requireDialect } from "./sql-dialect.js";
+import { buildCustomMigrationFiles } from "./generate-custom-migrations.js";
+import { generateProceduresForDialect } from "./generate-procedures.js";
+import { seedSections } from "./seed-generator.js";
+import { versionDiffPaths, versionMigrationFiles } from "./version-migrations.js";
+import { migrationDownTmpl, migrationUpTmpl } from "../resources/sql.js";
+import { createIndexStatementOf, createTableStatementOf, createTriggerStatementOf, dropTableStatementOf, } from "../statements.js";
+const finalizeSql = (text, casing) => {
+    const out = casing.applyKeywords(text.replace(/\n{3,}/g, "\n\n"));
+    return out.endsWith("\n") ? out : `${out}\n`;
+};
+const flattenTable = (dialect, table, mapping) => {
+    const indexes = table.indexes.map((idx) => renderSql(dialect, createIndexStatementOf(dialect, mapping, table, idx)));
+    const live = { ...table, pkName: pkName(table, overlayOf(table)) };
+    const audit = hasAuditColumns(table)
+        ? renderSql(dialect, createTriggerStatementOf(dialect, live, mapping, live.pkName ?? "id"))
+        : "";
+    return {
+        createTable: renderSql(dialect, createTableStatementOf(dialect, table, mapping)),
+        indexesBlock: indexes.join("\n"),
+        trigger: audit,
+    };
+};
+const generateInitialMigration = (language, types, seedsByTable, casing) => {
+    const dialect = requireDialect(language);
+    const mapping = new SqlMapping(casing, types);
+    const live = buildLiveTables(types, mapping);
+    const seeds = seedSections(dialect, live, seedsByTable, mapping);
+    return {
+        up: {
+            path: "0001_initial_up.sql",
+            content: finalizeSql(fill(migrationUpTmpl, {
+                dialect,
+                preamble: "",
+                tables: live.map((t) => flattenTable(dialect, t, mapping)),
+                hasSeeds: seeds.length > 0,
+                seedBlocks: seeds,
+            }), casing),
+        },
+        down: {
+            path: "0001_initial_down.sql",
+            content: finalizeSql(fill(migrationDownTmpl, {
+                dialect,
+                dropStatements: [...live]
+                    .reverse()
+                    .map((t) => renderSql(dialect, dropTableStatementOf(dialect, t.tableName))),
+            }), casing),
+        },
+    };
+};
+const customEntries = async (dialect, deterministicDir) => {
+    if (!deterministicDir)
+        return [];
+    const files = await buildCustomMigrationFiles(deterministicDir, dialect);
+    const seen = new Set();
+    for (const { filename } of files) {
+        if (seen.has(filename)) {
+            throw new Error(`custom migration filename collision for dialect '${dialect}': ${filename} is generated by both an included datasource and this project`);
+        }
+        seen.add(filename);
+    }
+    return files.map((file) => content(`${dialect}/migrations/${file.filename}`, file.content));
+};
+const loadSchema = async (ctx) => {
+    const spec = await DeterministicParser(ctx.reader).parse(ctx.settings);
+    return {
+        types: sqlTablesFrom(spec),
+        seeds: spec.datasourceSeeds,
+    };
+};
+/** DDL initial migration (+ optional custom migrations and stored procedures) for one SQL dialect. */
+export const generateSqlFor = async (dialect, ctx) => {
+    const key = requireDialect(dialect);
+    const casing = createCasing(ctx.settings);
+    const dir = ctx.settings["paths.deterministic"];
+    const schema = await schemaFiles(key, ctx, casing);
+    return [
+        ...schema.entries,
+        ...(await customEntries(key, dir)),
+        ...(await generateProceduresForDialect(dialect, ctx, schema.count + 1)),
+    ];
+};
+const schemaFiles = async (key, ctx, casing) => {
+    if (versionDiffPaths(ctx.settings).length > 0) {
+        const liveTypes = (await ctx.reader.exists("types.yaml"))
+            ? await ctx.reader.read("types.yaml")
+            : undefined;
+        const liveDatasource = (await ctx.reader.exists("datasource.yaml"))
+            ? await ctx.reader.read("datasource.yaml")
+            : undefined;
+        const versions = await versionMigrationFiles(key, ctx, casing, {
+            typesYaml: liveTypes,
+            datasourceYaml: liveDatasource,
+        });
+        return {
+            entries: versions.files.map((file) => content(`${key}/migrations/${file.path}`, file.content)),
+            count: versions.count,
+        };
+    }
+    const data = await loadSchema(ctx);
+    const initial = generateInitialMigration(key, data.types, data.seeds, casing);
+    return {
+        entries: [
+            content(`${key}/migrations/${initial.up.path}`, initial.up.content),
+            content(`${key}/migrations/${initial.down.path}`, initial.down.content),
+        ],
+        count: 1,
+    };
+};

package/node_modules/@deterministic-code/datasources-code-generators/dist/sql/common/procedures/driver.d.ts

@@ -0,0 +1,9 @@
+import type { PackCasing } from "../default-casing.js";
+export type ProcOp = "create" | "read" | "update" | "delete" | "bulkCreate" | "bulkUpdate" | "bulkDelete";
+export type ProcSpec = {
+    op: ProcOp;
+    name: string;
+    byProperties: string[];
+};
+/** Ordered CRUD ops + routine names for one entity. */
+export declare const procedureSpecs: (entityName: string, byGroups: string[][], casing: PackCasing) => ProcSpec[];

package/node_modules/@deterministic-code/datasources-code-generators/dist/sql/common/procedures/driver.js

@@ -0,0 +1,18 @@
+/** Ordered CRUD ops + routine names for one entity. */
+export const procedureSpecs = (entityName, byGroups, casing) => {
+    const name = (stem) => casing.routineName(stem);
+    const plural = casing.pluralStem(entityName);
+    const bySuffix = (props) => props.length === 0 ? "" : `_by_${props.join("_")}`;
+    return [
+        { op: "create", name: name(`create_${plural}`), byProperties: [] },
+        { op: "read", name: name(`read_${plural}`), byProperties: [] },
+        ...byGroups.flatMap((props) => [
+            { op: "read", name: name(`read_${plural}${bySuffix(props)}`), byProperties: props },
+            { op: "update", name: name(`update_${plural}${bySuffix(props)}`), byProperties: props },
+            { op: "delete", name: name(`delete_${plural}${bySuffix(props)}`), byProperties: props },
+        ]),
+        { op: "bulkCreate", name: name(`bulk_create_${plural}`), byProperties: [] },
+        { op: "bulkUpdate", name: name(`bulk_update_${plural}`), byProperties: [] },
+        { op: "bulkDelete", name: name(`bulk_delete_${plural}`), byProperties: [] },
+    ];
+};

package/node_modules/@deterministic-code/datasources-code-generators/dist/sql/common/procedures/helpers.d.ts

@@ -0,0 +1,25 @@
+/** Helpers shared by stored-procedure generation. */
+interface ProcField {
+    name: string;
+    type: string;
+    size?: number;
+}
+interface ProcTable {
+    fields: ProcField[];
+    pkName?: string;
+}
+/** The entity's primary key: `pkName` when set, else a field named `id`. */
+export declare const pkFieldOf: (table: ProcTable) => ProcField;
+/** The writable, non-audit columns: everything but the pk, the system `uuid`, and `created`/`updated`. */
+export declare const writableNonAuditFields: (table: ProcTable) => ProcField[];
+/** CREATE IN-params from expanded columns, in the stored-procedure call order: `uuid` (if present), writable fields, `created`, `updated`. */
+export declare const createParamFields: (table: ProcTable) => ProcField[];
+/** The expanded `updated` column — present on every table that gets procedures. */
+export declare const updatedFieldOf: (table: ProcTable) => ProcField;
+/** Expanded columns qualified with a table alias (default `t`). */
+export declare const aliasedColumns: (table: ProcTable, alias?: string, columnName?: (field: string) => string) => string;
+export declare const paramAlignWidth: (params: {
+    name: string;
+}[]) => number;
+export declare const pad: (s: string, w: number) => string;
+export {};

package/node_modules/@deterministic-code/datasources-code-generators/dist/sql/common/procedures/helpers.js

@@ -0,0 +1,39 @@
+/** Helpers shared by stored-procedure generation. */
+/** The entity's primary key: `pkName` when set, else a field named `id`. */
+export const pkFieldOf = (table) => (table.pkName
+    ? table.fields.find((f) => f.name === table.pkName)
+    : undefined) ??
+    table.fields.find((f) => f.name === "id") ?? { name: "id", type: "integer" };
+/** The writable, non-audit columns: everything but the pk, the system `uuid`, and `created`/`updated`. */
+export const writableNonAuditFields = (table) => {
+    const pk = pkFieldOf(table);
+    return table.fields.filter((f) => f.name !== pk.name &&
+        f.name !== "uuid" &&
+        f.name !== "created" &&
+        f.name !== "updated");
+};
+/** CREATE IN-params from expanded columns, in the stored-procedure call order: `uuid` (if present), writable fields, `created`, `updated`. */
+export const createParamFields = (table) => {
+    const field = (name) => {
+        const found = table.fields.find((f) => f.name === name);
+        return found ? [found] : [];
+    };
+    return [
+        ...field("uuid"),
+        ...writableNonAuditFields(table),
+        ...field("created"),
+        ...field("updated"),
+    ];
+};
+/** The expanded `updated` column — present on every table that gets procedures. */
+export const updatedFieldOf = (table) => {
+    const field = table.fields.find((f) => f.name === "updated");
+    if (!field) {
+        throw new Error("procedure table is missing expanded `updated` column");
+    }
+    return field;
+};
+/** Expanded columns qualified with a table alias (default `t`). */
+export const aliasedColumns = (table, alias = "t", columnName = (field) => field) => table.fields.map((f) => `${alias}.${columnName(f.name)}`).join(", ");
+export const paramAlignWidth = (params) => params.reduce((m, p) => Math.max(m, p.name.length), 0);
+export const pad = (s, w) => s + " ".repeat(Math.max(0, w - s.length));

package/node_modules/@deterministic-code/datasources-code-generators/dist/sql/common/schema-diff.d.ts

@@ -0,0 +1,10 @@
+import { type IStatement } from "@deterministic-code/datasources";
+import type { SqlMapping } from "./sql-mapping.js";
+import type { SqlDialect } from "./sql-dialect.js";
+import { type LiveTable } from "./sql-schema.js";
+export type SchemaSnapshot = {
+    tables: LiveTable[];
+    mapping: SqlMapping;
+};
+/** Ordered CREATE / ALTER / DROP statements that take `before` to `after`. */
+export declare const schemaDiff: (dialect: SqlDialect, before: SchemaSnapshot, after: SchemaSnapshot) => IStatement[];

package/node_modules/@deterministic-code/datasources-code-generators/dist/sql/common/schema-diff.js

@@ -0,0 +1,136 @@
+import { isDeepStrictEqual } from "node:util";
+import { AlterTableStatement, } from "@deterministic-code/datasources";
+import { createIndexStatementOf, createTableStatementOf, createTriggerStatementOf, columnOf, dropIndexStatementOf, dropTableStatementOf, dropTriggerStatementOf, foreignKeyOf, uniqueConstraintOf, } from "../statements.js";
+import { fieldOverlay, hasAuditColumns, isGeneratedIdentity, overlayOf, tableIdentity, } from "./sql-schema.js";
+import { pkName } from "@deterministic-code/generators-common/spec-types";
+const byName = (tables) => new Map(tables.map((table) => [table.name, table]));
+const fieldByName = (table) => new Map(table.fields.map((field) => [field.name, field]));
+const indexKey = (index) => JSON.stringify([index.name, index.fields, index.isUnique]);
+const uniqueField = (table, field) => fieldOverlay(table, field.name)?.isUnique === true || field.name === "uuid";
+const refsOf = (field) => JSON.stringify(field.references ?? null);
+const columnShape = (field) => [
+    field.type,
+    field.size ?? null,
+    field.isNullable,
+    field.defaultValue ?? null,
+];
+const identityOf = (table) => [
+    tableIdentity(table),
+    isGeneratedIdentity(table),
+];
+const trigger = (dialect, table, mapping) => createTriggerStatementOf(dialect, table, mapping, pkName(table, overlayOf(table)) ?? "id");
+const dropTrigger = (dialect, table, mapping) => dropTriggerStatementOf(dialect, mapping.triggerName(table), table.tableName);
+const dropIndex = (dialect, mapping, table, index) => dropIndexStatementOf(dialect, mapping.constraintName(table, index.name, "index"), table.tableName);
+const createTable = (dialect, table, mapping) => [
+    createTableStatementOf(dialect, table, mapping),
+    ...table.indexes.map((index) => createIndexStatementOf(dialect, mapping, table, index)),
+    ...(hasAuditColumns(table) ? [trigger(dialect, table, mapping)] : []),
+];
+const dropTable = (dialect, table, mapping) => [
+    ...(hasAuditColumns(table) ? [dropTrigger(dialect, table, mapping)] : []),
+    ...[...table.indexes].reverse().map((index) => dropIndex(dialect, mapping, table, index)),
+    dropTableStatementOf(dialect, table.tableName),
+];
+const diffTable = (dialect, before, after, beforeMap, afterMap) => {
+    if (!isDeepStrictEqual(identityOf(before), identityOf(after))) {
+        throw new Error(`${after.name}: primary key or identity change is not supported`);
+    }
+    const beforeFields = fieldByName(before);
+    const afterFields = fieldByName(after);
+    const droppedFields = before.fields.filter((field) => !afterFields.has(field.name));
+    const addedFields = after.fields.filter((field) => !beforeFields.has(field.name));
+    const keptFields = after.fields.filter((field) => beforeFields.has(field.name));
+    const beforeIndexes = new Map(before.indexes.map((index) => [index.name, index]));
+    const afterIndexes = new Map(after.indexes.map((index) => [index.name, index]));
+    const out = [];
+    for (const index of before.indexes) {
+        const next = afterIndexes.get(index.name);
+        if (next === undefined || indexKey(index) !== indexKey(next)) {
+            out.push(dropIndex(dialect, beforeMap, before, index));
+        }
+    }
+    for (const field of before.fields) {
+        if (uniqueField(before, field) && (!afterFields.has(field.name) || !uniqueField(after, afterFields.get(field.name)))) {
+            out.push(new AlterTableStatement(before.tableName, {
+                kind: "dropConstraint",
+                name: uniqueConstraintOf(dialect, beforeMap, before, field).name,
+            }));
+        }
+        if (field.references !== undefined && (!afterFields.has(field.name) || refsOf(afterFields.get(field.name)) !== refsOf(field))) {
+            out.push(new AlterTableStatement(before.tableName, {
+                kind: "dropConstraint",
+                name: foreignKeyOf(dialect, beforeMap, before, field).name,
+            }));
+        }
+    }
+    if (hasAuditColumns(before) && !hasAuditColumns(after)) {
+        out.push(dropTrigger(dialect, before, beforeMap));
+    }
+    for (const field of droppedFields) {
+        out.push(new AlterTableStatement(before.tableName, {
+            kind: "dropColumn",
+            name: columnOf(dialect, beforeMap, before, field).name,
+        }));
+    }
+    const tableName = after.tableName;
+    if (before.tableName !== after.tableName) {
+        out.push(new AlterTableStatement(before.tableName, { kind: "renameTable", to: after.tableName }));
+    }
+    for (const field of keptFields) {
+        const previous = beforeFields.get(field.name);
+        const from = columnOf(dialect, beforeMap, before, previous).name;
+        const to = columnOf(dialect, afterMap, after, field).name;
+        if (from !== to) {
+            out.push(new AlterTableStatement(tableName, { kind: "renameColumn", from, to }));
+        }
+        if (!isDeepStrictEqual(columnShape(previous), columnShape(field))) {
+            out.push(new AlterTableStatement(tableName, {
+                kind: "alterColumn",
+                column: columnOf(dialect, afterMap, after, field),
+            }));
+        }
+    }
+    for (const field of addedFields) {
+        out.push(new AlterTableStatement(tableName, {
+            kind: "addColumn",
+            column: columnOf(dialect, afterMap, after, field),
+        }));
+    }
+    for (const field of after.fields) {
+        if (uniqueField(after, field) && (!beforeFields.has(field.name) || !uniqueField(before, beforeFields.get(field.name)))) {
+            out.push(new AlterTableStatement(tableName, {
+                kind: "addConstraint",
+                constraint: uniqueConstraintOf(dialect, afterMap, after, field),
+            }));
+        }
+        if (field.references !== undefined && (!beforeFields.has(field.name) || refsOf(beforeFields.get(field.name)) !== refsOf(field))) {
+            out.push(new AlterTableStatement(tableName, {
+                kind: "addConstraint",
+                constraint: foreignKeyOf(dialect, afterMap, after, field),
+            }));
+        }
+    }
+    for (const index of after.indexes) {
+        const previous = beforeIndexes.get(index.name);
+        if (previous === undefined || indexKey(previous) !== indexKey(index)) {
+            out.push(createIndexStatementOf(dialect, afterMap, after, index));
+        }
+    }
+    if (!hasAuditColumns(before) && hasAuditColumns(after)) {
+        out.push(trigger(dialect, after, afterMap));
+    }
+    return out;
+};
+/** Ordered CREATE / ALTER / DROP statements that take `before` to `after`. */
+export const schemaDiff = (dialect, before, after) => {
+    const previous = byName(before.tables);
+    const next = byName(after.tables);
+    const removed = before.tables.filter((table) => !next.has(table.name));
+    const added = after.tables.filter((table) => !previous.has(table.name));
+    const kept = after.tables.filter((table) => previous.has(table.name));
+    return [
+        ...[...removed].reverse().flatMap((table) => dropTable(dialect, table, before.mapping)),
+        ...kept.flatMap((table) => diffTable(dialect, previous.get(table.name), table, before.mapping, after.mapping)),
+        ...added.flatMap((table) => createTable(dialect, table, after.mapping)),
+    ];
+};

package/node_modules/@deterministic-code/datasources-code-generators/dist/sql/common/seed-generator.d.ts

@@ -0,0 +1,6 @@
+import type { SeedRow } from "@deterministic-code/deterministic-generators-common/parser";
+import { type SqlDialect } from "./sql-dialect.js";
+import type { SqlMapping } from "./sql-mapping.js";
+import { type LiveTable } from "./sql-schema.js";
+/** Per-table seed SQL blocks for the initial migration (`-- Seeds: <table>`). */
+export declare const seedSections: (dialect: SqlDialect, tables: LiveTable[], seeds: Map<string, SeedRow[]>, mapping: SqlMapping) => string[];

package/node_modules/@deterministic-code/datasources-code-generators/dist/sql/common/seed-generator.js

@@ -0,0 +1,82 @@
+import { createHash } from "node:crypto";
+import { isPkField } from "@deterministic-code/generators-common/spec-types";
+import { sqlStringLiteral } from "@deterministic-code/datasources";
+import { identityInsertStatementOf, seedInsertStatementOf } from "../statements.js";
+import { renderSql, sqlDefault } from "./sql-dialect.js";
+import { dialectConverter } from "./sql-dialect.js";
+import { isGeneratedIdentity, overlayOf, tableIdentity, } from "./sql-schema.js";
+const SEED_UUID_NAMESPACE = "9b3a8e6c-2f1d-4a5b-8c9d-1e2f3a4b5c6d";
+const pkType = (table) => table.fields.find((f) => isPkField(f, table, overlayOf(table)))?.type ??
+    "integer";
+const seedUuid = (tableName, id) => {
+    const bytes = Buffer.from(createHash("sha1")
+        .update(Buffer.concat([
+        Buffer.from(SEED_UUID_NAMESPACE.replace(/-/g, ""), "hex"),
+        Buffer.from(`${tableName}:${id}`, "utf8"),
+    ]))
+        .digest()
+        .subarray(0, 16));
+    bytes[6] = (bytes[6] & 0x0f) | 0x50;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    const hex = bytes.toString("hex");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
+};
+const renderValue = (dialect, field, value) => {
+    if (field.type === "boolean") {
+        return (dialectConverter(dialect).defaultValueConverter.convert("boolean", value ? "true" : "false") ?? "0");
+    }
+    if (field.type === "number" || field.type === "reference") {
+        return String(value);
+    }
+    return sqlStringLiteral(value);
+};
+const idValue = (table, id) => {
+    const t = pkType(table);
+    if (t === "uuid")
+        return sqlStringLiteral(seedUuid(table.name, id));
+    if (t === "string")
+        return sqlStringLiteral(String(id));
+    return String(id);
+};
+const colValue = (dialect, field, value) => {
+    if (!field)
+        return "NULL";
+    if (value === null || value === undefined) {
+        return sqlDefault(dialect, field) ?? "NULL";
+    }
+    return renderValue(dialect, field, value);
+};
+const colsForRow = (table, row) => {
+    const names = new Set(table.fields.map((f) => f.name));
+    const generated = isGeneratedIdentity(table) ? tableIdentity(table) : [];
+    return [
+        ...generated.filter((k) => names.has(k)),
+        ...(names.has("uuid") && !generated.includes("uuid") ? ["uuid"] : []),
+        ...Object.keys(row).filter((k) => !generated.includes(k) && k !== "uuid"),
+    ];
+};
+/** Per-table seed SQL blocks for the initial migration (`-- Seeds: <table>`). */
+export const seedSections = (dialect, tables, seeds, mapping) => {
+    const lines = [];
+    for (const table of tables) {
+        const rows = seeds.get(table.name) ?? [];
+        if (rows.length === 0)
+            continue;
+        const generated = isGeneratedIdentity(table) ? tableIdentity(table) : [];
+        const t = pkType(table);
+        const identity = isGeneratedIdentity(table) && t !== "uuid" && t !== "string";
+        const inserts = rows.map((seed) => {
+            const cols = colsForRow(table, seed.row);
+            const values = cols.map((c) => {
+                if (generated.includes(c))
+                    return idValue(table, seed.id);
+                if (c === "uuid")
+                    return sqlStringLiteral(seedUuid(table.name, seed.id));
+                return colValue(dialect, table.fields.find((f) => f.name === c), seed.row[c]);
+            });
+            return seedInsertStatementOf(table, mapping, cols, values, dialect);
+        });
+        lines.push(`-- Seeds: ${table.tableName}`, renderSql(dialect, identityInsertStatementOf(dialect, table, mapping, inserts, identity)), "");
+    }
+    return lines;
+};

package/node_modules/@deterministic-code/datasources-code-generators/dist/sql/common/sql-dialect.d.ts

@@ -0,0 +1,23 @@
+import { type DefaultValueConverter, type DeterministicTypeConverter, type IDriver, type IStatement, type SpecField, type StatementTextRenderer } from "@deterministic-code/datasources";
+export type SqlDialect = string;
+export type SqlGenerateDriver = IDriver & {
+    quoteLeft: string;
+    quoteRight: string;
+    typeConverter: DeterministicTypeConverter;
+    defaultValueConverter: DefaultValueConverter;
+    statementRenderer: StatementTextRenderer;
+};
+export declare const dialectDriver: (dialect: string) => SqlGenerateDriver;
+export declare const renderSql: (dialect: string, statement: IStatement) => string;
+export declare const dialectConverter: (dialect: string) => {
+    quoteLeft: string;
+    quoteRight: string;
+    defaultValueConverter: DefaultValueConverter;
+    toColumnType: (field: SpecField) => string;
+};
+export declare const requireDialect: (language: string) => SqlDialect;
+/** Dialects listed in `backend.datasources`. */
+export declare const dialectsFromSettings: (settings: Record<string, string>) => SqlDialect[];
+export declare const q: (dialect: string, ident: string) => string;
+export declare const mapColumnType: (dialect: string, field: SpecField) => string;
+export declare const sqlDefault: (dialect: string, field: SpecField) => string | null;

package/node_modules/@deterministic-code/datasources-code-generators/dist/sql/common/sql-dialect.js

@@ -0,0 +1,58 @@
+import { createRequire } from "node:module";
+import { DriverLoader, ProviderCatalog, } from "@deterministic-code/datasources";
+const require = createRequire(import.meta.url);
+export const dialectDriver = (dialect) => {
+    const catalog = ProviderCatalog.default[dialect];
+    if (catalog === undefined)
+        throw new Error(`Unknown SQL dialect "${dialect}".`);
+    const driver = DriverLoader.load(new ProviderCatalog(catalog.name, require.resolve(catalog.location), catalog.module));
+    if (driver.typeConverter == null ||
+        driver.defaultValueConverter == null ||
+        driver.statementRenderer == null) {
+        throw new Error(`"${dialect}" is not a SQL dialect.`);
+    }
+    return driver;
+};
+export const renderSql = (dialect, statement) => {
+    const sql = dialectDriver(dialect).statementRenderer.render(statement).trimEnd();
+    return sql === "" ? "" : /[;/]$/.test(sql) ? sql : `${sql};`;
+};
+export const dialectConverter = (dialect) => {
+    const driver = dialectDriver(dialect);
+    return {
+        quoteLeft: driver.quoteLeft,
+        quoteRight: driver.quoteRight,
+        defaultValueConverter: driver.defaultValueConverter,
+        toColumnType: (field) => driver.typeConverter.convert(field),
+    };
+};
+export const requireDialect = (language) => {
+    dialectDriver(language);
+    return language;
+};
+/** Dialects listed in `backend.datasources`. */
+export const dialectsFromSettings = (settings) => {
+    const raw = settings["backend.datasources"];
+    if (raw === undefined || raw === "")
+        return ["sqlite"];
+    const out = [];
+    for (const name of raw.split(",")) {
+        const key = name.trim();
+        if (key === "")
+            continue;
+        const dialect = requireDialect(key);
+        if (!out.includes(dialect))
+            out.push(dialect);
+    }
+    return out.length > 0 ? out : ["sqlite"];
+};
+export const q = (dialect, ident) => {
+    const driver = dialectDriver(dialect);
+    return `${driver.quoteLeft}${ident}${driver.quoteRight}`;
+};
+export const mapColumnType = (dialect, field) => dialectDriver(dialect).typeConverter.convert(field);
+export const sqlDefault = (dialect, field) => {
+    if (field.defaultValue === undefined || field.defaultValue === null)
+        return null;
+    return dialectDriver(dialect).defaultValueConverter.convert(field.type, String(field.defaultValue));
+};

package/node_modules/@deterministic-code/datasources-code-generators/dist/sql/common/sql-keywords.d.ts

@@ -0,0 +1,4 @@
+/** SQL reserved words and native types that follow `datasource.casing.keywords`. */
+export declare const SQL_KEYWORDS: Set<string>;
+/** Rewrite unquoted SQL keywords/types. Quoted idents, strings, and comments stay as-is. */
+export declare const applyKeywordCasing: (sql: string, keyword: (word: string) => string) => string;