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

package/dist/generate/RustRepositories.js

@@ -0,0 +1,270 @@
+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};
+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")}
+    ])));
+`;
+  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(", ")}];`;
+};
+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")}
+    ])));
+`;
+  return `    let mut options = ReadonlyRepositoryMappingOptions::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.read_properties = vec![${model.readProperties.map((name) => `${rustString(name)}.into()`).join(", ")}];`;
+};
+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);
+  if (linked && isLinked(item)) {
+    const link = childField("rust", item.link, item.linkType);
+    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 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 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> {
+${body}
+}`;
+};
+const rustTokenWhere = (model, token) => {
+  const [first, ...rest] = [...model.ids, token.property];
+  const value = (name) => name === token.property ? "expected.clone()" : `item.get(${rustString(name)}).cloned().ok_or_else(|| DatasourceError::message(${rustString(name)}))?`;
+  return `        let expected = item.get(${rustString(token.property)}).cloned().ok_or_else(|| DatasourceError::message(${rustString(token.property)}))?;
+        let clause = Where::binary(${rustString(first)}, eq, ${value(first)})${rest.map((name) => `.and(${rustString(name)}, eq, ${value(name)})`).join("")};`;
+};
+const rustOcc = (model) => {
+  const token = model.optimisticConcurrency;
+  if (token === void 0) return "";
+  const name = `${model.typeName}Optimistic`;
+  const bump = token.increment ? `        if let Some(value) = item.get(${rustString(token.property)}).cloned() {
+            item.insert(${rustString(token.property)}.into(), match value {
+                Value::Int(n) => Value::Int(n + 1),
+                Value::Float(n) => Value::Float(n + 1.0),
+                other => other,
+            });
+        }
+` : "";
+  const where = rustTokenWhere(model, token);
+  return `
+use datasources::{async_trait, CommandMiddleware, DatasourceError, IReadonlyRepository, IRepository, IdKey, IWhere, Parameter, ReadInput, Response, Value, Where, eq};
+use futures_core::Stream;
+use std::any::TypeId;
+use std::pin::Pin;
+
+pub struct ${name} {
+    repo: CRUDRepository,
+}
+
+impl ${name} {
+    pub fn new(repo: CRUDRepository) -> Self {
+        Self { repo }
+    }
+}
+
+impl IRepository for ${name} {
+    fn entity_type(&self) -> TypeId {
+        self.repo.entity_type()
+    }
+}
+
+#[async_trait]
+impl IReadonlyRepository for ${name} {
+    fn to_crud(self: Arc<Self>) -> Option<Arc<dyn ICRUDRepository>> {
+        Some(self)
+    }
+
+    async fn read_single(
+        &self,
+        query: Option<&dyn ReadInput>,
+        parameters: Option<&[Parameter]>,
+        options: Option<&ReadonlyRepositoryMappingOptions>,
+    ) -> Result<Option<datasources::Row>> {
+        self.repo.read_single(query, parameters, options).await
+    }
+
+    fn read<'a>(
+        &'a self,
+        query: Option<&'a dyn ReadInput>,
+        parameters: Option<&'a [Parameter]>,
+        options: Option<&'a ReadonlyRepositoryMappingOptions>,
+    ) -> Pin<Box<dyn Stream<Item = Result<datasources::Row>> + Send + 'a>> {
+        self.repo.read(query, parameters, options)
+    }
+}
+
+#[async_trait]
+impl ICRUDRepository for ${name} {
+    async fn create(&self, item: &mut datasources::Row) -> Result<datasources::Row> {
+        self.repo.create(item).await
+    }
+
+    async fn update(&self, item: &mut datasources::Row, by_where: Option<&dyn IWhere>) -> Result<Response> {
+${where}
+${bump}        let response = self.repo.update(item, Some(by_where.unwrap_or(&clause))).await?;
+        if response.rows_affected != 1 {
+            return Err(DatasourceError::message(format!("Update affected {} rows", response.rows_affected)));
+        }
+        Ok(response)
+    }
+
+    async fn delete(&self, item: &datasources::Row, by_where: Option<&dyn IWhere>) -> Result<Response> {
+${where}
+        let response = self.repo.delete(item, Some(by_where.unwrap_or(&clause))).await?;
+        if response.rows_affected != 1 {
+            return Err(DatasourceError::message(format!("Delete affected {} rows", response.rows_affected)));
+        }
+        Ok(response)
+    }
+
+    async fn read_single_by_id(&self, id: &dyn IdKey) -> Result<Option<datasources::Row>> {
+        self.repo.read_single_by_id(id).await
+    }
+
+    fn id_names(&self) -> Vec<String> {
+        self.repo.id_names()
+    }
+
+    fn add_middleware(&self, middleware: Arc<dyn CommandMiddleware>) {
+        self.repo.add_middleware(middleware)
+    }
+}
+`;
+};
+const pad = (text) => text.split("\n").map((line) => `    ${line}`).join("\n");
+const plain = (model, nested) => `${uses}
+
+pub fn ${model.specName}_repository(connection: Arc<dyn Connection>) -> Result<CRUDRepository> {
+${crudOptions(model)}
+    CRUDRepository::new(connection, options)
+}
+
+${readonlyFn(model, nested)}
+${rustOcc(model)}`;
+const wrapped = (model, nested) => {
+  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");
+  return `${uses}
+use std::ops::Deref;
+
+pub struct ${type} {
+    pub repo: Arc<CRUDRepository>,
+${fields}
+}
+
+impl ${type} {
+    pub fn new(connection: Arc<dyn Connection>) -> Result<Self> {
+${pad(crudOptions(model))}
+${childLets(children, nested)}
+        let mut repo = CRUDRepository::new(Arc::clone(&connection), options)?;
+${enrich}
+        Ok(Self { repo: Arc::new(repo), ${assign} })
+    }
+}
+
+impl Deref for ${type} {
+    type Target = CRUDRepository;
+    fn deref(&self) -> &Self::Target {
+        self.repo.as_ref()
+    }
+}
+
+pub fn ${model.specName}_repository(connection: Arc<dyn Connection>) -> Result<CRUDRepository> {
+    Arc::try_unwrap(${type}::new(connection)?.repo).map_err(|_| datasources::DatasourceError::message("repository"))
+}
+
+${readonlyFn(model, nested)}
+${rustOcc(model)}`;
+};
+const rustRepositories = (models) => {
+  const nested = nestedOf(models);
+  const files = models.map(
+    (model) => content(repositoryFile("rust", model), childModels(model).length === 0 ? plain(model, nested) : wrapped(model, nested))
+  );
+  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>`;
+    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>,
+    );`;
+  });
+  const methods = models.map((model) => {
+    const name = pluralSnake(model.specName);
+    return `    fn ${name}(&self) -> Arc<dyn ICRUDRepository>;`;
+  });
+  const impls = models.map((model) => {
+    const name = pluralSnake(model.specName);
+    return `    fn ${name}(&self) -> Arc<dyn ICRUDRepository> {
+        self.create_repository_by_name(${rustString(name)}, None).expect(${rustString(name)})
+    }`;
+  });
+  const registry = `use datasources::{Datasource, ICRUDRepository, IReadonlyRepository, RepositoryFactory};
+use std::sync::Arc;
+
+pub fn register(factory: &RepositoryFactory) {
+${register.join("\n")}
+}
+
+#[ctor::ctor]
+fn bind() {
+    RepositoryFactory::bind(register);
+}
+
+pub trait Repositories {
+${methods.join("\n")}
+}
+
+impl Repositories for dyn Datasource {
+${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;
+`)
+  ];
+};
+export {
+  rustRepositories
+};

package/dist/generate/TypeScriptRepositories.js

@@ -0,0 +1,115 @@
+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('"', '\\"');
+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)}"`;
+  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)}`;
+    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, options) => {
+  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")}`);
+  return `  static createReadonly(connection: IConnection) {
+    const repo = new ReadonlyRepository<${model.typeName}>(connection, ${options});
+${locals.join("\n")}
+${enrich.join("\n")}
+    return repo;
+  }`;
+};
+const tokenWhere = (model, token, expected) => {
+  const [first, ...rest] = [...model.ids, token.property];
+  const value = (name) => name === token.property ? expected : `item.${name}`;
+  return `new Where("${quote(first)}", eq, ${value(first)})${rest.map((name) => `.and("${quote(name)}", eq, ${value(name)})`).join("")}`;
+};
+const occWrap = (model) => {
+  const token = model.optimisticConcurrency;
+  if (token === void 0) return "";
+  const bump = token.increment ? `      item.${token.property} = Number(expected) + 1;
+` : "";
+  return `    const update = this.update;
+    const remove = this.delete;
+    this.update = async (item, byWhere) => {
+      const expected = item.${token.property};
+${bump}      const response = await update(item, byWhere ?? ${tokenWhere(model, token, "expected")});
+      if (response.rowsAffected !== 1) throw new DatasourceError(\`Update affected \${response.rowsAffected} rows\`);
+      return response;
+    };
+    this.delete = async (item, byWhere) => {
+      const response = await remove(item, byWhere ?? ${tokenWhere(model, token, `item.${token.property}`)});
+      if (response.rowsAffected !== 1) throw new DatasourceError(\`Delete affected \${response.rowsAffected} rows\`);
+      return response;
+    };
+`;
+};
+const repoImport = (specName) => `./${specName.replaceAll("_", "-")}-repository`;
+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 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 = [
+      ...children.map((child) => `    this.${childField("typescript", child.specName, child.typeName)} = new ${childClass(child.typeName)}(connection);`),
+      ...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";`;
+    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}> {
+${fields.length === 0 ? "" : `${fields.join("\n")}
+`}  constructor(connection: IConnection) {
+    super(connection, ${crudOptions});
+${wrap}${lines.length === 0 ? "" : `${lines.join("\n")}
+`}  }
+${createReadonly(model, readonlyOptions)}
+}
+`
+    );
+  });
+  const registerImports = models.map((model) => `import { ${childClass(model.typeName)} } from "${repoImport(model.specName)}";`);
+  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",
+      `import { RepositoryFactory } from "@deterministic-code/datasources";
+${registerImports.join("\n")}
+
+export const register = (factory: RepositoryFactory): void => {
+${registerCalls.join("\n")}
+};
+RepositoryFactory.bind(register);
+
+declare module "@deterministic-code/datasources" {
+  interface Datasource {
+${props.join("\n")}
+  }
+}
+`
+    )
+  ];
+};
+export {
+  typescriptRepositories
+};

package/dist/generate/applyGenerate.js

@@ -0,0 +1,28 @@
+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 { 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 entries = await {
+    all: async () => [
+      ...await provider.generateTypes(request),
+      ...await provider.generateRepositories(request),
+      ...await provider.generateDatasource(request)
+    ],
+    types: () => provider.generateTypes(request),
+    repositories: () => provider.generateRepositories(request),
+    datasource: () => provider.generateDatasource(request)
+  }[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);
+};
+export {
+  applyGenerate
+};

package/dist/generate/applyMigrations.js

@@ -0,0 +1,28 @@
+import { isAbsolute, join } from "node:path";
+import { generate as generateSql } from "@deterministic-code/datasources-code-generators/generate-sql";
+import { memoryReader } from "@deterministic-code/generators-common/deterministic-reader";
+import { loadSpec } from "./loadSpec.js";
+import { providerByName } from "./providers.js";
+import { writeEntries } from "./writeEntries.js";
+const at = (root, path) => isAbsolute(path) ? path : join(root, path);
+const afterMigrations = (filename) => filename.replace(/^[^/]+\/migrations\//, "");
+const dialectsOf = (entries) => [
+  ...new Set(entries.map((entry) => entry.filename.split("/")[0]))
+];
+const applyMigrations = async (command, flags, deps) => {
+  providerByName(command.provider);
+  const loaded = await loadSpec(deps.fs, at(flags.cwd, command.input));
+  const entries = await generateSql({ reader: memoryReader(loaded.files), settings: loaded.settings });
+  if (command.migrationsPath !== void 0 && dialectsOf(entries).length > 1)
+    throw new Error("--migrations-path requires a single SQL dialect in backend.datasources");
+  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) {
+    for (const entry of remapped) deps.log(join(root, entry.filename));
+    return;
+  }
+  for (const path of await writeEntries(deps.fs, root, remapped)) deps.log(path);
+};
+export {
+  applyMigrations
+};

package/dist/generate/loadSpec.js

@@ -0,0 +1,48 @@
+import { join } from "node:path";
+import { settingsFrom } from "./settingsFlat.js";
+const specFiles = ["types.yaml", "datasource.yaml", "datasource_seeds.yaml", "services.yaml", "routes.yaml"];
+const defaultDatasourceYaml = `version: 1.0.0
+includes:
+  - types:
+      filter: tag == "datasource_type" || tag == "view_type"
+types: []
+`;
+const readOptional = async (fs, path) => {
+  try {
+    return await fs.readFile(path);
+  } catch {
+    return void 0;
+  }
+};
+const versionDir = /^version-\d{8}T\d{6}Z-\d{3}$/;
+const loadSpec = async (fs, dir) => {
+  const files = {};
+  for (const name of specFiles) {
+    const text = await readOptional(fs, join(dir, name));
+    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(() => []);
+  const diffs = names.filter((name) => versionDir.test(name)).sort();
+  const versionFiles = [];
+  for (const name of diffs) {
+    const path = `${name}/diff.yaml`;
+    const text = await readOptional(fs, join(dir, path));
+    if (text === void 0) continue;
+    files[path] = text;
+    versionFiles.push(path);
+  }
+  return {
+    files,
+    settings: {
+      ...settingsFrom(await readOptional(fs, join(dir, "settings.yaml"))),
+      "paths.deterministic": dir,
+      ...versionFiles.length ? { "version.diffs": versionFiles.join("\n") } : {}
+    }
+  };
+};
+export {
+  defaultDatasourceYaml,
+  loadSpec
+};

package/dist/generate/migrateUp.js

@@ -0,0 +1,76 @@
+import { isAbsolute, join } from "node:path";
+import { parseEnv, scheme } from "../env.js";
+import { migrateProviders } from "../migrateInit.js";
+import { loadSpec } from "./loadSpec.js";
+const at = (root, path) => isAbsolute(path) ? path : join(root, path);
+const aliases = {
+  sqlite3: "sqlite",
+  postgresql: "postgres",
+  pg: "postgres",
+  mariadb: "mysql",
+  mssql: "sqlserver",
+  mssqlserver: "sqlserver",
+  ora: "oracle"
+};
+const canonical = (name) => {
+  const key = name.trim().toLowerCase();
+  return aliases[key] ?? key;
+};
+const isSql = (name) => migrateProviders.includes(name);
+const sqlDialects = (settings) => {
+  const out = [];
+  for (const name of settings["backend.datasources"].split(",")) {
+    const key = canonical(name);
+    if (key !== "" && isSql(key) && !out.includes(key)) out.push(key);
+  }
+  return out;
+};
+const readEnv = async (fs, cwd) => {
+  try {
+    return parseEnv(await fs.readFile(join(cwd, ".env")));
+  } catch {
+    return {};
+  }
+};
+const merged = (file, env) => ({
+  ...file,
+  ...env.PROVIDER ? { PROVIDER: env.PROVIDER } : {},
+  ...env.DATASOURCE_URL ? { DATASOURCE_URL: env.DATASOURCE_URL } : {}
+});
+const inMemory = (url) => url === ":memory:" || url.includes(":memory:");
+const applyMigrateUp = async (command, flags, deps, env = process.env) => {
+  const loaded = await loadSpec(deps.fs, at(flags.cwd, command.input));
+  const dialects = sqlDialects(loaded.settings);
+  const values = merged(await readEnv(deps.fs, flags.cwd), env);
+  const connection = values.DATASOURCE_URL ?? "";
+  const provider = canonical(values.PROVIDER || scheme(connection) || "");
+  if (!provider || !connection) {
+    deps.log("migrate-up skipped: set PROVIDER and DATASOURCE_URL, or pass --no-migrate");
+    return;
+  }
+  if (inMemory(connection)) {
+    deps.log("migrate-up skipped: DATASOURCE_URL is in-memory");
+    return;
+  }
+  if (!isSql(provider)) {
+    deps.log(`migrate-up skipped: ${provider} has no SQL migrations`);
+    return;
+  }
+  if (!dialects.includes(provider))
+    throw new Error(
+      `migrate-up: provider ${provider} is not in backend.datasources (${dialects.join(", ") || "none"})`
+    );
+  const args = [
+    "migrate-up",
+    "--provider",
+    provider,
+    "--connection",
+    connection,
+    ...command.migrationsPath ? ["--migrations-path", command.migrationsPath] : ["--migrations-root", command.migrationsRoot]
+  ];
+  deps.log(`$ npx ${args.join(" ")}`);
+  if (!flags.dryRun) await deps.run("npx", args, flags.cwd);
+};
+export {
+  applyMigrateUp
+};

package/dist/generate/providers.js

@@ -0,0 +1,10 @@
+import { deterministic } from "./DeterministicProvider.js";
+const providers = { deterministic };
+const providerByName = (name) => {
+  const provider = providers[name];
+  if (provider === void 0) throw new Error(`Unknown provider: ${name}`);
+  return provider;
+};
+export {
+  providerByName
+};

package/dist/generate/settingsFlat.js

@@ -0,0 +1,29 @@
+import { parse } from "yaml";
+const isMap = (node) => node !== null && typeof node === "object" && !Array.isArray(node);
+const write = (node, prefix, out) => {
+  if (Array.isArray(node)) {
+    if (prefix) out[prefix] = node.map((item) => String(item)).join(",");
+    return;
+  }
+  if (isMap(node)) {
+    for (const [key, value] of Object.entries(node)) write(value, prefix ? `${prefix}.${key}` : key, out);
+    return;
+  }
+  if (prefix) out[prefix] = String(node);
+};
+const flattenSettings = (text) => {
+  const parsed = parse(text);
+  const root = isMap(parsed) && isMap(parsed.settings) ? parsed.settings : parsed;
+  const out = {};
+  write(root, "", out);
+  return out;
+};
+const settingsFrom = (text) => ({
+  "backend.datasources": "sqlite",
+  "languages.typescript.casing.fields": "camel",
+  ...text === void 0 ? {} : flattenSettings(text)
+});
+export {
+  flattenSettings,
+  settingsFrom
+};

package/dist/generate/writeEntries.js

@@ -0,0 +1,35 @@
+import { join } from "node:path";
+import { stripAttributes } from "@deterministic-code/generators-common/generate-entry";
+const merge = (existing, entry) => {
+  if (entry.section !== void 0) {
+    const start = `// <${entry.section}>`;
+    const end = `// </${entry.section}>`;
+    const block = `${start}
+${entry.content}
+${end}
+`;
+    const pattern = new RegExp(`${start}[\\s\\S]*?${end}\\n?`);
+    return pattern.test(existing) ? existing.replace(pattern, block) : `${existing}${block}`;
+  }
+  if (existing.includes(entry.content)) return existing;
+  if (entry.appendIfNotExists === "None") return existing;
+  if (entry.appendIfNotExists === "Start") return `${entry.content}${existing}`;
+  return `${existing}${entry.content}`;
+};
+const writeEntries = async (fs, root, entries) => {
+  const paths = [];
+  for (const entry of stripAttributes(entries)) {
+    const path = join(root, entry.filename);
+    if (entry.kind === "content") {
+      await fs.writeFile(path, entry.contents);
+    } else {
+      const existing = await fs.readFile(path).catch(() => "");
+      await fs.writeFile(path, merge(existing, entry));
+    }
+    paths.push(path);
+  }
+  return paths;
+};
+export {
+  writeEntries
+};

package/dist/index.js

@@ -0,0 +1,10 @@
+import { catalog, providers } from "./catalog.js";
+import { parseArgs, help } from "./parse.js";
+import { run } from "./run.js";
+export {
+  catalog,
+  help,
+  parseArgs,
+  providers,
+  run
+};

package/dist/installed.js

@@ -0,0 +1,14 @@
+import { catalog, providers } from "./catalog.js";
+const npmProviders = (manifest) => {
+  const deps = { ...manifest.dependencies, ...manifest.devDependencies };
+  return providers.filter((name) => catalog[name].npm in deps);
+};
+const cargoProviders = (toml) => providers.filter((name) => hasCargoCrate(toml, catalog[name].cargo));
+const csharpProviders = (csproj) => providers.filter((name) => hasCsharpPackage(csproj, catalog[name].nuget));
+const hasCargoCrate = (toml, crate) => new RegExp(`(^|[\\s{,])${crate}\\s*=`, "m").test(toml) || new RegExp(`"${crate}"`).test(toml);
+const hasCsharpPackage = (xml, id) => xml.includes(`"${id}"`) || xml.includes(`${id}.csproj`);
+export {
+  cargoProviders,
+  csharpProviders,
+  npmProviders
+};