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

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

@@ -0,0 +1,140 @@
+/** SQL reserved words and native types that follow `datasource.casing.keywords`. */
+export const SQL_KEYWORDS = new Set([
+    "AFTER",
+    "ALTER",
+    "AND",
+    "AS",
+    "AT",
+    "AUTOINCREMENT",
+    "AUTO_INCREMENT",
+    "BEFORE",
+    "BEGIN",
+    "BETWEEN",
+    "BIGINT",
+    "BIGSERIAL",
+    "BINARY_DOUBLE",
+    "BIT",
+    "BLOB",
+    "BOOLEAN",
+    "BY",
+    "BYTEA",
+    "CASCADE",
+    "CAST",
+    "CHAR",
+    "CLOB",
+    "CONSTRAINT",
+    "CONSTRAINTS",
+    "CREATE",
+    "DATETIME",
+    "DATETIME2",
+    "DECIMAL",
+    "DECLARE",
+    "DEFAULT",
+    "DELETE",
+    "DIAGNOSTICS",
+    "DOUBLE",
+    "DROP",
+    "EACH",
+    "ELSE",
+    "END",
+    "EXCEPTION",
+    "EXECUTE",
+    "EXISTS",
+    "FALSE",
+    "FLOAT",
+    "FOR",
+    "FOREIGN",
+    "FROM",
+    "FUNCTION",
+    "GENERATED",
+    "GET",
+    "GETDATE",
+    "GETUTCDATE",
+    "GO",
+    "IDENTITY",
+    "IDENTITY_INSERT",
+    "IF",
+    "IMMEDIATE",
+    "IN",
+    "INDEX",
+    "INNER",
+    "INSERT",
+    "INT",
+    "INTEGER",
+    "INTO",
+    "JOIN",
+    "KEY",
+    "LANGUAGE",
+    "LAST_INSERT_ID",
+    "LOCALTIMESTAMP",
+    "LONGBLOB",
+    "LONGTEXT",
+    "MAX",
+    "NCHAR",
+    "NEW",
+    "NEWID",
+    "NOCOUNT",
+    "NOT",
+    "NOW",
+    "NULL",
+    "NUMBER",
+    "NUMERIC",
+    "NVARCHAR",
+    "OFF",
+    "OLD",
+    "ON",
+    "OR",
+    "ORDER",
+    "OTHERS",
+    "PRECISION",
+    "PRIMARY",
+    "PROCEDURE",
+    "RAISE",
+    "RAW",
+    "REAL",
+    "REFERENCES",
+    "REPLACE",
+    "RETURN",
+    "RETURNING",
+    "RETURNS",
+    "ROW",
+    "ROWCOUNT",
+    "ROW_COUNT",
+    "SCOPE_IDENTITY",
+    "SELECT",
+    "SERIAL",
+    "SET",
+    "SETOF",
+    "SMALLINT",
+    "SQLCODE",
+    "SYS_EXTRACT_UTC",
+    "SYS_GUID",
+    "SYSTIMESTAMP",
+    "TABLE",
+    "TEXT",
+    "THEN",
+    "TIME",
+    "TIMESTAMP",
+    "TIMESTAMPTZ",
+    "TINYINT",
+    "TRIGGER",
+    "TRUE",
+    "UNIQUE",
+    "UNIQUEIDENTIFIER",
+    "UNSIGNED",
+    "UPDATE",
+    "UTC_TIMESTAMP",
+    "UUID",
+    "VALUES",
+    "VARBINARY",
+    "VARCHAR",
+    "VARCHAR2",
+    "WHEN",
+    "WHERE",
+    "ZONE",
+]);
+const TOKEN = /('(?:''|[^'])*')|("(?:""|[^"])*")|(`(?:``|[^`])*`)|(\[[^\]]*\])|(--[^\n]*)|(\/\*[\s\S]*?\*\/)|([A-Za-z_][A-Za-z0-9_]*)/g;
+/** Rewrite unquoted SQL keywords/types. Quoted idents, strings, and comments stay as-is. */
+export const applyKeywordCasing = (sql, keyword) => sql.replace(TOKEN, (match, _s, _d, _b, _br, _lc, _bc, word) => word !== undefined && SQL_KEYWORDS.has(word.toUpperCase())
+    ? keyword(word)
+    : match);

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

@@ -0,0 +1,20 @@
+import type { TypeField } from "@deterministic-code/deterministic-generators-common/parser";
+import type { PackCasing } from "./default-casing.js";
+import { type SqlTable } from "./sql-schema.js";
+/** Physical table/column names from datasource `mapping` overlays + pack casing. */
+export declare class SqlMapping {
+    private readonly casing;
+    private readonly byLogicalName;
+    constructor(casing: PackCasing, tables: readonly SqlTable[]);
+    tableStem(table: SqlTable): string;
+    fieldStem(table: SqlTable, fieldName: string): string;
+    tableName(table: SqlTable): string;
+    columnName(table: SqlTable, fieldName: string): string;
+    constraintName(table: SqlTable, ...parts: string[]): string;
+    triggerName(table: SqlTable): string;
+    tableOf(logicalName: string): SqlTable;
+    resolveReference(references: NonNullable<TypeField["references"]>): {
+        tableName: string;
+        columnName: string;
+    };
+}

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

@@ -0,0 +1,43 @@
+import { fieldOverlay, referenceTarget, } from "./sql-schema.js";
+/** Physical table/column names from datasource `mapping` overlays + pack casing. */
+export class SqlMapping {
+    casing;
+    byLogicalName;
+    constructor(casing, tables) {
+        this.casing = casing;
+        this.byLogicalName = new Map(tables.map((t) => [t.name, t]));
+    }
+    tableStem(table) {
+        return table.mapping ?? table.name;
+    }
+    fieldStem(table, fieldName) {
+        return fieldOverlay(table, fieldName)?.mapping ?? fieldName;
+    }
+    tableName(table) {
+        return this.casing.tableName(this.tableStem(table));
+    }
+    columnName(table, fieldName) {
+        return this.casing.columnName(this.fieldStem(table, fieldName));
+    }
+    constraintName(table, ...parts) {
+        return this.casing.constraintName(this.tableStem(table), ...parts);
+    }
+    triggerName(table) {
+        return this.casing.triggerName(this.tableStem(table));
+    }
+    tableOf(logicalName) {
+        const table = this.byLogicalName.get(logicalName);
+        if (!table) {
+            throw new Error(`foreign key references unknown table "${logicalName}"`);
+        }
+        return table;
+    }
+    resolveReference(references) {
+        const [logicalTable, logicalCol] = referenceTarget(references);
+        const target = this.tableOf(logicalTable);
+        return {
+            tableName: this.tableName(target),
+            columnName: this.columnName(target, logicalCol),
+        };
+    }
+}

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

@@ -0,0 +1,35 @@
+import type { DatasourceFieldOverlay, DatasourceIndex, DatasourceTable, IDeterministic, Type, TypeField } from "@deterministic-code/deterministic-generators-common/parser";
+/** Flattened `datasource.*` flags. Stored procedures are opt-in `"true"`. */
+export declare const datasourceSettings: (settings: Record<string, string>) => {
+    useStoredProcedures: boolean;
+};
+export type SqlTable = Omit<Type, "mapping"> & {
+    tableName?: string;
+    indexes: DatasourceIndex[];
+    uniqueIndexFields: string[];
+    mapping?: string;
+    overlays: DatasourceFieldOverlay[];
+};
+export type LiveTable = SqlTable & {
+    tableName: string;
+};
+export declare const overlayOf: (table: SqlTable) => DatasourceTable;
+export declare const fieldOverlay: (table: SqlTable, fieldName: string) => DatasourceFieldOverlay | undefined;
+export declare const tableIdentity: (table: SqlTable) => string[];
+export declare const isGeneratedIdentity: (table: SqlTable) => boolean;
+export declare const usesGeneratedIdColumn: (table: SqlTable, field: TypeField) => boolean;
+export declare const sqlTablesFrom: (spec: IDeterministic) => SqlTable[];
+export declare const hasAuditColumns: (table: {
+    fields: {
+        name: string;
+    }[];
+}) => boolean;
+export type SqlFile = {
+    path: string;
+    content: string;
+};
+export declare const referenceTarget: (references: NonNullable<TypeField["references"]>) => [string, string];
+/** Attach physical names and order parent tables before children. */
+export declare const buildLiveTables: (types: SqlTable[], mapping: {
+    tableName: (table: SqlTable) => string;
+}) => LiveTable[];

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

@@ -0,0 +1,112 @@
+import { datasourceTypesOf, dictionaryUniqueColumns, identityColumns, persistedColumnFields, tableByName, } from "@deterministic-code/generators-common/spec-types";
+/** Flattened `datasource.*` flags. Stored procedures are opt-in `"true"`. */
+export const datasourceSettings = (settings) => ({
+    useStoredProcedures: String(settings["datasource.use_stored_procedures"]) === "true",
+});
+export const overlayOf = (table) => ({
+    name: table.name,
+    fields: table.overlays,
+    indexes: table.indexes,
+    uniqueIndexFields: table.uniqueIndexFields,
+    ...(table.mapping !== undefined ? { mapping: table.mapping } : {}),
+});
+export const fieldOverlay = (table, fieldName) => table.overlays.find((overlay) => overlay.name === fieldName);
+const GENERATED_ID_TYPES = new Set([
+    "integer",
+    "biginteger",
+    "uuid",
+    "string",
+]);
+export const tableIdentity = (table) => {
+    const keys = identityColumns(table, overlayOf(table));
+    if (keys.length > 1) {
+        return keys.every((col) => table.fields.some((f) => f.name === col))
+            ? keys
+            : [];
+    }
+    const col = keys[0];
+    if (col === undefined)
+        return [];
+    if (table.fields.some((f) => f.name === col) || table.inherits === "set") {
+        return [col];
+    }
+    return [];
+};
+export const isGeneratedIdentity = (table) => {
+    const keys = tableIdentity(table);
+    if (keys.length !== 1)
+        return false;
+    return fieldOverlay(table, keys[0])?.isFixedId !== true;
+};
+export const usesGeneratedIdColumn = (table, field) => isGeneratedIdentity(table) &&
+    field.name === tableIdentity(table)[0] &&
+    GENERATED_ID_TYPES.has(field.type);
+export const sqlTablesFrom = (spec) => {
+    const overlays = tableByName(spec);
+    const byName = new Map(spec.expandedTypes.map((t) => [t.name, t]));
+    return datasourceTypesOf(spec).map((type) => {
+        const table = overlays.get(type.name);
+        const { mapping: _typeMapping, ...rest } = type;
+        const uniqueCols = dictionaryUniqueColumns(type, byName);
+        const indexes = [...(table?.indexes ?? [])];
+        if (uniqueCols.length > 0 &&
+            !indexes.some((idx) => idx.isUnique &&
+                idx.fields.length === uniqueCols.length &&
+                idx.fields.every((name, i) => name === uniqueCols[i]))) {
+            indexes.push({
+                name: "owner_key",
+                fields: uniqueCols,
+                isUnique: true,
+            });
+        }
+        return {
+            ...rest,
+            fields: persistedColumnFields(type, byName),
+            indexes,
+            uniqueIndexFields: table?.uniqueIndexFields ?? [],
+            ...(table?.mapping !== undefined ? { mapping: table.mapping } : {}),
+            overlays: table?.fields ?? [],
+        };
+    });
+};
+export const hasAuditColumns = (table) => table.fields.some((f) => f.name === "created") &&
+    table.fields.some((f) => f.name === "updated");
+const referenceParents = (references) => {
+    if (references === undefined)
+        return [];
+    if (Array.isArray(references))
+        return [references[0]];
+    return [references.split(".")[0]];
+};
+export const referenceTarget = (references) => {
+    if (Array.isArray(references))
+        return [references[0], references[1]];
+    const [table, col] = references.split(".");
+    return [table ?? "", col ?? ""];
+};
+const topoSort = (tables) => {
+    const names = new Set(tables.map((t) => t.name));
+    const deps = new Map(tables.map((t) => [
+        t.name,
+        new Set(t.fields.flatMap((f) => referenceParents(f.references).filter((dep) => names.has(dep) && dep !== t.name))),
+    ]));
+    const out = [];
+    const done = new Set();
+    const pending = tables.slice();
+    while (pending.length > 0) {
+        const idx = pending.findIndex((t) => [...(deps.get(t.name) ?? [])].every((d) => done.has(d)));
+        if (idx === -1) {
+            out.push(...pending);
+            break;
+        }
+        const [t] = pending.splice(idx, 1);
+        out.push(t);
+        done.add(t.name);
+    }
+    return out;
+};
+/** Attach physical names and order parent tables before children. */
+export const buildLiveTables = (types, mapping) => topoSort(types.map((t) => ({
+    ...t,
+    tableName: mapping.tableName(t),
+})));

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

@@ -0,0 +1,18 @@
+export type Json = string | number | boolean | null | Json[] | {
+    [key: string]: Json;
+};
+type JsonObject = {
+    [key: string]: Json;
+};
+export declare const apply: (before: Json, next: Json) => Json;
+export declare const applyFile: (before: Json | undefined, envelope: Json) => Json | undefined;
+export declare const applyDocument: (before: {
+    [path: string]: Json;
+}, doc: {
+    [path: string]: Json;
+}) => {
+    [path: string]: Json;
+};
+export declare const isObject: (value: Json | undefined) => value is JsonObject;
+export declare const snapshotsEqual: (left: Json | undefined, right: Json | undefined) => boolean;
+export {};

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

@@ -0,0 +1,83 @@
+import { isDeepStrictEqual } from "node:util";
+export const apply = (before, next) => {
+    if (next == null)
+        return before;
+    if (isKeyedCollection(before) && isKeyedSplit(next))
+        return applyKeyed(before, next);
+    if (isObject(before) && isObject(next))
+        return applyObject(before, next);
+    return next;
+};
+export const applyFile = (before, envelope) => {
+    if (envelope == null)
+        return before;
+    if (isObject(envelope)) {
+        if (envelope.removed === true && Object.keys(envelope).length === 1)
+            return undefined;
+        if (envelope.added === true)
+            return envelope.content;
+    }
+    return apply(before ?? null, envelope);
+};
+export const applyDocument = (before, doc) => {
+    const out = { ...before };
+    for (const [path, envelope] of Object.entries(doc)) {
+        const next = applyFile(out[path], envelope);
+        if (next === undefined)
+            delete out[path];
+        else
+            out[path] = next;
+    }
+    return out;
+};
+const applyKeyed = (beforeVal, split) => {
+    const removed = new Set(split.removed ?? []);
+    const changed = new Map();
+    for (const entry of split.changed ?? []) {
+        const key = Object.keys(entry)[0];
+        changed.set(key, entry[key]);
+    }
+    return [
+        ...beforeVal.flatMap((entry) => {
+            const key = Object.keys(entry)[0];
+            if (removed.has(key))
+                return [];
+            return changed.has(key) ? [{ [key]: apply(entry[key], changed.get(key)) }] : [entry];
+        }),
+        ...(split.added ?? []),
+    ];
+};
+const applyObject = (beforeVal, next) => {
+    const removed = new Set(Array.isArray(next.removed) ? next.removed : []);
+    const out = {};
+    for (const key of Object.keys(beforeVal)) {
+        if (removed.has(key))
+            continue;
+        out[key] = key in next ? apply(beforeVal[key], next[key]) : beforeVal[key];
+    }
+    for (const key of Object.keys(next)) {
+        if (key === "removed" && Array.isArray(next.removed))
+            continue;
+        if (!(key in beforeVal))
+            out[key] = next[key];
+    }
+    return out;
+};
+const isKeyedSplit = (value) => {
+    if (!isObject(value))
+        return false;
+    const allowed = new Set(["added", "changed", "removed"]);
+    return Object.keys(value).every((key) => allowed.has(key));
+};
+export const isObject = (value) => value !== null &&
+    value !== undefined &&
+    typeof value === "object" &&
+    !Array.isArray(value) &&
+    Object.getPrototypeOf(value) === Object.prototype;
+const isKeyedCollection = (value) => Array.isArray(value) &&
+    value.length > 0 &&
+    value.every((item) => item !== null &&
+        typeof item === "object" &&
+        !Array.isArray(item) &&
+        Object.keys(item).length === 1);
+export const snapshotsEqual = (left, right) => isDeepStrictEqual(left ?? null, right ?? null);

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

@@ -0,0 +1,15 @@
+import type { GenerateContext } from "@deterministic-code/generators-common/generate-context";
+import { type PackCasing } from "./default-casing.js";
+import { type SqlDialect } from "./sql-dialect.js";
+export declare const versionDiffPaths: (settings: Record<string, string>) => string[];
+/** Replay frozen diffs, fail when live types/datasource YAML drifted, emit per-version SQL. */
+export declare const versionMigrationFiles: (dialect: SqlDialect, ctx: GenerateContext, casing: PackCasing, live: {
+    typesYaml: string | undefined;
+    datasourceYaml: string | undefined;
+}) => Promise<{
+    files: {
+        path: string;
+        content: string;
+    }[];
+    count: number;
+}>;

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

@@ -0,0 +1,127 @@
+import { parse, stringify } from "yaml";
+import { CreateTableStatement } from "@deterministic-code/datasources";
+import { memoryReader } from "@deterministic-code/generators-common/deterministic-reader";
+import { DeterministicParser } from "@deterministic-code/deterministic-generators-common/parser";
+import { applyDocument, isObject, snapshotsEqual } from "./version-apply.js";
+import { createCasing } from "./default-casing.js";
+import { SqlMapping } from "./sql-mapping.js";
+import { buildLiveTables, sqlTablesFrom } from "./sql-schema.js";
+import { renderSql } from "./sql-dialect.js";
+import { schemaDiff } from "./schema-diff.js";
+import { seedSections } from "./seed-generator.js";
+import { byGroupsFromDatasource } from "./datasource-by-fields.js";
+import { procedureStatementsForTable } from "./generate-procedures.js";
+import { datasourceSettings, hasAuditColumns } from "./sql-schema.js";
+const versionDiff = /^version-\d{8}T\d{6}Z-\d{3}\/diff\.yaml$/;
+const defaultDatasourceYaml = `version: 1.0.0
+includes:
+  - types:
+      filter: tag == "datasource_type" || tag == "view_type"
+types: []
+`;
+export const versionDiffPaths = (settings) => (settings["version.diffs"] ?? "")
+    .split("\n")
+    .map((path) => path.trim())
+    .filter((path) => versionDiff.test(path));
+const asDocument = (value, source) => isObject(value) ? value : (() => { throw new Error(`${source}: expected a mapping`); })();
+const filesOf = (snapshot) => {
+    const files = {};
+    for (const [path, value] of Object.entries(snapshot))
+        files[path] = stringify(value);
+    files["datasource.yaml"] ??= defaultDatasourceYaml;
+    return files;
+};
+const compile = async (snapshot, settings) => {
+    const spec = await DeterministicParser(memoryReader(filesOf(snapshot))).parse(settings);
+    const types = sqlTablesFrom(spec);
+    const mapping = new SqlMapping(createCasing(settings), types);
+    return { tables: buildLiveTables(types, mapping), mapping, seeds: spec.datasourceSeeds };
+};
+const emptySnapshot = (settings) => compile({}, settings);
+const pad = (n) => String(n).padStart(4, "0");
+const renderAll = (dialect, statements) => statements
+    .map((statement) => renderSql(dialect, statement))
+    .filter((sql) => sql !== "")
+    .join("\n");
+/** Replay frozen diffs, fail when live types/datasource YAML drifted, emit per-version SQL. */
+export const versionMigrationFiles = async (dialect, ctx, casing, live) => {
+    const paths = versionDiffPaths(ctx.settings);
+    if (paths.length === 0)
+        return { files: [], count: 0 };
+    let before = {};
+    const snapshots = [];
+    for (const path of paths) {
+        const text = await ctx.reader.read(path);
+        if (text === "")
+            continue;
+        before = applyDocument(before, asDocument(parse(text), path));
+        snapshots.push(before);
+    }
+    if (snapshots.length === 0)
+        return { files: [], count: 0 };
+    const last = snapshots[snapshots.length - 1];
+    const liveTypes = live.typesYaml === undefined ? undefined : parse(live.typesYaml);
+    const liveDatasource = parse(live.datasourceYaml ?? defaultDatasourceYaml);
+    const snapshotDatasource = last["datasource.yaml"] ?? parse(defaultDatasourceYaml);
+    if (!snapshotsEqual(last["types.yaml"], liveTypes) || !snapshotsEqual(snapshotDatasource, liveDatasource)) {
+        throw new Error("types.yaml or datasource.yaml differs from the frozen version diffs; run datasources version first");
+    }
+    const files = [];
+    let previous = await emptySnapshot(ctx.settings);
+    let number = 0;
+    for (const [index, snapshot] of snapshots.entries()) {
+        const current = await compile(snapshot, ctx.settings);
+        const up = [
+            ...schemaDiff(dialect, previous, current),
+            ...procedureDiff(dialect, ctx.settings, previous, current),
+        ];
+        const down = [
+            ...schemaDiff(dialect, current, previous),
+            ...procedureDiff(dialect, ctx.settings, current, previous),
+        ];
+        if (up.length === 0 && down.length === 0) {
+            previous = current;
+            continue;
+        }
+        number += 1;
+        const seeds = index === 0 && up.some((statement) => statement instanceof CreateTableStatement)
+            ? seedSections(dialect, current.tables, current.seeds, current.mapping)
+            : [];
+        const upSql = [
+            `-- Generated migration for ${dialect}`,
+            renderAll(dialect, up),
+            ...(seeds.length ? ["", "-- Seed data", ...seeds] : []),
+        ]
+            .filter((line) => line !== "")
+            .join("\n");
+        const downSql = [`-- Rollback migration for ${dialect}`, renderAll(dialect, down)].join("\n");
+        files.push({
+            path: `${pad(number)}_up.sql`,
+            content: finalize(upSql, casing),
+        });
+        files.push({
+            path: `${pad(number)}_down.sql`,
+            content: finalize(downSql, casing),
+        });
+        previous = current;
+    }
+    return { files, count: number };
+};
+const fieldsOf = (table) => JSON.stringify(table.fields.map((field) => [field.name, field.type, field.size ?? null]));
+const procedureDiff = (dialect, settings, before, after) => {
+    if (!datasourceSettings(settings).useStoredProcedures)
+        return [];
+    const casing = createCasing(settings);
+    const previous = new Map(before.tables.map((table) => [table.name, table]));
+    const groups = byGroupsFromDatasource(after.tables);
+    return after.tables.flatMap((table) => {
+        const prior = previous.get(table.name);
+        if (prior === undefined || !hasAuditColumns(table) || fieldsOf(prior) === fieldsOf(table))
+            return [];
+        return procedureStatementsForTable(dialect, table, after.mapping, casing, groups.get(table.name) ?? []).statements;
+    });
+};
+const finalize = (text, casing) => {
+    const out = casing.applyKeywords(text.replace(/\n{3,}/g, "\n\n"));
+    return out.endsWith("\n") ? out : `${out}\n`;
+};

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

@@ -0,0 +1,10 @@
+export declare const sqliteTypeConverter: import("datasources/dist/index.js").IMapping<string, string> & import("datasources/dist/index.js").DeterministicTypeConverter;
+export declare const sqliteDefaultValueConverter: import("datasources/dist/index.js").DefaultValueConverter;
+export declare const mysqlTypeConverter: import("datasources/dist/index.js").IMapping<string, string> & import("datasources/dist/index.js").DeterministicTypeConverter;
+export declare const mysqlDefaultValueConverter: import("datasources/dist/index.js").DefaultValueConverter;
+export declare const postgresTypeConverter: import("datasources/dist/index.js").IMapping<string, string> & import("datasources/dist/index.js").DeterministicTypeConverter;
+export declare const postgresDefaultValueConverter: import("datasources/dist/index.js").DefaultValueConverter;
+export declare const oracleTypeConverter: import("datasources/dist/index.js").IMapping<string, string> & import("datasources/dist/index.js").DeterministicTypeConverter;
+export declare const oracleDefaultValueConverter: import("datasources/dist/index.js").DefaultValueConverter;
+export declare const sqlserverTypeConverter: import("datasources/dist/index.js").IMapping<string, string> & import("datasources/dist/index.js").DeterministicTypeConverter;
+export declare const sqlserverDefaultValueConverter: import("datasources/dist/index.js").DefaultValueConverter;

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

@@ -0,0 +1,16 @@
+import { dialectDriver } from "./common/sql-dialect.js";
+const sqlite = dialectDriver("sqlite");
+const mysql = dialectDriver("mysql");
+const postgres = dialectDriver("postgres");
+const oracle = dialectDriver("oracle");
+const sqlserver = dialectDriver("sqlserver");
+export const sqliteTypeConverter = sqlite.typeConverter;
+export const sqliteDefaultValueConverter = sqlite.defaultValueConverter;
+export const mysqlTypeConverter = mysql.typeConverter;
+export const mysqlDefaultValueConverter = mysql.defaultValueConverter;
+export const postgresTypeConverter = postgres.typeConverter;
+export const postgresDefaultValueConverter = postgres.defaultValueConverter;
+export const oracleTypeConverter = oracle.typeConverter;
+export const oracleDefaultValueConverter = oracle.defaultValueConverter;
+export const sqlserverTypeConverter = sqlserver.typeConverter;
+export const sqlserverDefaultValueConverter = sqlserver.defaultValueConverter;

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

@@ -0,0 +1,4 @@
+import type { GenerateContext } from "@deterministic-code/generators-common/generate-context";
+import type { GenerateEntry } from "@deterministic-code/generators-common/generate-entry";
+/** DDL + custom migrations (+ stored procedures when enabled) for each dialect. */
+export declare const generate: (ctx: GenerateContext, dialects: readonly string[]) => Promise<GenerateEntry[]>;

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

@@ -0,0 +1,10 @@
+import { generateSqlFor } from "./common/generate-sql.js";
+import { requireDialect } from "./common/sql-dialect.js";
+/** DDL + custom migrations (+ stored procedures when enabled) for each dialect. */
+export const generate = async (ctx, dialects) => {
+    const entries = [];
+    for (const dialect of dialects) {
+        entries.push(...(await generateSqlFor(requireDialect(dialect), ctx)));
+    }
+    return entries;
+};

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

@@ -0,0 +1,4 @@
+import type { GenerateContext } from "@deterministic-code/generators-common/generate-context";
+import type { GenerateEntry } from "@deterministic-code/generators-common/generate-entry";
+/** Stored-procedure migrations for dialects that support them. */
+export declare const generate: (ctx: GenerateContext, dialects: readonly string[]) => Promise<GenerateEntry[]>;

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

@@ -0,0 +1,10 @@
+import { generateProceduresForDialect } from "./common/generate-procedures.js";
+import { requireDialect } from "./common/sql-dialect.js";
+/** Stored-procedure migrations for dialects that support them. */
+export const generate = async (ctx, dialects) => {
+    const entries = [];
+    for (const dialect of dialects) {
+        entries.push(...(await generateProceduresForDialect(requireDialect(dialect), ctx)));
+    }
+    return entries;
+};

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

@@ -0,0 +1 @@
+export declare const migrationUpTmpl: string, migrationDownTmpl: string;