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

package/node_modules/@deterministic-code/csharp-generators/src/templates/create-datasource-types-tests/type.tests.cs.tmpl

@@ -0,0 +1,44 @@
+// schema-version: {{schemaVersion}}
+using Xunit;
+using Backend.Types.Datasource;
+
+namespace Backend.Tests.Datasource;
+
+public class {{testClassName}}
+{
+    private static {{className}} Sample() => new {{className}}
+    {
+{{#fields}}
+        {{ident}} = {{&sampleExpr}},
+{{/fields}}
+    };
+
+{{#fields}}
+    [Fact]
+    public void {{getsTest}}()
+    {
+        var initial = {{&sampleExpr}};
+        var value = Sample();
+        value.{{ident}} = initial;
+        Assert.Equal(initial, value.{{ident}});
+    }
+
+    [Fact]
+    public void {{setsTest}}()
+    {
+        var value = Sample();
+        var next = {{&nextExpr}};
+        value.{{ident}} = next;
+        Assert.Equal(next, value.{{ident}});
+    }
+{{#nullable}}
+    [Fact]
+    public void {{allowsNullTest}}()
+    {
+        var value = Sample();
+        value.{{ident}} = null;
+        Assert.Null(value.{{ident}});
+    }
+{{/nullable}}
+{{/fields}}
+}

package/node_modules/@deterministic-code/csharp-generators/src/templates/create-routes/custom-stub.cs.tmpl

@@ -0,0 +1,5 @@
+namespace Routes.Custom;
+
+public interface {{interfaceName}} { }
+
+public class {{className}} : {{interfaceName}} { }

package/node_modules/@deterministic-code/csharp-generators/src/templates/create-routes/name-enrichment.cs.tmpl

@@ -0,0 +1,49 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace Routes.Enrichment;
+
+public static class {{className}}
+{
+    public static async Task<IList<T>> {{enrichItemsMethod}}<T>(
+        IList<T> items,
+        {{sourceInterfaceName}} source)
+    {
+        if (items.Count == 0) return items;
+        var rows = await source.FindAllAsync();
+        var map = rows.ToDictionary(r => r.Id, r => r.Name);
+        foreach (var item in items)
+        {
+            var id = (long)(item!.GetType().GetProperty("{{fkProp}}")!.GetValue(item)!);
+            if (!map.TryGetValue(id, out var name))
+            {
+                throw new InvalidOperationException(
+                    $"{{enrichItemsMethod}}: no {{targetTable}} row for id {id}");
+            }
+            item.GetType().GetProperty("{{nameProp}}")?.SetValue(item, name);
+        }
+        return items;
+    }
+
+    public static async Task<T> {{enrichItemMethod}}<T>(
+        T item,
+        {{sourceInterfaceName}} source)
+    {
+        var id = (long)(item!.GetType().GetProperty("{{fkProp}}")!.GetValue(item)!);
+        var row = await source.FindAsync(id)
+            ?? throw new InvalidOperationException(
+                $"{{enrichItemMethod}}: no {{targetTable}} row for id {id}");
+        item.GetType().GetProperty("{{nameProp}}")?.SetValue(item, row.Name);
+        return item;
+    }
+}
+
+public interface {{sourceInterfaceName}}
+{
+    Task<IReadOnlyList<{{rowTypeName}}>> FindAllAsync();
+    Task<{{rowTypeName}}?> FindAsync(long id);
+}
+
+public sealed record {{rowTypeName}}(long Id, string Name);

package/node_modules/@deterministic-code/csharp-generators/src/templates/create-routes/router.cs.tmpl

@@ -0,0 +1,15 @@
+namespace Routes.Views;
+
+{{#simpleDoc}}/** Route {{className}}. */
+{{/simpleDoc}}{{#descriptionDoc}}/**
+ * Route {{className}}.
+ * Datasource type: standard.
+ */
+{{/descriptionDoc}}public interface {{interfaceName}} { }
+
+{{#simpleDoc}}/** Route {{className}}. */
+{{/simpleDoc}}{{#descriptionDoc}}/**
+ * Route {{className}}.
+ * Datasource type: standard.
+ */
+{{/descriptionDoc}}public class {{className}} : {{interfaceName}} { }

package/node_modules/@deterministic-code/csharp-generators/src/templates/create-routes-tests/generic.cs.tmpl

@@ -0,0 +1,3 @@
+namespace Routes.Views.Tests;
+
+public class {{testClass}} { }

package/node_modules/@deterministic-code/csharp-generators/src/templates/create-service-tests/generic.cs.tmpl

@@ -0,0 +1,3 @@
+namespace Backend.Services.Views.Tests;
+
+public class {{testClass}} { }

package/node_modules/@deterministic-code/csharp-generators/src/templates/create-services/custom-stub.cs.tmpl

@@ -0,0 +1,19 @@
+namespace Backend.Services.Custom;
+
+{{#simpleDoc}}/** Service {{interfaceName}}. */
+{{/simpleDoc}}{{#descriptionDoc}}/**
+ * Service {{interfaceName}}.
+ * Datasource type: standard.
+ * Target: Custom.
+ * Fields: 0.
+ */
+{{/descriptionDoc}}public interface {{interfaceName}} { }
+
+{{#simpleDoc}}/** Service {{className}}. */
+{{/simpleDoc}}{{#descriptionDoc}}/**
+ * Service {{className}}.
+ * Datasource type: standard.
+ * Target: Custom.
+ * Fields: 0.
+ */
+{{/descriptionDoc}}public class {{className}} : {{interfaceName}} { }

package/node_modules/@deterministic-code/csharp-generators/src/templates/create-services/generic.cs.tmpl

@@ -0,0 +1,9 @@
+namespace Backend.Services.Views;
+
+{{#simpleDoc}}/** Service {{className}}. */
+{{/simpleDoc}}{{#descriptionDoc}}/**
+ * Service {{className}}.
+ * Datasource type: {{datasourceType}}.
+ * Fields: 0.
+ */
+{{/descriptionDoc}}public class {{className}} { }

package/node_modules/@deterministic-code/csharp-generators/src/templates/create-view-type-validators/type.cs.tmpl

@@ -0,0 +1,17 @@
+// schema-version: {{schemaVersion}}
+using FluentValidation;
+using Backend.Types.View;
+using Backend.Types.Datasource;
+using Backend.Validators.Datasource;
+
+namespace Backend.Validators.View;
+
+public class {{validatorClass}} : AbstractValidator<Backend.Types.View.{{className}}>
+{
+    public {{validatorClass}}()
+    {
+{{#rules}}
+{{&line}}
+{{/rules}}
+    }
+}

package/node_modules/@deterministic-code/csharp-generators/src/templates/create-view-type-validators-tests/type.tests.cs.tmpl

@@ -0,0 +1,30 @@
+// schema-version: {{schemaVersion}}
+using Xunit;
+using FluentValidation;
+{{#needsList}}
+using System.Collections.Generic;
+{{/needsList}}
+using Backend.Types.View;
+using Backend.Types.Datasource;
+using Backend.Validators.View;
+using Backend.Validators.Datasource;
+
+namespace Backend.Tests.View;
+
+public class {{testClassName}}
+{
+{{#cases}}
+    [Fact]
+    public void {{ident}}()
+    {
+        var value = {{&fixture}};
+{{#isUnion}}
+        new {{validatorClass}}().ValidateAndThrow(value);
+        Assert.NotNull(value);
+{{/isUnion}}{{^isUnion}}
+        var result = new {{validatorClass}}().Validate(value);
+        Assert.{{assertion}}(result.IsValid);
+{{/isUnion}}
+    }
+{{/cases}}
+}

package/node_modules/@deterministic-code/csharp-generators/src/templates/create-view-types/type.cs.tmpl

@@ -0,0 +1,20 @@
+// schema-version: {{schemaVersion}}
+{{#needsList}}
+using System.Collections.Generic;
+
+{{/needsList}}
+namespace Backend.Types.View;
+
+{{#simpleDoc}}/** View {{className}}. */
+{{/simpleDoc}}{{#descriptionDoc}}/**
+ * View {{className}}.
+ * Datasource type: {{datasourceType}}.
+ * Target: {{target}}.
+ * Fields: {{fieldCount}}.
+ */
+{{/descriptionDoc}}public class {{className}}{{#hasExtends}} : {{&extendsType}}{{/hasExtends}}
+{
+{{#fields}}
+    public {{&csType}} {{ident}} { get; set; }{{#hasInitializer}} = {{&initializer}}{{/hasInitializer}};
+{{/fields}}
+}

package/node_modules/@deterministic-code/csharp-generators/src/templates/create-view-types-tests/type.tests.cs.tmpl

@@ -0,0 +1,60 @@
+// schema-version: {{schemaVersion}}
+using Xunit;
+{{#needsList}}
+using System.Collections.Generic;
+{{/needsList}}
+using Backend.Types.View;
+using Backend.Types.Datasource;
+
+namespace Backend.Tests.View;
+
+public class {{testClassName}}
+{
+{{#isShaped}}
+    private static {{className}} Sample() => new {{className}}
+    {
+{{#fields}}
+        {{ident}} = {{&sampleExpr}},
+{{/fields}}
+    };
+
+{{#fields}}
+    [Fact]
+    public void {{getsTest}}()
+    {
+        var initial = {{&sampleExpr}};
+        var value = Sample();
+        value.{{ident}} = initial;
+        Assert.Equal(initial, value.{{ident}});
+    }
+
+    [Fact]
+    public void {{setsTest}}()
+    {
+        var value = Sample();
+        var next = {{&nextExpr}};
+        value.{{ident}} = next;
+        Assert.Equal(next, value.{{ident}});
+    }
+{{#nullable}}
+    [Fact]
+    public void {{allowsNullTest}}()
+    {
+        var value = Sample();
+        value.{{ident}} = null;
+        Assert.Null(value.{{ident}});
+    }
+{{/nullable}}
+{{/fields}}
+{{/isShaped}}
+{{#isUnion}}
+{{#members}}
+    [Fact]
+    public void {{acceptsMemberTest}}()
+    {
+        var value = new {{memberClass}}();
+        Assert.NotNull(value);
+    }
+{{/members}}
+{{/isUnion}}
+}

package/node_modules/@deterministic-code/csharp-generators/tsconfig.build.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "module": "nodenext", "moduleResolution": "nodenext", "target": "ES2022",
+    "lib": ["ES2022"], "types": ["node"], "declaration": true, "outDir": "dist",
+    "rootDir": "src", "allowImportingTsExtensions": true, "rewriteRelativeImportExtensions": true,
+    "resolveJsonModule": true, "skipLibCheck": true, "strict": true, "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist", "src/templates/**"]
+}

package/node_modules/@deterministic-code/datasources-code-generators/dist/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 in `backend.datasources`. */
+export declare const generate: (ctx: GenerateContext) => Promise<GenerateEntry[]>;

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

@@ -0,0 +1,4 @@
+import { generate as generateSqlForDialects } from "./sql/generate-sql.js";
+import { dialectsFromSettings } from "./sql/common/sql-dialect.js";
+/** DDL + custom migrations (+ stored procedures when enabled) for each dialect in `backend.datasources`. */
+export const generate = async (ctx) => generateSqlForDialects(ctx, dialectsFromSettings(ctx.settings));

package/node_modules/@deterministic-code/datasources-code-generators/dist/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 in `backend.datasources` that support them. */
+export declare const generate: (ctx: GenerateContext) => Promise<GenerateEntry[]>;

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

@@ -0,0 +1,4 @@
+import { generate as generateProceduresForDialects } from "./sql/generate-stored-procedures.js";
+import { dialectsFromSettings } from "./sql/common/sql-dialect.js";
+/** Stored-procedure migrations for dialects in `backend.datasources` that support them. */
+export const generate = async (ctx) => generateProceduresForDialects(ctx, dialectsFromSettings(ctx.settings));

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

@@ -0,0 +1 @@
+export { generate as generateSql } from "./sql/generate-sql.js";

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

@@ -0,0 +1 @@
+export { generate as generateSql } from "./sql/generate-sql.js";

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

@@ -0,0 +1,3 @@
+import type { TypeField } from "@deterministic-code/deterministic-generators-common/parser";
+import type { SpecField } from "@deterministic-code/datasources";
+export declare const converterFieldOf: (field: TypeField) => SpecField;

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

@@ -0,0 +1,6 @@
+export const converterFieldOf = (field) => ({
+    type: field.type,
+    name: field.name,
+    size: field.size,
+    defaultValue: field.defaultValue,
+});

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

@@ -0,0 +1,9 @@
+interface CustomMigrationPair {
+    order: number;
+    name: string;
+    up: string;
+    down: string;
+}
+/** Reads `custom/<dialect>/<order>_<name>_{up,down}.sql` as paired SQL. Missing dir → []. */
+export declare function readCustomMigrationPairs(deterministicDir: string, dialect: string): Promise<CustomMigrationPair[]>;
+export {};

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

@@ -0,0 +1,71 @@
+import { readdir, readFile, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { requireDialect } from "./sql-dialect.js";
+const FILENAME_RE = /^(\d+)_([A-Za-z0-9][A-Za-z0-9_-]*)_(up|down)\.sql$/;
+function dialectDir(deterministicDir, dialect) {
+    return join(deterministicDir, "custom", requireDialect(dialect));
+}
+async function listSqlFiles(dir) {
+    try {
+        const st = await stat(dir);
+        if (!st.isDirectory()) {
+            throw new Error(`discoverCustomMigrations: ${dir} exists but is not a directory`);
+        }
+    }
+    catch (e) {
+        if (e.code === "ENOENT")
+            return null;
+        throw e;
+    }
+    return (await readdir(dir)).filter((f) => f.endsWith(".sql")).sort();
+}
+function addSlot(dir, filename, slots) {
+    const m = FILENAME_RE.exec(filename);
+    if (!m) {
+        throw new Error(`discoverCustomMigrations: ${join(dir, filename)} does not match expected pattern <order>_<name>_(up|down).sql`);
+    }
+    const order = Number.parseInt(m[1], 10);
+    if (order < 1 || order > 999) {
+        throw new Error(`discoverCustomMigrations: ${join(dir, filename)} has order ${order}; must be in [1, 999]`);
+    }
+    const name = m[2];
+    const side = m[3];
+    const key = `${order}|${name}`;
+    const slot = slots.get(key) ?? { order, name };
+    if (slot[side]) {
+        throw new Error(`discoverCustomMigrations: duplicate ${side} file for order=${order} name=${name} in ${dir}`);
+    }
+    slot[side] = filename;
+    slots.set(key, slot);
+}
+/** Reads `custom/<dialect>/<order>_<name>_{up,down}.sql` as paired SQL. Missing dir → []. */
+export async function readCustomMigrationPairs(deterministicDir, dialect) {
+    const dir = dialectDir(deterministicDir, dialect);
+    const files = await listSqlFiles(dir);
+    if (files === null)
+        return [];
+    const slots = new Map();
+    for (const filename of files)
+        addSlot(dir, filename, slots);
+    const missing = [];
+    for (const slot of slots.values()) {
+        if (!slot.up)
+            missing.push(`missing _up.sql counterpart for ${slot.down} in ${dir}`);
+        if (!slot.down)
+            missing.push(`missing _down.sql counterpart for ${slot.up} in ${dir}`);
+    }
+    if (missing.length > 0) {
+        throw new Error(`discoverCustomMigrations: ${missing.length} mismatched up/down pair(s):\n  ${missing.join("\n  ")}`);
+    }
+    const ordered = [...slots.values()].sort((a, b) => a.order - b.order || (a.name < b.name ? -1 : 1));
+    return Promise.all(ordered.map(async (slot) => {
+        const upPath = join(dir, slot.up);
+        const downPath = join(dir, slot.down);
+        return {
+            order: slot.order,
+            name: slot.name,
+            up: await readFile(upPath, "utf8"),
+            down: await readFile(downPath, "utf8"),
+        };
+    }));
+}

package/node_modules/@deterministic-code/datasources-code-generators/dist/sql/common/datasource-by-fields.d.ts

@@ -0,0 +1,3 @@
+/** Unique fields + unique indexes → `ByProperties` groups including the primary key. */
+import { type SqlTable } from "./sql-schema.js";
+export declare const byGroupsFromDatasource: (types: SqlTable[]) => Map<string, string[][]>;

package/node_modules/@deterministic-code/datasources-code-generators/dist/sql/common/datasource-by-fields.js

@@ -0,0 +1,38 @@
+/** Unique fields + unique indexes → `ByProperties` groups including the primary key. */
+import { pkName } from "@deterministic-code/generators-common/spec-types";
+import { overlayOf } from "./sql-schema.js";
+const uniqueLookupFields = (type) => {
+    const overlay = overlayOf(type);
+    const names = [];
+    const add = (name) => {
+        if (!names.includes(name))
+            names.push(name);
+    };
+    for (const field of overlay.fields)
+        if (field.isUnique === true)
+            add(field.name);
+    for (const name of overlay.uniqueIndexFields)
+        add(name);
+    return names;
+};
+const same = (left, right) => left.length === right.length && left.every((name, index) => name === right[index]);
+export const byGroupsFromDatasource = (types) => new Map(types.map((type) => {
+    const overlay = overlayOf(type);
+    const pk = pkName(type, overlay);
+    const groups = pk === undefined ? [] : [[pk]];
+    const add = (props) => {
+        if (props.length === 0)
+            return;
+        if (groups.some((group) => same(group, props)))
+            return;
+        groups.push(props);
+    };
+    for (const name of uniqueLookupFields(type)) {
+        if (name !== pk)
+            add([name]);
+    }
+    for (const index of type.indexes.filter((item) => item.isUnique)) {
+        add(index.fields);
+    }
+    return [type.name, groups];
+}));

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

@@ -0,0 +1,20 @@
+import { type ICasingStrategy } from "@deterministic-code/generators-common/casing-strategy";
+export type PackCasing = ICasingStrategy & {
+    isVerbatim: (mapping: string) => boolean;
+    tableName: (entity: string) => string;
+    /** Always-plural routine English (`find_contacts`); ignores the table flag. */
+    pluralTableName: (entity: string) => string;
+    /** Snake plural stem for routine names (`notification_types`). */
+    pluralStem: (entity: string) => string;
+    columnName: (field: string) => string;
+    constraintName: (entity: string, ...parts: string[]) => string;
+    triggerName: (entity: string) => string;
+    routineName: (stem: string) => string;
+    fileBase: (stem: string) => string;
+    filePath: (stem: string) => string;
+    directory: (entity: string) => string;
+    keyword: (text: string) => string;
+    applyKeywords: (sql: string) => string;
+};
+/** Datasource naming + SQL-only keyword/object letter-case. */
+export declare const createCasing: (settings: Record<string, string>) => PackCasing;

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

@@ -0,0 +1,64 @@
+import { createCasingStrategy, } from "@deterministic-code/generators-common/casing-strategy";
+import { createDatasourceNaming } from "@deterministic-code/generators-common/datasource-naming";
+import { applyKeywordCasing } from "./sql-keywords.js";
+const DATASOURCE_CASING = "datasource.casing";
+const UPPER_LOWER = ["upper", "lower"];
+const parseUpperLower = (raw, path, fallback) => {
+    if (raw === undefined || raw === "")
+        return fallback;
+    const parsed = raw.toLowerCase();
+    if (parsed === "auto")
+        return fallback;
+    if (parsed === "upper" || parsed === "lower")
+        return parsed;
+    throw new Error(`${path} must be one of [${UPPER_LOWER.join(", ")}] (got "${raw}").`);
+};
+const letterCase = (text, format) => format === "upper"
+    ? text.toUpperCase()
+    : format === "lower"
+        ? text.toLowerCase()
+        : text;
+/** Datasource naming + SQL-only keyword/object letter-case. */
+export const createCasing = (settings) => {
+    const naming = createDatasourceNaming(settings);
+    const alwaysPlural = createDatasourceNaming({
+        ...settings,
+        "datasource.pluralize_datatable_names": "true",
+    });
+    const casing = createCasingStrategy("sql", settings, {
+        prefix: DATASOURCE_CASING,
+    });
+    const keywordFormat = parseUpperLower(settings[`${DATASOURCE_CASING}.keywords`], `${DATASOURCE_CASING}.keywords`, "upper");
+    const objectFormat = parseUpperLower(settings[`${DATASOURCE_CASING}.objects`], `${DATASOURCE_CASING}.objects`, "preserve");
+    const keyword = (text) => letterCase(text, keywordFormat);
+    const objectName = (text) => letterCase(text, objectFormat);
+    const objectIdent = (stem, converted) => naming.isVerbatim(stem) ? converted : objectName(converted);
+    const fileBase = (stem) => casing.convertFileName(stem);
+    const trigger = (entity, suffix) => {
+        const stem = naming.physicalStem(entity);
+        return naming.isVerbatim(entity)
+            ? `trg_${entity}_${suffix}`
+            : objectName(naming.tableName(`trg_${stem}_${suffix}`));
+    };
+    return {
+        convertFileName: (text) => casing.convertFileName(text),
+        convertTypes: (text) => casing.convertTypes(text),
+        convertFields: (text) => casing.convertFields(text),
+        convertDirectories: (text) => casing.convertDirectories(text),
+        isVerbatim: naming.isVerbatim,
+        tableName: (entity) => objectIdent(entity, naming.resolveTable(entity)),
+        pluralTableName: (entity) => objectIdent(entity, alwaysPlural.resolveTable(entity)),
+        pluralStem: (entity) => alwaysPlural.physicalStem(entity),
+        columnName: (field) => naming.resolveColumn(field),
+        constraintName: (entity, ...parts) => naming.isVerbatim(entity)
+            ? [entity, ...parts].join("_")
+            : objectName(naming.tableName([naming.physicalStem(entity), ...parts].join("_"))),
+        triggerName: (entity) => trigger(entity, "updated_at"),
+        routineName: (stem) => objectIdent(stem, naming.tableName(stem)),
+        fileBase,
+        filePath: (stem) => `${fileBase(stem)}.sql`,
+        directory: (entity) => casing.convertDirectories(entity),
+        keyword,
+        applyKeywords: (sql) => keywordFormat === "lower" ? applyKeywordCasing(sql, keyword) : sql,
+    };
+};

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

@@ -0,0 +1,6 @@
+interface CustomMigrationFile {
+    filename: string;
+    content: string;
+}
+export declare function buildCustomMigrationFiles(deterministicDir: string, dialect: string): Promise<CustomMigrationFile[]>;
+export {};

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

@@ -0,0 +1,25 @@
+import { readCustomMigrationPairs } from "./custom-migrations-source.js";
+const CUSTOM_TOKEN = "_custom_";
+function generatedFilenameForCustom(order, name, direction) {
+    if (!Number.isInteger(order) || order < 1 || order > 999) {
+        throw new Error(`generatedFilenameForCustom: order must be an integer in [1, 999], got ${order}`);
+    }
+    if (direction !== "up" && direction !== "down") {
+        throw new Error(`generatedFilenameForCustom: direction must be "up" or "down", got "${direction}"`);
+    }
+    const stamp = String(order).padStart(10, "0");
+    return `${stamp}${CUSTOM_TOKEN}${String(order).padStart(3, "0")}_${name}_${direction}.sql`;
+}
+export async function buildCustomMigrationFiles(deterministicDir, dialect) {
+    const pairs = await readCustomMigrationPairs(deterministicDir, dialect);
+    return pairs.flatMap((pair) => [
+        {
+            filename: generatedFilenameForCustom(pair.order, pair.name, "up"),
+            content: pair.up,
+        },
+        {
+            filename: generatedFilenameForCustom(pair.order, pair.name, "down"),
+            content: pair.down,
+        },
+    ]);
+}

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

@@ -0,0 +1,14 @@
+import type { IStatement } from "@deterministic-code/datasources";
+import type { GenerateContext } from "@deterministic-code/generators-common/generate-context";
+import { type GenerateEntry } from "@deterministic-code/generators-common/generate-entry";
+import { type PackCasing } from "./default-casing.js";
+import { SqlMapping } from "./sql-mapping.js";
+import { type SqlDialect } from "./sql-dialect.js";
+import { type LiveTable } from "./sql-schema.js";
+/** Create / read / update / delete / bulk procedure statements for one live table. */
+export declare const procedureStatementsForTable: (dialect: SqlDialect, t: LiveTable, mapping: SqlMapping, casing: PackCasing, groups: string[][]) => {
+    statements: IStatement[];
+    names: string[];
+};
+/** Stored-procedure migration — empty when the driver does not render routines. */
+export declare const generateProceduresForDialect: (dialect: SqlDialect, ctx: GenerateContext, order?: number) => Promise<GenerateEntry[]>;