@deterministic-code/datasources-cli 0.1.10 → 0.1.12

package/dist/generate/CSharpRepositories.js

@@ -7,7 +7,29 @@ import {
   pluralPascal,
   repositoryFile
 } from "./RepositoryModel.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)}"`;
@@ -45,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());`;
+        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());
+        var repo = new ReadonlyRepository<${type}>(connection, ${optionsCall(model)});
 ${locals.join("\n")}
 ${enrich.join("\n")}
         return repo;
@@ -69,17 +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()) { }` : `    public ${model.typeName}Repository(IConnection connection) : base(connection, Options())
+    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 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(
@@ -93,13 +109,7 @@ ${fields.length === 0 ? "" : `${fields.join("\n")}
 
 ${createReadonly(model, type)}
 ${occMethods(model, type)}
-    static CRUDRepositoryOptions<${type}> Options() => new()
-    {
-        Entity = "${quote(model.entity)}",
-        EntityMapper = new DictionaryMapper<string>(new Dictionary<string, string> { ["${quote(model.entity)}"] = "${quote(model.table)}" }),
-${mapping}        Ids = [${ids}],
-        ReadProperties = [${read}],
-    };
+${optionsMethod(model, type)}
 }
 `
     );

package/dist/generate/DeterministicProvider.js

@@ -10,6 +10,7 @@ import { csharpRepositories } from "./CSharpRepositories.js";
 import { rustRepositories } from "./RustRepositories.js";
 import { typescriptRepositories } from "./TypeScriptRepositories.js";
 import { planRepositories } from "./RepositoryPlan.js";
+import { datasourceEnginesOf, engineDatasourceOf, overlayDatasource } from "./datasourceYaml.js";
 const place = (dir, entries) => entries.map((entry) => ({ ...entry, filename: `${dir}/${entry.filename}` }));
 const typePacks = {
   csharp: { datasource: csharpDatasourceTypes, views: csharpViewTypes },
@@ -22,6 +23,35 @@ 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)) {
+    const yaml = await engineDatasourceOf(request.reader, engine);
+    if (yaml === void 0) continue;
+    byProvider[engine] = planRepositories(
+      await DeterministicParser(overlayDatasource(request.reader, yaml)).parse(request.settings),
+      request.dialect,
+      request.settings
+    );
+  }
+  return Object.keys(byProvider).length === 0 ? models : models.map((model) => ({
+    ...model,
+    optionsByProvider: Object.fromEntries(
+      Object.entries(byProvider).map(([engine, planned]) => [
+        engine,
+        optionsOf(planned.find((item) => item.specName === model.specName) ?? model)
+      ])
+    )
+  }));
+};
 const dialectsOf = (settings) => {
   const out = [];
   for (const name of (settings["backend.datasources"] ?? "").split(",")) {
@@ -44,7 +74,11 @@ const deterministic = {
   },
   generateRepositories: async (request) => {
     const spec = await DeterministicParser(request.reader).parse(request.settings);
-    return place(`${request.dialect}/repositories`, repositoryPacks[request.dialect](planRepositories(spec, request.dialect, request.settings), request.settings));
+    const models = planRepositories(spec, request.dialect, request.settings);
+    return place(
+      `${request.dialect}/repositories`,
+      repositoryPacks[request.dialect](await withProviderWrites(request, models), request.settings)
+    );
   },
   generateDatasource: async (request) => place("sql", await generateSql(context(request), dialectsOf(request.settings)))
 };

package/dist/generate/RepositoryPlan.js

@@ -1,6 +1,7 @@
 import { createCasingStrategy } from "@deterministic-code/generators-common/casing-strategy";
 import { createDatasourceNaming } from "@deterministic-code/generators-common/datasource-naming";
 import { identityColumns, isCollectionField, persistedColumnFields } from "@deterministic-code/generators-common/spec-types";
+import { writeInclusionOf } from "@deterministic-code/datasources-code-generators/sql/common/write-inclusion";
 const referenceOf = (references) => {
   if (references === void 0) return void 0;
   const [type, field] = [references].flat().join(".").split(".");
@@ -70,6 +71,12 @@ const planRepositories = (spec, dialect, settings) => {
         }),
         ids: identityColumns(tableType, table).map(property),
         readProperties: columns.map((field) => property(field.name)),
+        createProperties: columns.filter(
+          (field) => writeInclusionOf(field, identityColumns(tableType, table), overlays.get(field.name)).includeInCreate
+        ).map((field) => property(field.name)),
+        updateProperties: columns.filter(
+          (field) => writeInclusionOf(field, identityColumns(tableType, table), overlays.get(field.name)).includeInUpdate
+        ).map((field) => property(field.name)),
         optimisticConcurrency: concurrencyToken(table, tableType, property),
         enrichments: relations(authored, full, casing, types, expanded, repoName, identity)
       }

package/dist/generate/RustRepositories.js

@@ -1,21 +1,39 @@
 import { content } from "@deterministic-code/generators-common/generate-entry";
 import { childField, children as childModels, isLinked, pluralSnake, repositoryFile } from "./RepositoryModel.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(", ")}];`;
+  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")}
@@ -162,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)}
@@ -180,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} {
@@ -190,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,7 +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";
-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)}"`;
@@ -12,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});`;
@@ -56,11 +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 read = `readProperties: [${model.readProperties.map((name) => `"${quote(name)}"`).join(", ")}] }`;
-    const crudOptions = `${head}ids: [${model.ids.map((id) => `"${quote(id)}"`).join(", ")}], ${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 = [
@@ -68,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/datasourceYaml.js

@@ -0,0 +1,22 @@
+const known = ["sqlite", "mysql", "postgres", "sqlserver", "oracle"];
+const overlayDatasource = (reader, yaml) => ({
+  read: (name) => name === "datasource.yaml" ? Promise.resolve(yaml) : reader.read(name),
+  exists: (name) => name === "datasource.yaml" ? Promise.resolve(true) : reader.exists(name)
+});
+const engineDatasourceOf = async (reader, engine) => await reader.exists(`datasource.${engine}.yaml`) ? reader.read(`datasource.${engine}.yaml`) : void 0;
+const datasourceEnginesOf = async (reader, settings) => {
+  const engines = /* @__PURE__ */ new Set();
+  for (const name of (settings["backend.datasources"] ?? "").split(",")) {
+    const key = name.trim();
+    if (key !== "") engines.add(key);
+  }
+  for (const name of known) {
+    if (await reader.exists(`datasource.${name}.yaml`)) engines.add(name);
+  }
+  return [...engines];
+};
+export {
+  datasourceEnginesOf,
+  engineDatasourceOf,
+  overlayDatasource
+};

package/dist/generate/loadSpec.js

@@ -22,8 +22,13 @@ const loadSpec = async (fs, dir) => {
     if (text !== void 0) files[name] = text;
   }
   if (files["types.yaml"] === void 0) throw new Error(`missing types.yaml in ${dir}`);
-  files["datasource.yaml"] ??= defaultDatasourceYaml;
   const names = await fs.readdir(dir).catch(() => []);
+  for (const name of names) {
+    if (!/^datasource\.[a-z0-9]+\.yaml$/.test(name)) continue;
+    const text = await readOptional(fs, join(dir, name));
+    if (text !== void 0) files[name] = text;
+  }
+  files["datasource.yaml"] ??= files["datasource.sqlite.yaml"] ?? defaultDatasourceYaml;
   const diffs = names.filter((name) => versionDir.test(name)).sort();
   const versionFiles = [];
   for (const name of diffs) {

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

@@ -0,0 +1,19 @@
+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 writeList = (dialect, names) => dialect === "csharp" ? csharpList(names) : dialect === "typescript" ? tsList(names) : rustList(names);
+export {
+  dialectsOf,
+  pad,
+  quote,
+  writeList
+};

package/dist/parse.js

@@ -3,7 +3,7 @@ import { isDialect } from "./generate/GenerateRequest.js";
 const generateTargets = ["all", "types", "repositories", "datasource"];
 const help = `Usage: datasources <command> [options]
 
-setup                 Interactive .env, provider install, and optional deterministic/
+setup [provider...]   Interactive .env, provider install, and optional deterministic/
   --cwd <dir>                 Consumer project directory (default: .)
   --ecosystem ts|rust|csharp  Required when more than one project type exists
   --dry-run                   Print package-manager commands without running them
@@ -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");
@@ -88,7 +92,7 @@ const parseArgs = (argv, cwd = ".") => {
 };
 const commandOf = (verb, names, generate) => {
   if (verb === void 0 || verb === "help") return { kind: "help" };
-  if (verb === "setup") return { kind: "setup" };
+  if (verb === "setup") return { kind: "setup", providers: names };
   if (verb === "add") return { kind: "add", providers: names };
   if (verb === "remove") return { kind: "remove", providers: names };
   if (verb === "generate") return generateCommand(names, generate);
@@ -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

@@ -3,12 +3,7 @@ import { join } from "node:path";
 import { catalog, requireProviders } from "./catalog.js";
 import { addCommands, removeCommands } from "./commands.js";
 import { csharpTarget, detect, resolveEcosystem } from "./detect.js";
-import {
-  answersFromEnv,
-  parseEnv,
-  serializeEnv,
-  updateEnvProviders
-} from "./env.js";
+import { parseEnv, serializeEnv, updateEnvProviders } from "./env.js";
 import { defaultDatasourceYaml } from "./generate/loadSpec.js";
 import {
   cargoProviders,
@@ -21,7 +16,7 @@ import { applyMigrateUp } from "./generate/migrateUp.js";
 import { migrateInitCommands, migrateLanguage, sqlMigrateProviders } from "./migrateInit.js";
 import { help, parseArgs } from "./parse.js";
 import { applyVersion } from "./version/applyVersion.js";
-import { envFromAnswers, promptSetup, starterTypesYaml } from "./setup.js";
+import { answersForSetup, envFromAnswers, promptSetup, starterTypesYaml } from "./setup.js";
 import { wireRegister } from "./wireRegister.js";
 const run = async (argv, deps, cwd = ".") => {
   try {
@@ -35,7 +30,7 @@ const run = async (argv, deps, cwd = ".") => {
 };
 const dispatch = async (command, flags, deps) => {
   if (command.kind === "help") return deps.log(help.trimEnd());
-  if (command.kind === "setup") return applySetup(flags, deps);
+  if (command.kind === "setup") return applySetup(flags, deps, command.providers);
   if (command.kind === "add") return applyAddRemove(flags, deps, requireProviders(needNames(command.providers, "add")), []);
   if (command.kind === "remove") return applyAddRemove(flags, deps, [], requireProviders(needNames(command.providers, "remove")));
   if (command.kind === "version") return applyVersion(command, flags, deps);
@@ -48,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 }
       },
@@ -59,7 +55,7 @@ const dispatch = async (command, flags, deps) => {
 const needNames = (names, verb) => names.length ? names : (() => {
   throw new Error(`Usage: datasources ${verb} <provider...>`);
 })();
-const applySetup = async (flags, deps) => {
+const applySetup = async (flags, deps, requested) => {
   const entries = await deps.fs.readdir(flags.cwd);
   const found = detect(entries);
   const existing = await readEnv(deps.fs, flags.cwd);
@@ -67,7 +63,7 @@ const applySetup = async (flags, deps) => {
   const typesPath = join(specDir, "types.yaml");
   const datasourcePath = join(specDir, "datasource.yaml");
   const missingSpec = await optional(deps.fs, typesPath) === void 0;
-  const answers = flags.yes ? { ...answersFromEnv(existing), ecosystem: flags.ecosystem, scaffold: false } : await promptSetup(deps.prompt, existing, found, flags.ecosystem, missingSpec);
+  const answers = flags.yes ? { ...answersForSetup(existing, requested), ecosystem: flags.ecosystem, scaffold: false } : await promptSetup(deps.prompt, existing, found, flags.ecosystem, missingSpec, requested);
   const ecosystem = resolveEcosystem(found, answers.ecosystem ?? flags.ecosystem);
   const selected = requireProviders(answers.providers);
   const installed = await readInstalled(deps.fs, flags.cwd, ecosystem, entries);

package/dist/setup.js

@@ -14,8 +14,9 @@ types:
             type: string
             size: 128
 `;
-const promptSetup = async (prompt, env, found, explicit, askScaffold = false) => {
-  const defaults = answersFromEnv(env);
+const answersForSetup = (env, requested = []) => requested.length ? answersFromEnv({ ...env, INSTALLED_PROVIDERS: requested.join(",") }) : answersFromEnv(env);
+const promptSetup = async (prompt, env, found, explicit, askScaffold = false, requested = []) => {
+  const defaults = answersForSetup(env, requested);
   const ecosystem = explicit ?? (found.length === 1 ? found[0] : found.length === 0 ? void 0 : ecosystemOr(await prompt.select({
     message: "Project type",
     choices: found.map((value) => ({ name: value, value })),
@@ -48,6 +49,7 @@ const envFromAnswers = (answers) => {
   };
 };
 export {
+  answersForSetup,
   envFromAnswers,
   promptSetup,
   starterTypesYaml

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);