@deterministic-code/datasources-cli 0.1.12 → 0.1.14

package/dist/detect.js

@@ -1,14 +1,25 @@
+import { host } from "./catalog.js";
 const detect = (entries) => [
   ...entries.includes("package.json") ? ["ts"] : [],
   ...entries.includes("Cargo.toml") ? ["rust"] : [],
   ...entries.some((e) => e.endsWith(".csproj") || e.endsWith(".sln") || e.endsWith(".slnx")) ? ["csharp"] : []
 ];
-const resolveEcosystem = (found, explicit) => {
-  if (explicit) return explicit;
-  if (found.length === 1) return found[0];
-  throw new Error(
-    found.length === 0 ? "No package.json, Cargo.toml, or .csproj/.sln in this directory" : "Multiple project types found. Pass --ecosystem ts|rust|csharp"
-  );
+const resolveLanguages = (found, explicit = []) => explicit.length ? explicit : found.length ? found : (() => {
+  throw new Error("No package.json, Cargo.toml, or .csproj/.sln in this directory");
+})();
+const hasProject = (language, entries) => ({
+  csharp: csharpTarget(entries) !== ".",
+  rust: entries.includes("Cargo.toml"),
+  ts: entries.includes("package.json")
+})[language];
+const missingProject = (language) => ({
+  csharp: `No dotnet packages installed for language csharp. Create a project, or run dotnet add package ${host.csharp.core}.`,
+  rust: `No cargo packages installed for language rust. Create a project, or run cargo add ${host.rust.core}.`,
+  ts: `No npm packages installed for language typescript. Create a project, or run npm install ${host.ts.core}.`
+})[language];
+const requireProjects = (languages, entries) => {
+  const missing = languages.filter((language) => !hasProject(language, entries));
+  if (missing.length) throw new Error(missing.map(missingProject).join("\n"));
 };
 const csharpTarget = (entries) => {
   const projects = entries.filter((e) => e.endsWith(".csproj")).sort();
@@ -18,6 +29,9 @@ const isEcosystem = (value) => value === "ts" || value === "rust" || value === "
 export {
   csharpTarget,
   detect,
+  hasProject,
   isEcosystem,
-  resolveEcosystem
+  missingProject,
+  requireProjects,
+  resolveLanguages
 };

package/dist/generate/CSharpRepositories.js

@@ -1,3 +1,4 @@
+import { createCasingStrategy } from "@deterministic-code/generators-common/casing-strategy";
 import { content } from "@deterministic-code/generators-common/generate-entry";
 import {
   childClass,
@@ -5,6 +6,7 @@ import {
   isLinked,
   children as childModels,
   pluralPascal,
+  registryFile,
   repositoryFile
 } from "./RepositoryModel.js";
 import { dialectsOf, pad, quote, writeList } from "./writeLists.js";
@@ -30,11 +32,11 @@ const optionsMethod = (model, type) => {
             .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 enrichment = (item, casing, host = "ctor") => {
+  const via = childField(casing, item.via);
   const head = `"${quote(item.destination)}", "${quote(item.source)}", "${quote(item.relatedKey)}"`;
   if (host === "ctor" && isLinked(item)) {
-    const link = childField("csharp", item.link, item.linkType);
+    const link = childField(casing, item.link);
     return `AddLinked(new(${head}, Association: new("${quote(item.parentFk)}", "${quote(item.relatedFk)}")), ${via}, ${link});`;
   }
   const related = item.relatedProperty === void 0 ? "" : `, "${quote(item.relatedProperty)}"`;
@@ -68,13 +70,13 @@ const occMethods = (model, type) => {
 `;
 };
 const optionsCall = (model) => dialectsOf(model).length === 0 ? "Options()" : "Options(connection)";
-const createReadonly = (model, type) => {
+const createReadonly = (model, type, casing) => {
   const children = childModels(model);
   if (children.length === 0 && model.enrichments.length === 0)
     return `    public static IReadonlyRepository<${type}> CreateReadonly(IConnection 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")}`);
+  const locals = children.map((child) => `        var ${childField(casing, child.specName)} = new ${childClass(child.typeName)}(connection);`);
+  const enrich = model.enrichments.map((item) => `        ${enrichment(item, casing, "readonly")}`);
   return `    public static IReadonlyRepository<${type}> CreateReadonly(IConnection connection)
     {
         var repo = new ReadonlyRepository<${type}>(connection, ${optionsCall(model)});
@@ -83,14 +85,16 @@ ${enrich.join("\n")}
         return repo;
     }`;
 };
-const csharpRepositories = (models) => {
+const csharpRepositories = (models, settings) => {
+  const casing = createCasingStrategy("csharp", settings);
+  const registryClass = casing.convertTypes("repository_registry");
   const files = models.map((model) => {
     const type = `${model.typeHome === "view" ? "Backend.Types.View" : "Backend.Types.Datasource"}.${model.typeName}`;
     const children = childModels(model);
-    const fields = children.map((child) => `    public ${childClass(child.typeName)} ${childField("csharp", child.specName, child.typeName)} { get; }`);
+    const fields = children.map((child) => `    public ${childClass(child.typeName)} ${childField(casing, child.specName)} { get; }`);
     const lines = [
-      ...children.map((child) => `        ${childField("csharp", child.specName, child.typeName)} = new ${childClass(child.typeName)}(connection);`),
-      ...model.enrichments.map((item) => `        ${enrichment(item)}`)
+      ...children.map((child) => `        ${childField(casing, child.specName)} = new ${childClass(child.typeName)}(connection);`),
+      ...model.enrichments.map((item) => `        ${enrichment(item, casing)}`)
     ];
     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)})
     {
@@ -99,7 +103,7 @@ ${lines.join("\n")}
     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(
-      repositoryFile("csharp", model),
+      repositoryFile("cs", model.specName, casing),
       `${usings}
 public sealed class ${model.typeName}Repository : CRUDRepository<${type}>${implementsOcc}
 {
@@ -107,7 +111,7 @@ ${fields.length === 0 ? "" : `${fields.join("\n")}
 
 `}${constructor}
 
-${createReadonly(model, type)}
+${createReadonly(model, type, casing)}
 ${occMethods(model, type)}
 ${optionsMethod(model, type)}
 }
@@ -121,11 +125,11 @@ ${optionsMethod(model, type)}
   return [
     ...files,
     content(
-      "RepositoryRegistry.cs",
+      registryFile("cs", casing),
       `using System.Runtime.CompilerServices;
 using Datasources;
 
-public static class RepositoryRegistry
+public static class ${registryClass}
 {
     [ModuleInitializer]
     internal static void Bind() => RepositoryFactory.Bind(Register);

package/dist/generate/DeterministicProvider.js

@@ -5,13 +5,19 @@ import { generate as rustDatasourceTypes } from "@deterministic-code/rust-genera
 import { generate as rustViewTypes } from "@deterministic-code/rust-generators/generate-view-types";
 import { generate as typescriptDatasourceTypes } from "@deterministic-code/typescript-generators/generate-datasource-types";
 import { generate as typescriptViewTypes } from "@deterministic-code/typescript-generators/generate-view-types";
+import { createCasingStrategy } from "@deterministic-code/generators-common/casing-strategy";
 import { DeterministicParser } from "@deterministic-code/deterministic-generators-common/parser";
+import { caseDirectories, repositoriesPrefix, typesPrefix } from "./casing.js";
 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 remap = (entries, settings, dialect) => {
+  const casing = createCasingStrategy(dialect, settings);
+  return entries.map((entry) => ({ ...entry, filename: caseDirectories(entry.filename, casing) }));
+};
 const typePacks = {
   csharp: { datasource: csharpDatasourceTypes, views: csharpViewTypes },
   typescript: { datasource: typescriptDatasourceTypes, views: typescriptViewTypes },
@@ -65,19 +71,29 @@ const deterministic = {
   generateTypes: async (request) => {
     const pack = typePacks[request.dialect];
     const ctx = context(request);
+    const casing = createCasingStrategy(request.dialect, request.settings);
     const datasource = await pack.datasource(ctx);
     const views = await pack.views(ctx);
-    return request.dialect === "typescript" ? [
-      ...place("typescript/types/generated/datasource", datasource),
-      ...place("typescript/types/generated/views", views)
-    ] : place(request.dialect, [...datasource, ...views]);
+    return remap(
+      request.dialect === "typescript" ? [
+        ...place(typesPrefix(request.dialect, casing, "datasource"), datasource),
+        ...place(typesPrefix(request.dialect, casing, "views"), views)
+      ] : place(request.dialect, [...datasource, ...views]),
+      request.settings,
+      request.dialect
+    );
   },
   generateRepositories: async (request) => {
     const spec = await DeterministicParser(request.reader).parse(request.settings);
     const models = planRepositories(spec, request.dialect, request.settings);
-    return place(
-      `${request.dialect}/repositories`,
-      repositoryPacks[request.dialect](await withProviderWrites(request, models), request.settings)
+    const casing = createCasingStrategy(request.dialect, request.settings);
+    return remap(
+      place(
+        repositoriesPrefix(request.dialect, casing),
+        repositoryPacks[request.dialect](await withProviderWrites(request, models), request.settings)
+      ),
+      request.settings,
+      request.dialect
     );
   },
   generateDatasource: async (request) => place("sql", await generateSql(context(request), dialectsOf(request.settings)))

package/dist/generate/RepositoryModel.js

@@ -1,5 +1,9 @@
-const repositoryFile = (dialect, model) => dialect === "csharp" ? `${model.typeName}Repository.cs` : dialect === "typescript" ? `${model.specName.replaceAll("_", "-")}-repository.ts` : `${model.specName}_repository.rs`;
-const childField = (dialect, specName, typeName) => dialect === "csharp" ? typeName : dialect === "typescript" ? camel(specName) : specName;
+const repositoryFile = (ext, specName, casing) => `${casing.convertFileName(`${specName}_repository`)}.${ext}`;
+const registryFile = (ext, casing) => `${casing.convertFileName("repository_registry")}.${ext}`;
+const rustIdent = (stem) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(stem) ? stem : stem.replaceAll("-", "_");
+const rustModLine = (stem) => rustIdent(stem) === stem ? `pub mod ${stem};` : `#[path = "${stem}.rs"]
+pub mod ${rustIdent(stem)};`;
+const childField = (casing, specName) => casing.convertFields(specName);
 const childClass = (typeName) => `${typeName}Repository`;
 const isLinked = (item) => item.kind === "linked";
 const children = (model) => {
@@ -10,7 +14,6 @@ const children = (model) => {
   }
   return [...rows].map(([specName, typeName]) => ({ specName, typeName }));
 };
-const camel = (name) => name.split("_").map((word, index) => index === 0 ? word : word.charAt(0).toUpperCase() + word.slice(1)).join("");
 const uncountable = /* @__PURE__ */ new Set(["sheep", "fish", "series", "species", "deer", "news"]);
 const irregular = {
   person: "people",
@@ -60,5 +63,8 @@ export {
   pluralCamel,
   pluralPascal,
   pluralSnake,
-  repositoryFile
+  registryFile,
+  repositoryFile,
+  rustIdent,
+  rustModLine
 };

package/dist/generate/RepositoryPlan.js

@@ -1,5 +1,6 @@
+import { createCasing } from "@deterministic-code/datasources-code-generators/sql/common/default-casing";
+import { inferReferenceFieldTypes } from "@deterministic-code/datasources-code-generators/sql/common/infer-reference-types";
 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) => {
@@ -23,7 +24,12 @@ const guardCycles = (models) => {
 };
 const planRepositories = (spec, dialect, settings) => {
   const casing = createCasingStrategy(dialect, settings);
-  const naming = createDatasourceNaming(settings);
+  const naming = createCasing(settings);
+  spec = {
+    ...spec,
+    types: inferReferenceFieldTypes(spec.types),
+    expandedTypes: inferReferenceFieldTypes(spec.expandedTypes)
+  };
   const types = new Map(spec.types.map((type) => [type.name, type]));
   const expanded = new Map(spec.expandedTypes.map((type) => [type.name, type]));
   const referenced = /* @__PURE__ */ new Set();
@@ -63,10 +69,10 @@ const planRepositories = (spec, dialect, settings) => {
         typeName: casing.convertTypes(authored.name),
         typeHome: authored.tags.includes("view_type") ? "view" : "datasource",
         entity: casing.convertTypes(authored.name),
-        table: naming.resolveTable(table.name, table.mapping),
+        table: naming.tableName(table.mapping ?? table.name),
         propertyMappings: columns.flatMap((field) => {
           const from = property(field.name);
-          const to = naming.resolveColumn(field.name, overlays.get(field.name)?.mapping);
+          const to = naming.columnName(overlays.get(field.name)?.mapping ?? field.name);
           return from === to ? [] : [{ from, to }];
         }),
         ids: identityColumns(tableType, table).map(property),
@@ -164,7 +170,8 @@ const relations = (authored, full, casing, types, expanded, repoName, identity)
   for (const [key, dest] of Object.entries(authored.mapping ?? {})) {
     const dotted = key.includes(".") ? key.split(".") : void 0;
     const memberName = dotted?.[0] ?? (authored.union ?? []).find((name) => expanded.get(name).fields.some((field) => field.name === key));
-    const fk = memberName === void 0 ? void 0 : full.fields.find((field) => referenceOf(field.references)?.type === memberName);
+    const parent = types.get(authored.inherits ?? "");
+    const fk = memberName === void 0 ? void 0 : full.fields.find((field) => referenceOf(field.references)?.type === memberName) ?? parent?.fields.find((field) => referenceOf(field.references)?.type === memberName);
     if (memberName === void 0 || fk === void 0) continue;
     const via = named(memberName);
     planned.push({

package/dist/generate/RustRepositories.js

@@ -1,5 +1,6 @@
+import { createCasingStrategy } from "@deterministic-code/generators-common/casing-strategy";
 import { content } from "@deterministic-code/generators-common/generate-entry";
-import { childField, children as childModels, isLinked, pluralSnake, repositoryFile } from "./RepositoryModel.js";
+import { childField, children as childModels, isLinked, pluralSnake, registryFile, repositoryFile, rustIdent, rustModLine } from "./RepositoryModel.js";
 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};
@@ -48,31 +49,37 @@ ${mapping}    options.read_properties = vec![${model.readProperties.map((name) =
 };
 const nestedOf = (models) => new Set(models.filter((model) => childModels(model).length > 0).map((model) => model.specName));
 const viaClone = (name, specName, nested) => nested.has(specName) ? `Arc::clone(&${name}.repo)` : `Arc::clone(&${name})`;
-const enrichment = (item, linked, nested) => {
-  const via = childField("rust", item.via, item.viaType);
+const fileStem = (specName, casing) => casing.convertFileName(`${specName}_repository`);
+const moduleStem = (specName, casing) => rustIdent(fileStem(specName, casing));
+const repoFn = (specName, casing) => casing.convertFields(`${specName}_repository`);
+const readonlyFnName = (specName, casing) => casing.convertFields(`${specName}_readonly_repository`);
+const enrichment = (item, linked, nested, casing) => {
+  const via = childField(casing, item.via);
   if (linked && isLinked(item)) {
-    const link = childField("rust", item.link, item.linkType);
+    const link = childField(casing, item.link);
     return `repo.add_linked(Enrichment::new(${rustString(item.destination)}, ${rustString(item.source)}, ${rustString(item.relatedKey)}, None, EnrichmentPropertyType::List).linked(Association::new(${rustString(item.parentFk)}, ${rustString(item.relatedFk)})), ${viaClone(via, item.via, nested)}, ${viaClone(link, item.link, nested)} as Arc<dyn ICRUDRepository>, None);`;
   }
   const related = item.relatedProperty === void 0 ? "None" : `Some(${rustString(item.relatedProperty)}.into())`;
   const type = item.kind === "object" ? "EnrichmentPropertyType::Object" : item.kind === "dictionary" ? "EnrichmentPropertyType::Dictionary" : "EnrichmentPropertyType::List";
   return `repo.add_enriched(Enrichment::new(${rustString(item.destination)}, ${rustString(item.source)}, ${rustString(item.relatedKey)}, ${related}, ${type}), ${viaClone(via, item.via, nested)}, None);`;
 };
-const childLets = (children, nested) => children.map(
-  (child) => nested.has(child.specName) ? `        let ${child.specName} = Arc::new(super::${child.specName}_repository::${child.typeName}Repository::new(Arc::clone(&connection))?);` : `        let ${child.specName} = Arc::new(super::${child.specName}_repository::${child.specName}_repository(Arc::clone(&connection))?);`
-).join("\n");
+const childLets = (children, nested, casing) => children.map((child) => {
+  const field = childField(casing, child.specName);
+  const module = moduleStem(child.specName, casing);
+  return nested.has(child.specName) ? `        let ${field} = Arc::new(super::${module}::${child.typeName}Repository::new(Arc::clone(&connection))?);` : `        let ${field} = Arc::new(super::${module}::${repoFn(child.specName, casing)}(Arc::clone(&connection))?);`;
+}).join("\n");
 const readonlyChildren = (model) => {
   const rows = /* @__PURE__ */ new Map();
   for (const item of model.enrichments) rows.set(item.via, item.viaType);
   return [...rows].map(([specName, typeName]) => ({ specName, typeName }));
 };
-const readonlyFn = (model, nested) => {
-  const lets = childLets(readonlyChildren(model), nested);
-  const enrich = model.enrichments.map((item) => `        ${enrichment(item, false, nested)}`).join("\n");
+const readonlyFn = (model, nested, casing) => {
+  const lets = childLets(readonlyChildren(model), nested, casing);
+  const enrich = model.enrichments.map((item) => `        ${enrichment(item, false, nested, casing)}`).join("\n");
   const body = `${readonlyOptions(model)}
 ${lets}${lets.length === 0 ? "" : "\n"}        let ${model.enrichments.length === 0 ? "repo" : "mut repo"} = ReadonlyRepository::new(connection, options)?;
 ${enrich}${enrich.length === 0 ? "" : "\n"}        Ok(repo)`;
-  return `pub fn ${model.specName}_readonly_repository(connection: Arc<dyn Connection>) -> Result<ReadonlyRepository> {
+  return `pub fn ${readonlyFnName(model.specName, casing)}(connection: Arc<dyn Connection>) -> Result<ReadonlyRepository> {
 ${body}
 }`;
 };
@@ -180,23 +187,25 @@ ${where}
 }
 `;
 };
-const plain = (model, nested) => `${uses(model)}
+const plain = (model, nested, casing) => `${uses(model)}
 
-pub fn ${model.specName}_repository(connection: Arc<dyn Connection>) -> Result<CRUDRepository> {
+pub fn ${repoFn(model.specName, casing)}(connection: Arc<dyn Connection>) -> Result<CRUDRepository> {
 ${crudOptions(model)}
     CRUDRepository::new(connection, options)
 }
 
-${readonlyFn(model, nested)}
+${readonlyFn(model, nested, casing)}
 ${rustOcc(model)}`;
-const wrapped = (model, nested) => {
+const wrapped = (model, nested, casing) => {
   const type = `${model.typeName}Repository`;
   const children = childModels(model);
-  const fields = children.map(
-    (child) => nested.has(child.specName) ? `    pub ${child.specName}: Arc<super::${child.specName}_repository::${child.typeName}Repository>,` : `    pub ${child.specName}: Arc<CRUDRepository>,`
-  ).join("\n");
-  const assign = children.map((child) => child.specName).join(", ");
-  const enrich = model.enrichments.map((item) => `        ${enrichment(item, true, nested)}`).join("\n");
+  const fields = children.map((child) => {
+    const field = childField(casing, child.specName);
+    const module = moduleStem(child.specName, casing);
+    return nested.has(child.specName) ? `    pub ${field}: Arc<super::${module}::${child.typeName}Repository>,` : `    pub ${field}: Arc<CRUDRepository>,`;
+  }).join("\n");
+  const assign = children.map((child) => childField(casing, child.specName)).join(", ");
+  const enrich = model.enrichments.map((item) => `        ${enrichment(item, true, nested, casing)}`).join("\n");
   return `${uses(model)}
 use std::ops::Deref;
 
@@ -208,7 +217,7 @@ ${fields}
 impl ${type} {
     pub fn new(connection: Arc<dyn Connection>) -> Result<Self> {
 ${pad(crudOptions(model), 4)}
-${childLets(children, nested)}
+${childLets(children, nested, casing)}
         let mut repo = CRUDRepository::new(Arc::clone(&connection), options)?;
 ${enrich}
         Ok(Self { repo: Arc::new(repo), ${assign} })
@@ -222,26 +231,28 @@ impl Deref for ${type} {
     }
 }
 
-pub fn ${model.specName}_repository(connection: Arc<dyn Connection>) -> Result<CRUDRepository> {
+pub fn ${repoFn(model.specName, casing)}(connection: Arc<dyn Connection>) -> Result<CRUDRepository> {
     Arc::try_unwrap(${type}::new(connection)?.repo).map_err(|_| datasources::DatasourceError::message("repository"))
 }
 
-${readonlyFn(model, nested)}
+${readonlyFn(model, nested, casing)}
 ${rustOcc(model)}`;
 };
-const rustRepositories = (models) => {
+const rustRepositories = (models, settings) => {
+  const casing = createCasingStrategy("rust", settings);
   const nested = nestedOf(models);
   const files = models.map(
-    (model) => content(repositoryFile("rust", model), childModels(model).length === 0 ? plain(model, nested) : wrapped(model, nested))
+    (model) => content(repositoryFile("rs", model.specName, casing), childModels(model).length === 0 ? plain(model, nested, casing) : wrapped(model, nested, casing))
   );
   const register = models.map((model) => {
-    const module = `${model.specName}_repository`;
-    const crud = model.optimisticConcurrency === void 0 ? `Arc::new(super::${module}::${model.specName}_repository(connection).expect("repository")) as Arc<dyn ICRUDRepository>` : `Arc::new(super::${module}::${model.typeName}Optimistic::new(super::${module}::${model.specName}_repository(connection).expect("repository"))) as Arc<dyn ICRUDRepository>`;
+    const module = moduleStem(model.specName, casing);
+    const fn = repoFn(model.specName, casing);
+    const crud = model.optimisticConcurrency === void 0 ? `Arc::new(super::${module}::${fn}(connection).expect("repository")) as Arc<dyn ICRUDRepository>` : `Arc::new(super::${module}::${model.typeName}Optimistic::new(super::${module}::${fn}(connection).expect("repository"))) as Arc<dyn ICRUDRepository>`;
     return `    factory.register_named(
         ${rustString(model.entity)},
         ${rustString(pluralSnake(model.specName))},
         |connection| ${crud},
-        |connection| Arc::new(super::${module}::${model.specName}_readonly_repository(connection).expect("repository")) as Arc<dyn IReadonlyRepository>,
+        |connection| Arc::new(super::${module}::${readonlyFnName(model.specName, casing)}(connection).expect("repository")) as Arc<dyn IReadonlyRepository>,
     );`;
   });
   const methods = models.map((model) => {
@@ -276,9 +287,9 @@ ${impls.join("\n")}
 `;
   return [
     ...files,
-    content("repository_registry.rs", registry),
-    content("mod.rs", `${models.map((model) => `pub mod ${model.specName}_repository;`).join("\n")}
-pub mod repository_registry;
+    content(registryFile("rs", casing), registry),
+    content("mod.rs", `${models.map((model) => rustModLine(fileStem(model.specName, casing))).join("\n")}
+${rustModLine(casing.convertFileName("repository_registry"))}
 `)
   ];
 };

package/dist/generate/TypeScriptRepositories.js

@@ -1,6 +1,6 @@
 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 { childClass, childField, children as childModels, isLinked, pluralCamel, registryFile, repositoryFile } from "./RepositoryModel.js";
 import { dialectsOf, quote, writeList } from "./writeLists.js";
 const withEntity = (model, planned) => ({ entity: model.entity, ...planned });
 const entityAndMapping = (model) => {
@@ -18,23 +18,23 @@ const tsBuilder = (name, model, write) => `const ${name} = (connection: IConnect
 
 `;
 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 enrichment = (item, casing, host) => {
+  const via = host === "this" ? `this.${childField(casing, item.via)}` : childField(casing, item.via);
   const related = item.relatedProperty === void 0 ? "" : `, relatedProperty: "${quote(item.relatedProperty)}"`;
   const type = item.kind === "object" ? "object" : item.kind === "dictionary" ? "dictionary" : "list";
   if (host === "this" && isLinked(item)) {
-    const link = `this.${childField("typescript", item.link, item.linkType)}`;
+    const link = `this.${childField(casing, item.link)}`;
     return `this.addLinked({ destinationProperty: "${quote(item.destination)}", sourceProperty: "${quote(item.source)}", relatedKey: "${quote(item.relatedKey)}"${related}, association: { parent: "${quote(item.parentFk)}", related: "${quote(item.relatedFk)}" }, type: "${type}" }, ${via}, ${link});`;
   }
   return `${host}.addEnriched({ destinationProperty: "${quote(item.destination)}", sourceProperty: "${quote(item.source)}", relatedKey: "${quote(item.relatedKey)}"${related}, type: "${type}" }, ${via});`;
 };
-const createReadonly = (model) => {
+const createReadonly = (model, casing) => {
   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});`;
-  const locals = children.map((child) => `    const ${childField("typescript", child.specName, child.typeName)} = new ${childClass(child.typeName)}(connection);`);
-  const enrich = model.enrichments.map((item) => `    ${enrichment(item, "repo")}`);
+  const locals = children.map((child) => `    const ${childField(casing, child.specName)} = new ${childClass(child.typeName)}(connection);`);
+  const enrich = model.enrichments.map((item) => `    ${enrichment(item, casing, "repo")}`);
   return `  static createReadonly(connection: IConnection) {
     const repo = new ReadonlyRepository<${model.typeName}>(connection, ${options});
 ${locals.join("\n")}
@@ -67,24 +67,28 @@ ${bump}      const response = await update(item, byWhere ?? ${tokenWhere(model,
     };
 `;
 };
-const repoImport = (specName) => `./${specName.replaceAll("_", "-")}-repository`;
+const repoImport = (specName, casing) => `./${casing.convertFileName(`${specName}_repository`)}`;
+const typeImport = (model, casing) => {
+  const folder = model.typeHome === "view" ? "views" : "datasource";
+  const dirs = ["types", "generated", folder].map((segment) => casing.convertDirectories(segment)).join("/");
+  return `../${dirs}/${casing.convertFileName(model.specName)}`;
+};
 const typescriptRepositories = (models, settings) => {
   const casing = createCasingStrategy("typescript", settings);
   const files = models.map((model) => {
-    const folder = model.typeHome === "view" ? "views" : "datasource";
     const children = childModels(model);
-    const fields = children.map((child) => `  readonly ${childField("typescript", child.specName, child.typeName)}: ${childClass(child.typeName)};`);
+    const fields = children.map((child) => `  readonly ${childField(casing, child.specName)}: ${childClass(child.typeName)};`);
     const wrap = occWrap(model);
     const lines = [
-      ...children.map((child) => `    this.${childField("typescript", child.specName, child.typeName)} = new ${childClass(child.typeName)}(connection);`),
-      ...model.enrichments.map((item) => `    ${enrichment(item, "this")}`)
+      ...children.map((child) => `    this.${childField(casing, child.specName)} = new ${childClass(child.typeName)}(connection);`),
+      ...model.enrichments.map((item) => `    ${enrichment(item, casing, "this")}`)
     ];
-    const imports = children.map((child) => `import { ${childClass(child.typeName)} } from "${repoImport(child.specName)}";`);
+    const imports = children.map((child) => `import { ${childClass(child.typeName)} } from "${repoImport(child.specName, casing)}";`);
     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)}";
+      repositoryFile("ts", model.specName, casing),
+      `import type { ${model.typeName} } from "${typeImport(model, casing)}";
 ${core}
 ${imports.length === 0 ? "" : `${imports.join("\n")}
 `}
@@ -94,18 +98,18 @@ ${fields.length === 0 ? "" : `${fields.join("\n")}
     super(connection, ${tsOptionsExpr(model)});
 ${wrap}${lines.length === 0 ? "" : `${lines.join("\n")}
 `}  }
-${createReadonly(model)}
+${createReadonly(model, casing)}
 }
 `
     );
   });
-  const registerImports = models.map((model) => `import { ${childClass(model.typeName)} } from "${repoImport(model.specName)}";`);
+  const registerImports = models.map((model) => `import { ${childClass(model.typeName)} } from "${repoImport(model.specName, casing)}";`);
   const registerCalls = models.map((model) => `  factory.register("${quote(model.entity)}", "${quote(pluralCamel(model.typeName))}", (connection) => new ${childClass(model.typeName)}(connection), (connection) => ${childClass(model.typeName)}.createReadonly(connection));`);
   const props = models.map((model) => `    readonly ${pluralCamel(model.typeName)}: ${childClass(model.typeName)};`);
   return [
     ...files,
     content(
-      "repository-registry.ts",
+      registryFile("ts", casing),
       `import { RepositoryFactory } from "@deterministic-code/datasources";
 ${registerImports.join("\n")}
 

package/dist/generate/applyGenerate.js

@@ -4,15 +4,22 @@ import { loadSpec } from "./loadSpec.js";
 import { providerByName } from "./providers.js";
 import { withStoredProcedures } from "./storedProcedures.js";
 import { writeEntries } from "./writeEntries.js";
+import { overlayCasingFlags } from "./casing.js";
+import { overlaySqlFlags } from "./sqlFlags.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 settings = overlayCasingFlags(
+    overlaySqlFlags(withStoredProcedures(loaded.settings, command.storedProcedures), command),
+    command.dialect,
+    command
+  );
   const request = {
     dialect: command.dialect,
     reader: memoryReader(loaded.files),
-    settings: withStoredProcedures(loaded.settings, command.storedProcedures)
+    settings
   };
   const entries = await {
     all: async () => [
@@ -26,7 +33,7 @@ const applyGenerate = async (command, flags, deps) => {
   }[command.target]();
   for (const path of await writeEntries(deps.fs, at(flags.cwd, command.output), entries)) deps.log(path);
   if (command.target === "all" || command.target === "repositories")
-    await wireRegister(flags.cwd, command.output, command.dialect, flags.dryRun, deps);
+    await wireRegister(flags.cwd, command.output, command.dialect, flags.dryRun, deps, settings);
 };
 export {
   applyGenerate

package/dist/generate/applyMigrations.js

@@ -3,31 +3,23 @@ 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 { overlaySqlFlags } from "./sqlFlags.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\//, "");
 const applyMigrations = async (command, flags, deps) => {
   providerByName(command.provider);
   const loaded = await loadSpec(deps.fs, at(flags.cwd, command.input));
-  const listed = [
-    ...new Set(
-      loaded.settings["backend.datasources"].split(",").map((name) => name.trim()).filter((name) => name !== "")
-    )
-  ];
-  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: withStoredProcedures(loaded.settings, command.storedProcedures)
+    settings: overlaySqlFlags(withStoredProcedures(loaded.settings, command.storedProcedures), command)
   });
-  const remapped = command.migrationsPath === void 0 ? entries : entries.map((entry) => ({ ...entry, filename: afterMigrations(entry.filename) }));
-  const root = at(flags.cwd, command.migrationsPath ?? command.migrationsRoot);
+  const root = at(flags.cwd, command.migrationsRoot);
   if (flags.dryRun) {
-    for (const entry of remapped) deps.log(join(root, entry.filename));
+    for (const entry of entries) deps.log(join(root, entry.filename));
     return;
   }
-  for (const path of await writeEntries(deps.fs, root, remapped)) deps.log(path);
+  for (const path of await writeEntries(deps.fs, root, entries)) deps.log(path);
 };
 export {
   applyMigrations

package/dist/generate/casing.js

@@ -0,0 +1,28 @@
+const caseFormats = ["Pascal", "Camel", "Snake", "Kebab", "Auto"];
+const LITERAL_SEGMENTS = /* @__PURE__ */ new Set(["csharp", "typescript", "rust", "sql", "custom", "__tests__", "frontend"]);
+const parseCaseFlag = (raw, name) => {
+  const parsed = caseFormats.find((format) => format.toLowerCase() === raw.toLowerCase());
+  if (parsed === void 0) throw new Error(`${name} must be one of [${caseFormats.join(", ")}] (got "${raw}").`);
+  return parsed;
+};
+const overlayCasingFlags = (settings, dialect, flags) => {
+  const prefix = `languages.${dialect}.casing`;
+  return {
+    ...settings,
+    ...flags.fileNames === void 0 ? {} : { [`${prefix}.file_names`]: flags.fileNames },
+    ...flags.types === void 0 ? {} : { [`${prefix}.types`]: flags.types },
+    ...flags.fields === void 0 ? {} : { [`${prefix}.fields`]: flags.fields },
+    ...flags.directories === void 0 ? {} : { [`${prefix}.directories`]: flags.directories }
+  };
+};
+const caseDirectories = (path, casing) => path.split("/").map((segment) => LITERAL_SEGMENTS.has(segment) || segment.includes(".") ? segment : casing.convertDirectories(segment)).join("/");
+const typesPrefix = (dialect, casing, kind) => dialect === "typescript" ? ["typescript", casing.convertDirectories("types"), casing.convertDirectories("generated"), casing.convertDirectories(kind)].join("/") : dialect;
+const repositoriesPrefix = (dialect, casing) => `${dialect}/${casing.convertDirectories("repositories")}`;
+export {
+  caseDirectories,
+  caseFormats,
+  overlayCasingFlags,
+  parseCaseFlag,
+  repositoriesPrefix,
+  typesPrefix
+};