@deterministic-code/datasources-cli 0.1.11 → 0.1.13

package/dist/generate/CSharpRepositories.js

@@ -7,8 +7,29 @@ import {
   pluralPascal,
   repositoryFile
 } from "./RepositoryModel.js";
-import { writeList } from "./writeLists.js";
-const quote = (value) => value.replaceAll("\\", "\\\\").replaceAll('"', '\\"');
+import { dialectsOf, pad, quote, writeList } from "./writeLists.js";
+const csharpOptionsBody = (model) => `Entity = "${quote(model.entity)}",
+EntityMapper = new DictionaryMapper<string>(new Dictionary<string, string> { ["${quote(model.entity)}"] = "${quote(model.table)}" }),
+PropertyMappings = new DictionaryMapper<string>(new Dictionary<string, string>
+{
+${model.propertyMappings.map((pair) => `    ["${quote(pair.from)}"] = "${quote(pair.to)}",`).join("\n")}
+}),
+Ids = ${writeList("csharp", model.ids)},
+ReadProperties = ${writeList("csharp", model.readProperties)},
+CreateProperties = ${writeList("csharp", model.createProperties)},
+UpdateProperties = ${writeList("csharp", model.updateProperties)},`;
+const csharpOptions = (model, indent) => `new()
+${" ".repeat(indent)}{
+${pad(csharpOptionsBody(model), indent + 4)}
+${" ".repeat(indent)}}`;
+const optionsMethod = (model, type) => {
+  const dialects = dialectsOf(model);
+  return dialects.length === 0 ? `    static CRUDRepositoryOptions<${type}> Options() => ${csharpOptions(model, 4)};` : `    static CRUDRepositoryOptions<${type}> Options(IConnection connection) =>
+        new CRUDRepositoryBuilder<${type}>()
+            .Add(${csharpOptions(model, 12)})${dialects.map(([engine, planned]) => `
+            .Add("${quote(engine)}", ${csharpOptions({ entity: model.entity, ...planned }, 12)})`).join("")}
+            .For(connection);`;
+};
 const enrichment = (item, host = "ctor") => {
   const via = childField("csharp", item.via, item.viaType);
   const head = `"${quote(item.destination)}", "${quote(item.source)}", "${quote(item.relatedKey)}"`;
@@ -46,16 +67,17 @@ const occMethods = (model, type) => {
     }
 `;
 };
+const optionsCall = (model) => dialectsOf(model).length === 0 ? "Options()" : "Options(connection)";
 const createReadonly = (model, type) => {
   const children = childModels(model);
   if (children.length === 0 && model.enrichments.length === 0)
     return `    public static IReadonlyRepository<${type}> CreateReadonly(IConnection connection) =>
-        new ReadonlyRepository<${type}>(connection, Options(connection));`;
+        new ReadonlyRepository<${type}>(connection, ${optionsCall(model)});`;
   const locals = children.map((child) => `        var ${childField("csharp", child.specName, child.typeName)} = new ${childClass(child.typeName)}(connection);`);
   const enrich = model.enrichments.map((item) => `        ${enrichment(item, "readonly")}`);
   return `    public static IReadonlyRepository<${type}> CreateReadonly(IConnection connection)
     {
-        var repo = new ReadonlyRepository<${type}>(connection, Options(connection));
+        var repo = new ReadonlyRepository<${type}>(connection, ${optionsCall(model)});
 ${locals.join("\n")}
 ${enrich.join("\n")}
         return repo;
@@ -70,19 +92,10 @@ const csharpRepositories = (models) => {
       ...children.map((child) => `        ${childField("csharp", child.specName, child.typeName)} = new ${childClass(child.typeName)}(connection);`),
       ...model.enrichments.map((item) => `        ${enrichment(item)}`)
     ];
-    const mapping = `        PropertyMappings = new DictionaryMapper<string>(new Dictionary<string, string>
-        {
-${model.propertyMappings.map((pair) => `            ["${quote(pair.from)}"] = "${quote(pair.to)}",`).join("\n")}
-        }),
-`;
-    const constructor = lines.length === 0 ? `    public ${model.typeName}Repository(IConnection connection) : base(connection, Options(connection)) { }` : `    public ${model.typeName}Repository(IConnection connection) : base(connection, Options(connection))
+    const constructor = lines.length === 0 ? `    public ${model.typeName}Repository(IConnection connection) : base(connection, ${optionsCall(model)}) { }` : `    public ${model.typeName}Repository(IConnection connection) : base(connection, ${optionsCall(model)})
     {
 ${lines.join("\n")}
     }`;
-    const ids = model.ids.map((name) => `"${quote(name)}"`).join(", ");
-    const read = model.readProperties.map((name) => `"${quote(name)}"`).join(", ");
-    const create = writeList("csharp", model, "create");
-    const update = writeList("csharp", model, "update");
     const implementsOcc = model.optimisticConcurrency === void 0 ? "" : `, ICRUDRepository<${type}>`;
     const usings = model.optimisticConcurrency === void 0 ? "using Datasources;\n" : "using Datasources;\nusing static Datasources.Cmp;\n";
     return content(
@@ -96,15 +109,7 @@ ${fields.length === 0 ? "" : `${fields.join("\n")}
 
 ${createReadonly(model, type)}
 ${occMethods(model, type)}
-    static CRUDRepositoryOptions<${type}> Options(IConnection connection) => new()
-    {
-        Entity = "${quote(model.entity)}",
-        EntityMapper = new DictionaryMapper<string>(new Dictionary<string, string> { ["${quote(model.entity)}"] = "${quote(model.table)}" }),
-${mapping}        Ids = [${ids}],
-        ReadProperties = [${read}],
-        CreateProperties = ${create},
-        UpdateProperties = ${update},
-    };
+${optionsMethod(model, type)}
 }
 `
     );

package/dist/generate/DeterministicProvider.js

@@ -23,6 +23,14 @@ const repositoryPacks = {
   rust: rustRepositories
 };
 const context = (request) => ({ reader: request.reader, settings: request.settings });
+const optionsOf = (model) => ({
+  table: model.table,
+  ids: model.ids,
+  readProperties: model.readProperties,
+  createProperties: model.createProperties,
+  updateProperties: model.updateProperties,
+  propertyMappings: model.propertyMappings
+});
 const withProviderWrites = async (request, models) => {
   const byProvider = {};
   for (const engine of await datasourceEnginesOf(request.reader, request.settings)) {
@@ -36,17 +44,11 @@ const withProviderWrites = async (request, models) => {
   }
   return Object.keys(byProvider).length === 0 ? models : models.map((model) => ({
     ...model,
-    writesByProvider: Object.fromEntries(
-      Object.entries(byProvider).map(([engine, planned]) => {
-        const found = planned.find((item) => item.specName === model.specName);
-        return [
-          engine,
-          {
-            create: found?.createProperties ?? model.createProperties,
-            update: found?.updateProperties ?? model.updateProperties
-          }
-        ];
-      })
+    optionsByProvider: Object.fromEntries(
+      Object.entries(byProvider).map(([engine, planned]) => [
+        engine,
+        optionsOf(planned.find((item) => item.specName === model.specName) ?? model)
+      ])
     )
   }));
 };

package/dist/generate/RustRepositories.js

@@ -1,24 +1,39 @@
 import { content } from "@deterministic-code/generators-common/generate-entry";
 import { childField, children as childModels, isLinked, pluralSnake, repositoryFile } from "./RepositoryModel.js";
-import { writeList } from "./writeLists.js";
-const rustString = (value) => `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
-const uses = `use datasources::{Association, Connection, CRUDRepository, CRUDRepositoryOptions, DictionaryMapper, Enrichment, EnrichmentPropertyType, ICRUDRepository, ReadonlyRepository, ReadonlyRepositoryMappingOptions, Result};
+import { dialectsOf, pad, quote, writeList } from "./writeLists.js";
+const rustString = (value) => `"${quote(value)}"`;
+const uses = (model) => dialectsOf(model).length === 0 ? `use datasources::{Association, Connection, CRUDRepository, CRUDRepositoryOptions, DictionaryMapper, Enrichment, EnrichmentPropertyType, ICRUDRepository, ReadonlyRepository, ReadonlyRepositoryMappingOptions, Result};
+use std::sync::Arc;` : `use datasources::{Association, Connection, CRUDRepository, CRUDRepositoryBuilder, CRUDRepositoryOptions, DictionaryMapper, Enrichment, EnrichmentPropertyType, ICRUDRepository, ReadonlyRepository, ReadonlyRepositoryMappingOptions, Result};
 use std::sync::Arc;`;
-const crudOptions = (model) => {
-  const mapping = model.propertyMappings.length === 0 ? "" : `    options.property_mappings = Some(Arc::new(DictionaryMapper::new([
-${model.propertyMappings.map((pair) => `        (${rustString(pair.from)}.into(), ${rustString(pair.to)}.into()),`).join("\n")}
-    ])));
+const rustFill = (model) => {
+  const mapping = model.propertyMappings.length === 0 ? "" : `options.property_mappings = Some(Arc::new(DictionaryMapper::new([
+${model.propertyMappings.map((pair) => `    (${rustString(pair.from)}.into(), ${rustString(pair.to)}.into()),`).join("\n")}
+])));
 `;
-  return `    let mut options = CRUDRepositoryOptions::default();
-    options.entity = ${rustString(model.entity)}.into();
-    options.entity_mapper = Some(Arc::new(DictionaryMapper::new([
-        (${rustString(model.entity)}.into(), ${rustString(model.table)}.into()),
-    ])));
-${mapping}    options.ids = vec![${model.ids.map((id) => `${rustString(id)}.into()`).join(", ")}];
-    options.read_properties = vec![${model.readProperties.map((name) => `${rustString(name)}.into()`).join(", ")}];
-    options.create_properties = Some(${writeList("rust", model, "create")});
-    options.update_properties = Some(${writeList("rust", model, "update")});`;
+  return `let mut options = CRUDRepositoryOptions::default();
+options.entity = ${rustString(model.entity)}.into();
+options.entity_mapper = Some(Arc::new(DictionaryMapper::new([
+    (${rustString(model.entity)}.into(), ${rustString(model.table)}.into()),
+])));
+${mapping}options.ids = ${writeList("rust", model.ids)};
+options.read_properties = ${writeList("rust", model.readProperties)};
+options.create_properties = Some(${writeList("rust", model.createProperties)});
+options.update_properties = Some(${writeList("rust", model.updateProperties)});`;
+};
+const rustBlock = (model) => {
+  const dialects = dialectsOf(model);
+  return dialects.length === 0 ? rustFill(model) : `let options = CRUDRepositoryBuilder::new()
+    .add({
+${pad(rustFill(model), 8)}
+        options
+    })${dialects.map(([engine, planned]) => `
+    .add_for(${rustString(engine)}, {
+${pad(rustFill({ entity: model.entity, ...planned }), 8)}
+        options
+    })`).join("")}
+    .for_connection(connection.as_ref())?;`;
 };
+const crudOptions = (model) => pad(rustBlock(model), 4);
 const readonlyOptions = (model) => {
   const mapping = model.propertyMappings.length === 0 ? "" : `    options.property_mappings = Some(Arc::new(DictionaryMapper::new([
 ${model.propertyMappings.map((pair) => `        (${rustString(pair.from)}.into(), ${rustString(pair.to)}.into()),`).join("\n")}
@@ -165,8 +180,7 @@ ${where}
 }
 `;
 };
-const pad = (text) => text.split("\n").map((line) => `    ${line}`).join("\n");
-const plain = (model, nested) => `${uses}
+const plain = (model, nested) => `${uses(model)}
 
 pub fn ${model.specName}_repository(connection: Arc<dyn Connection>) -> Result<CRUDRepository> {
 ${crudOptions(model)}
@@ -183,7 +197,7 @@ const wrapped = (model, nested) => {
   ).join("\n");
   const assign = children.map((child) => child.specName).join(", ");
   const enrich = model.enrichments.map((item) => `        ${enrichment(item, true, nested)}`).join("\n");
-  return `${uses}
+  return `${uses(model)}
 use std::ops::Deref;
 
 pub struct ${type} {
@@ -193,7 +207,7 @@ ${fields}
 
 impl ${type} {
     pub fn new(connection: Arc<dyn Connection>) -> Result<Self> {
-${pad(crudOptions(model))}
+${pad(crudOptions(model), 4)}
 ${childLets(children, nested)}
         let mut repo = CRUDRepository::new(Arc::clone(&connection), options)?;
 ${enrich}

package/dist/generate/TypeScriptRepositories.js

@@ -1,8 +1,23 @@
 import { createCasingStrategy } from "@deterministic-code/generators-common/casing-strategy";
 import { content } from "@deterministic-code/generators-common/generate-entry";
 import { childClass, childField, children as childModels, isLinked, pluralCamel, repositoryFile } from "./RepositoryModel.js";
-import { writeList } from "./writeLists.js";
-const quote = (value) => value.replaceAll("\\", "\\\\").replaceAll('"', '\\"');
+import { dialectsOf, quote, writeList } from "./writeLists.js";
+const withEntity = (model, planned) => ({ entity: model.entity, ...planned });
+const entityAndMapping = (model) => {
+  const mapping = model.propertyMappings.length === 0 ? "" : `propertyMappings: new DictionaryMapper([${model.propertyMappings.map((pair) => `["${quote(pair.from)}", "${quote(pair.to)}"]`).join(", ")}]), `;
+  return `entity: "${quote(model.entity)}", entityMapper: new DictionaryMapper([["${quote(model.entity)}", "${quote(model.table)}"]]), ${mapping}`;
+};
+const tsOptions = (model) => `{ ${entityAndMapping(model)}ids: ${writeList("typescript", model.ids)}, createProperties: ${writeList("typescript", model.createProperties)}, updateProperties: ${writeList("typescript", model.updateProperties)}, readProperties: ${writeList("typescript", model.readProperties)} }`;
+const tsReadonly = (model) => `{ ${entityAndMapping(model)}readProperties: ${writeList("typescript", model.readProperties)} }`;
+const tsOptionsExpr = (model) => dialectsOf(model).length === 0 ? tsOptions(model) : "options(connection)";
+const tsBuilder = (name, model, write) => `const ${name} = (connection: IConnection) =>
+  new CRUDRepositoryBuilder<${model.typeName}>()
+    .add(${write(model)})${dialectsOf(model).map(([engine, planned]) => `
+    .add("${quote(engine)}", ${write(withEntity(model, planned))})`).join("")}
+    .for(connection);
+
+`;
+const tsOptionsFn = (model) => dialectsOf(model).length === 0 ? "" : `${tsBuilder("options", model, tsOptions)}${tsBuilder("readonlyOptions", model, tsReadonly)}`;
 const enrichment = (item, host) => {
   const via = host === "this" ? `this.${childField("typescript", item.via, item.viaType)}` : childField("typescript", item.via, item.viaType);
   const related = item.relatedProperty === void 0 ? "" : `, relatedProperty: "${quote(item.relatedProperty)}"`;
@@ -13,7 +28,8 @@ const enrichment = (item, host) => {
   }
   return `${host}.addEnriched({ destinationProperty: "${quote(item.destination)}", sourceProperty: "${quote(item.source)}", relatedKey: "${quote(item.relatedKey)}"${related}, type: "${type}" }, ${via});`;
 };
-const createReadonly = (model, options) => {
+const createReadonly = (model) => {
+  const options = dialectsOf(model).length === 0 ? tsReadonly(model) : "readonlyOptions(connection)";
   const children = childModels(model);
   if (children.length === 0 && model.enrichments.length === 0)
     return `  static createReadonly = (connection: IConnection) => new ReadonlyRepository<${model.typeName}>(connection, ${options});`;
@@ -57,12 +73,6 @@ const typescriptRepositories = (models, settings) => {
   const files = models.map((model) => {
     const folder = model.typeHome === "view" ? "views" : "datasource";
     const children = childModels(model);
-    const mapping = model.propertyMappings.length === 0 ? "" : `propertyMappings: new DictionaryMapper([${model.propertyMappings.map((pair) => `["${quote(pair.from)}", "${quote(pair.to)}"]`).join(", ")}]), `;
-    const head = `{ entity: "${quote(model.entity)}", entityMapper: new DictionaryMapper([["${quote(model.entity)}", "${quote(model.table)}"]]), ${mapping}`;
-    const writes = `createProperties: ${writeList("typescript", model, "create")}, updateProperties: ${writeList("typescript", model, "update")}`;
-    const read = `readProperties: [${model.readProperties.map((name) => `"${quote(name)}"`).join(", ")}] }`;
-    const crudOptions = `${head}ids: [${model.ids.map((id) => `"${quote(id)}"`).join(", ")}], ${writes}, ${read}`;
-    const readonlyOptions = `${head}${read}`;
     const fields = children.map((child) => `  readonly ${childField("typescript", child.specName, child.typeName)}: ${childClass(child.typeName)};`);
     const wrap = occWrap(model);
     const lines = [
@@ -70,20 +80,21 @@ const typescriptRepositories = (models, settings) => {
       ...model.enrichments.map((item) => `    ${enrichment(item, "this")}`)
     ];
     const imports = children.map((child) => `import { ${childClass(child.typeName)} } from "${repoImport(child.specName)}";`);
-    const core = model.optimisticConcurrency === void 0 ? `import { CRUDRepository, DictionaryMapper, ReadonlyRepository, type IConnection } from "@deterministic-code/datasources";` : `import { CRUDRepository, DatasourceError, DictionaryMapper, eq, ReadonlyRepository, Where, type IConnection } from "@deterministic-code/datasources";`;
+    const builder = dialectsOf(model).length === 0 ? "" : "CRUDRepositoryBuilder, ";
+    const core = model.optimisticConcurrency === void 0 ? `import { CRUDRepository, ${builder}DictionaryMapper, ReadonlyRepository, type IConnection } from "@deterministic-code/datasources";` : `import { CRUDRepository, ${builder}DatasourceError, DictionaryMapper, eq, ReadonlyRepository, Where, type IConnection } from "@deterministic-code/datasources";`;
     return content(
       repositoryFile("typescript", model),
       `import type { ${model.typeName} } from "../types/generated/${folder}/${casing.convertFileName(model.specName)}";
 ${core}
 ${imports.length === 0 ? "" : `${imports.join("\n")}
 `}
-export class ${model.typeName}Repository extends CRUDRepository<${model.typeName}> {
+${tsOptionsFn(model)}export class ${model.typeName}Repository extends CRUDRepository<${model.typeName}> {
 ${fields.length === 0 ? "" : `${fields.join("\n")}
 `}  constructor(connection: IConnection) {
-    super(connection, ${crudOptions});
+    super(connection, ${tsOptionsExpr(model)});
 ${wrap}${lines.length === 0 ? "" : `${lines.join("\n")}
 `}  }
-${createReadonly(model, readonlyOptions)}
+${createReadonly(model)}
 }
 `
     );

package/dist/generate/applyGenerate.js

@@ -2,13 +2,18 @@ import { isAbsolute, join } from "node:path";
 import { memoryReader } from "@deterministic-code/generators-common/deterministic-reader";
 import { loadSpec } from "./loadSpec.js";
 import { providerByName } from "./providers.js";
+import { withStoredProcedures } from "./storedProcedures.js";
 import { writeEntries } from "./writeEntries.js";
 import { wireRegister } from "../wireRegister.js";
 const at = (root, path) => isAbsolute(path) ? path : join(root, path);
 const applyGenerate = async (command, flags, deps) => {
   const provider = providerByName(command.provider);
   const loaded = await loadSpec(deps.fs, at(flags.cwd, command.input));
-  const request = { dialect: command.dialect, reader: memoryReader(loaded.files), settings: loaded.settings };
+  const request = {
+    dialect: command.dialect,
+    reader: memoryReader(loaded.files),
+    settings: withStoredProcedures(loaded.settings, command.storedProcedures)
+  };
   const entries = await {
     all: async () => [
       ...await provider.generateTypes(request),

package/dist/generate/applyMigrations.js

@@ -3,6 +3,7 @@ import { generate as generateSql } from "@deterministic-code/datasources-code-ge
 import { memoryReader } from "@deterministic-code/generators-common/deterministic-reader";
 import { loadSpec } from "./loadSpec.js";
 import { providerByName } from "./providers.js";
+import { withStoredProcedures } from "./storedProcedures.js";
 import { writeEntries } from "./writeEntries.js";
 const at = (root, path) => isAbsolute(path) ? path : join(root, path);
 const afterMigrations = (filename) => filename.replace(/^[^/]+\/migrations\//, "");
@@ -16,7 +17,10 @@ const applyMigrations = async (command, flags, deps) => {
   ];
   if (command.migrationsPath !== void 0 && listed.length > 1)
     throw new Error("--migrations-path requires a single SQL dialect in backend.datasources");
-  const entries = await generateSql({ reader: memoryReader(loaded.files), settings: loaded.settings });
+  const entries = await generateSql({
+    reader: memoryReader(loaded.files),
+    settings: withStoredProcedures(loaded.settings, command.storedProcedures)
+  });
   const remapped = command.migrationsPath === void 0 ? entries : entries.map((entry) => ({ ...entry, filename: afterMigrations(entry.filename) }));
   const root = at(flags.cwd, command.migrationsPath ?? command.migrationsRoot);
   if (flags.dryRun) {

package/dist/generate/storedProcedures.js

@@ -0,0 +1,5 @@
+const key = "datasource.use_stored_procedures";
+const withStoredProcedures = (settings, storedProcedures) => storedProcedures ? { ...settings, [key]: "true" } : settings;
+export {
+  withStoredProcedures
+};

package/dist/generate/writeLists.js

@@ -1,25 +1,19 @@
-const quote = (value) => value.replaceAll("\\", "\\\\").replaceAll('"', '\\"');
-const namesOf = (model, kind) => kind === "create" ? model.createProperties : model.updateProperties;
 const same = (left, right) => left.length === right.length && left.every((name, index) => name === right[index]);
+const samePairs = (left, right) => left.length === right.length && left.every((pair, index) => pair.from === right[index]?.from && pair.to === right[index]?.to);
+const sameOptions = (left, right) => left.table === right.table && same(left.ids, right.ids) && same(left.readProperties, right.readProperties) && same(left.createProperties, right.createProperties) && same(left.updateProperties, right.updateProperties) && samePairs(left.propertyMappings, right.propertyMappings);
+const dialectsOf = (model) => Object.entries(model.optionsByProvider ?? {}).filter(([, planned]) => !sameOptions(model, planned));
+const quote = (value) => value.replaceAll("\\", "\\\\").replaceAll('"', '\\"');
+const pad = (text, spaces) => {
+  const prefix = " ".repeat(spaces);
+  return text.split("\n").map((line) => `${prefix}${line}`).join("\n");
+};
 const csharpList = (names) => `[${names.map((name) => `"${quote(name)}"`).join(", ")}]`;
 const tsList = (names) => `[${names.map((name) => `"${quote(name)}"`).join(", ")}]`;
 const rustList = (names) => `vec![${names.map((name) => `"${quote(name)}".into()`).join(", ")}]`;
-const fallback = (model, kind) => model.writesByProvider?.sqlite?.[kind] ?? namesOf(model, kind);
-const writeList = (dialect, model, kind) => {
-  const by = model.writesByProvider;
-  const listed = namesOf(model, kind);
-  if (by === void 0 || Object.values(by).every((item) => same(item[kind], listed)))
-    return dialect === "csharp" ? csharpList(listed) : dialect === "typescript" ? tsList(listed) : rustList(listed);
-  const fallbackList = fallback(model, kind);
-  return dialect === "csharp" ? `connection.Provider switch
-        {
-${Object.entries(by).filter(([engine]) => engine !== "sqlite").map(([engine, item]) => `            "${quote(engine)}" => ${csharpList(item[kind])},`).join("\n")}
-            _ => ${csharpList(fallbackList)},
-        }` : dialect === "typescript" ? `({ ${Object.entries(by).filter(([engine]) => engine !== "sqlite").map(([engine, item]) => `${engine}: ${tsList(item[kind])}`).join(", ")} }[connection.provider] ?? ${tsList(fallbackList)})` : `match connection.provider() {
-        ${Object.entries(by).filter(([engine]) => engine !== "sqlite").map(([engine, item]) => `${engine === "mysql" || engine === "postgres" ? `"${engine}"` : `"${quote(engine)}"`} => ${rustList(item[kind])},`).join("\n        ")}
-        _ => ${rustList(fallbackList)},
-    }`;
-};
+const writeList = (dialect, names) => dialect === "csharp" ? csharpList(names) : dialect === "typescript" ? tsList(names) : rustList(names);
 export {
+  dialectsOf,
+  pad,
+  quote,
   writeList
 };

package/dist/parse.js

@@ -29,12 +29,14 @@ generate <all|types|repositories|datasource>
   --no-migrate                Skip migrate-up (generate all applies them)
   --migrations-root <dir>     Root prefix for generate all (default: sql)
   --migrations-path <dir>     One migrations directory (single SQL dialect)
+  --stored-procedures         Emit stored-procedure migrations when the dialect can
 
 migrations create     SQL migrations from the spec (migraters layout)
   --provider <name>           Spec provider (default: deterministic)
   --input <dir>               Deterministic project (default: ./deterministic)
   --migrations-root <dir>     Root prefix (default: sql)
   --migrations-path <dir>     One migrations directory (single SQL dialect)
+  --stored-procedures         Emit stored-procedure migrations when the dialect can
 
 version               Snapshot top-level YAML as the next version-*/diff.yaml
   --cwd <dir>                 Consumer project directory (default: .)
@@ -54,6 +56,7 @@ const parseArgs = (argv, cwd = ".") => {
     output: "generated",
     migrations: true,
     migrate: true,
+    storedProcedures: false,
     migrationsRoot: "sql",
     migrationsPath: ""
   };
@@ -76,6 +79,7 @@ const parseArgs = (argv, cwd = ".") => {
     else if (arg.startsWith("--output=")) generate.output = arg.slice("--output=".length);
     else if (arg === "--no-migrations") generate.migrations = false;
     else if (arg === "--no-migrate") generate.migrate = false;
+    else if (arg === "--stored-procedures") generate.storedProcedures = true;
     else if (arg === "--migrations-root") generate.migrationsRoot = take(argv, ++i, "--migrations-root");
     else if (arg.startsWith("--migrations-root=")) generate.migrationsRoot = arg.slice("--migrations-root=".length);
     else if (arg === "--migrations-path") generate.migrationsPath = take(argv, ++i, "--migrations-path");
@@ -105,6 +109,7 @@ ${help}`);
     kind: "migrations-create",
     provider: generate.provider,
     input: generate.input,
+    storedProcedures: generate.storedProcedures,
     migrationsRoot: generate.migrationsRoot,
     ...generate.migrationsPath === "" ? {} : { migrationsPath: generate.migrationsPath }
   };
@@ -130,6 +135,7 @@ ${help}`);
     output: generate.output,
     migrations: generate.migrations,
     migrate: generate.migrate,
+    storedProcedures: generate.storedProcedures,
     migrationsRoot: generate.migrationsRoot,
     ...generate.migrationsPath === "" ? {} : { migrationsPath: generate.migrationsPath }
   };

package/dist/run.js

@@ -43,6 +43,7 @@ const dispatch = async (command, flags, deps) => {
         kind: "migrations-create",
         provider: command.provider,
         input: command.input,
+        storedProcedures: command.storedProcedures,
         migrationsRoot: command.migrationsRoot,
         ...command.migrationsPath === void 0 ? {} : { migrationsPath: command.migrationsPath }
       },

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

@@ -0,0 +1,5 @@
+import { NestedSelectBuilder } from "@deterministic-code/datasources";
+import type { NestedSelectType } from "@deterministic-code/datasources";
+import type { Type } from "@deterministic-code/deterministic-generators-common/parser";
+export declare const nestedSelectFromSpec: (types: readonly Type[], root: string) => NestedSelectType;
+export { NestedSelectBuilder };

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

@@ -0,0 +1,64 @@
+import { ChangeCasingMapper, NestedSelectBuilder, PluralizerMapper } from "@deterministic-code/datasources";
+const pascal = new ChangeCasingMapper("snakeCase", "pascalCase");
+const plural = new PluralizerMapper();
+export const nestedSelectFromSpec = (types, root) => {
+    const tagged = types.some((item) => item.tags?.includes("datasource_type"));
+    const catalog = new Map(types
+        .filter((item) => !tagged || item.tags?.includes("datasource_type"))
+        .map((item) => [item.name, item]));
+    const name = catalog.has(root)
+        ? root
+        : [...catalog.keys()].find((item) => entity(item) === root);
+    if (name === undefined)
+        throw new Error(`Unknown nested select type "${root}"`);
+    return build(catalog.get(name), catalog, new Set());
+};
+export { NestedSelectBuilder };
+const build = (type, catalog, ancestors) => {
+    const next = new Set(ancestors);
+    next.add(type.name);
+    const key = entity(type.fields.find((field) => field.isId)?.name ?? type.ids?.[0] ?? "id");
+    const properties = type.fields
+        .filter((field) => field.references === undefined)
+        .map((field) => entity(field.name));
+    const objects = type.fields.flatMap((field) => {
+        const [table, column] = target(field);
+        if (!table || !catalog.has(table) || next.has(table))
+            return [];
+        return [{
+                name: relationName(field.name, table),
+                kind: "object",
+                from: entity(field.name),
+                to: entity(column),
+                target: build(catalog.get(table), catalog, next),
+            }];
+    });
+    const lists = [...catalog.values()].flatMap((child) => {
+        if (next.has(child.name))
+            return [];
+        return child.fields.flatMap((field) => {
+            const [table, column] = target(field);
+            if (table !== type.name || !column)
+                return [];
+            return [{
+                    name: plural.map(entity(child.name)),
+                    kind: "list",
+                    from: key,
+                    to: entity(field.name),
+                    target: build(child, catalog, next),
+                }];
+        });
+    });
+    return { name: entity(type.name), key, properties, relations: [...objects, ...lists] };
+};
+const target = (field) => {
+    if (Array.isArray(field.references) && field.references.length === 2)
+        return [field.references[0] ?? "", field.references[1] ?? ""];
+    const [table, column] = String(field.references ?? "").split(".");
+    return [table ?? "", column ?? ""];
+};
+const relationName = (field, table) => {
+    const name = entity(field);
+    return name.endsWith("Id") && name.length > 2 ? name.slice(0, -2) : entity(table);
+};
+const entity = (name) => pascal.map(name);

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

@@ -14,5 +14,6 @@ export declare const applyDocument: (before: {
     [path: string]: Json;
 };
 export declare const isObject: (value: Json | undefined) => value is JsonObject;
+/** Keyed lists compare by key. Version diffs append `added` entries and do not store position. */
 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

@@ -80,4 +80,41 @@ const isKeyedCollection = (value) => Array.isArray(value) &&
         typeof item === "object" &&
         !Array.isArray(item) &&
         Object.keys(item).length === 1);
-export const snapshotsEqual = (left, right) => isDeepStrictEqual(left ?? null, right ?? null);
+/** Keyed lists compare by key. Version diffs append `added` entries and do not store position. */
+export const snapshotsEqual = (left, right) => same(left ?? null, right ?? null);
+const same = (left, right) => {
+    if (isKeyedCollection(left) && isKeyedCollection(right))
+        return keyedEqual(left, right);
+    if (isObject(left) && isObject(right))
+        return objectEqual(left, right);
+    if (Array.isArray(left) && Array.isArray(right))
+        return left.length === right.length && left.every((item, index) => same(item, right[index]));
+    return isDeepStrictEqual(left, right);
+};
+const keyedEqual = (left, right) => {
+    const leftMap = uniqueKeyed(left);
+    const rightMap = uniqueKeyed(right);
+    if (leftMap === undefined || rightMap === undefined)
+        return isDeepStrictEqual(left, right);
+    if (leftMap.size !== rightMap.size)
+        return false;
+    for (const [key, value] of leftMap)
+        if (!rightMap.has(key) || !same(value, rightMap.get(key)))
+            return false;
+    return true;
+};
+const uniqueKeyed = (items) => {
+    const map = new Map();
+    for (const entry of items) {
+        const key = Object.keys(entry)[0];
+        if (map.has(key))
+            return undefined;
+        map.set(key, entry[key]);
+    }
+    return map;
+};
+const objectEqual = (left, right) => {
+    const keys = Object.keys(left);
+    return (keys.length === Object.keys(right).length &&
+        keys.every((key) => key in right && same(left[key], right[key])));
+};

package/node_modules/@deterministic-code/datasources-code-generators/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deterministic-code/datasources-code-generators",
-  "version": "0.1.11",
+  "version": "0.1.2",
   "type": "module",
   "exports": {
     ".": "./dist/generateSql.js",
@@ -12,12 +12,12 @@
     "./sql/common/write-inclusion": "./dist/sql/common/write-inclusion.js"
   },
   "dependencies": {
-    "@deterministic-code/datasources": "^0.1.11",
-    "@deterministic-code/datasources-mysql": "^0.1.11",
-    "@deterministic-code/datasources-oracle": "^0.1.11",
-    "@deterministic-code/datasources-postgres": "^0.1.11",
-    "@deterministic-code/datasources-sqlite": "^0.1.11",
-    "@deterministic-code/datasources-sqlserver": "^0.1.11",
+    "@deterministic-code/datasources": "^0.1.12",
+    "@deterministic-code/datasources-mysql": "^0.1.12",
+    "@deterministic-code/datasources-oracle": "^0.1.12",
+    "@deterministic-code/datasources-postgres": "^0.1.12",
+    "@deterministic-code/datasources-sqlite": "^0.1.12",
+    "@deterministic-code/datasources-sqlserver": "^0.1.12",
     "@deterministic-code/deterministic-generators-common": "0.1.0",
     "@deterministic-code/generators-common": "0.0.1",
     "pluralize": "^8.0.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deterministic-code/datasources-cli",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "type": "module",
   "bin": {
     "datasources": "./bin/datasources.mjs"
@@ -13,7 +13,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@deterministic-code/datasources-code-generators": "0.1.11",
+    "@deterministic-code/datasources-code-generators": "0.1.2",
     "@deterministic-code/generators-common": "0.0.1",
     "@deterministic-code/deterministic-generators-common": "0.1.0",
     "@deterministic-code/typescript-generators": "0.0.1",
@@ -21,12 +21,12 @@
     "@deterministic-code/rust-generators": "0.0.1",
     "@deterministic-code/generators-openapi": "0.0.1",
     "@deterministic-code/patch-merger": "0.1.0",
-    "@deterministic-code/datasources": "^0.1.11",
-    "@deterministic-code/datasources-sqlite": "^0.1.11",
-    "@deterministic-code/datasources-mysql": "^0.1.11",
-    "@deterministic-code/datasources-postgres": "^0.1.11",
-    "@deterministic-code/datasources-sqlserver": "^0.1.11",
-    "@deterministic-code/datasources-oracle": "^0.1.11",
+    "@deterministic-code/datasources": "^0.1.12",
+    "@deterministic-code/datasources-sqlite": "^0.1.12",
+    "@deterministic-code/datasources-mysql": "^0.1.12",
+    "@deterministic-code/datasources-postgres": "^0.1.12",
+    "@deterministic-code/datasources-sqlserver": "^0.1.12",
+    "@deterministic-code/datasources-oracle": "^0.1.12",
     "@inquirer/prompts": "^7.8.0",
     "yaml": "^2.6.0",
     "mustache": "^4.2.0",