@deterministic-code/datasources-cli 0.1.12 → 0.1.14

package/dist/generate/migrateUp.js

@@ -45,7 +45,7 @@ const applyMigrateUp = async (command, flags, deps, env = process.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");
+    deps.log("migrate-up skipped: set PROVIDER and DATASOURCE_URL, or pass --no-auto-migrate-up");
     return;
   }
   if (inMemory(connection)) {
@@ -61,9 +61,6 @@ const applyMigrateUp = async (command, flags, deps, env = process.env) => {
       `migrate-up: provider ${provider} is not in backend.datasources (${dialects.join(", ") || "none"})`
     );
   const npx = (verb, extra = []) => [
-    "--yes",
-    "--package",
-    "@deterministic-code/migraters",
     verb,
     "--provider",
     provider,
@@ -72,10 +69,7 @@ const applyMigrateUp = async (command, flags, deps, env = process.env) => {
     ...extra
   ];
   const setup = npx("migrate-setup");
-  const up = npx(
-    "migrate-up",
-    command.migrationsPath ? ["--migrations-path", command.migrationsPath] : ["--migrations-root", command.migrationsRoot]
-  );
+  const up = npx("migrate-up", ["--migrations-root", command.migrationsRoot]);
   deps.log(`$ npx ${setup.join(" ")}`);
   if (!flags.dryRun) await deps.run("npx", setup, flags.cwd);
   deps.log(`$ npx ${up.join(" ")}`);

package/dist/generate/sqlFlags.js

@@ -0,0 +1,27 @@
+const letterCases = ["Upper", "Lower", "Auto"];
+const parseLetterCaseFlag = (raw, name) => {
+  const parsed = letterCases.find((format) => format.toLowerCase() === raw.toLowerCase());
+  if (parsed === void 0) throw new Error(`${name} must be one of [${letterCases.join(", ")}] (got "${raw}").`);
+  return parsed;
+};
+const overlaySqlFlags = (settings, flags) => ({
+  ...settings,
+  ...flags.pluralizeTableNames === void 0 ? {} : { "datasource.pluralize_datatable_names": flags.pluralizeTableNames ? "true" : "false" },
+  ...flags.tableNames === void 0 ? {} : { "datasource.casing.types": flags.tableNames },
+  ...flags.columnNames === void 0 ? {} : { "datasource.casing.fields": flags.columnNames },
+  ...flags.objectNames === void 0 ? {} : { "datasource.casing.objects": flags.objectNames },
+  ...flags.sqlKeywords === void 0 ? {} : { "datasource.casing.keywords": flags.sqlKeywords }
+});
+const sqlFlagsOf = (flags) => ({
+  pluralizeTableNames: flags.pluralizeTableNames,
+  tableNames: flags.tableNames,
+  columnNames: flags.columnNames,
+  objectNames: flags.objectNames,
+  sqlKeywords: flags.sqlKeywords
+});
+export {
+  letterCases,
+  overlaySqlFlags,
+  parseLetterCaseFlag,
+  sqlFlagsOf
+};

package/dist/migrateInit.js

@@ -1,14 +1,15 @@
 const migrateProviders = ["sqlite", "postgres", "mysql", "sqlserver", "oracle"];
 const migrateLanguage = (ecosystem) => ecosystem === "ts" ? "typescript" : ecosystem;
 const sqlMigrateProviders = (names) => migrateProviders.filter((name) => names.includes(name));
-const migrateInitCommands = (dialects, language) => dialects.length === 0 ? [] : [
-  { command: "npm", args: ["install", "@deterministic-code/migraters"] },
+const migratersPackage = (env = process.env) => env.MIGRATERS_PACKAGE || "@deterministic-code/migraters";
+const migrateInitCommands = (dialects, language, env = process.env) => dialects.length === 0 ? [] : [
+  { command: "npm", args: ["install", migratersPackage(env)] },
   {
     command: "npx",
     args: [
       "--yes",
       "--package",
-      "@deterministic-code/migraters",
+      migratersPackage(env),
       "migrate-init",
       "--language",
       language,

package/dist/parse.js

@@ -1,42 +1,62 @@
 import { isEcosystem } from "./detect.js";
+import { parseCaseFlag } from "./generate/casing.js";
+import { parseLetterCaseFlag } from "./generate/sqlFlags.js";
 import { isDialect } from "./generate/GenerateRequest.js";
 const generateTargets = ["all", "types", "repositories", "datasource"];
 const help = `Usage: datasources <command> [options]
 
-setup [provider...]   Interactive .env, provider install, and optional deterministic/
+setup [name...]       Interactive .env, datasource install, and optional deterministic/
   --cwd <dir>                 Consumer project directory (default: .)
-  --ecosystem ts|rust|csharp  Required when more than one project type exists
+  --languages ts|rust|csharp  Project languages (default: every type found)
+  --datasources <name...>     Datasources to install (default: existing .env)
   --dry-run                   Print package-manager commands without running them
   --yes                       Setup without prompts (defaults / existing .env)
 
-add <provider...>     Add provider packages
+add [name...]         Add datasource packages
   --cwd <dir>                 Consumer project directory (default: .)
-  --ecosystem ts|rust|csharp  Required when more than one project type exists
+  --languages ts|rust|csharp  Project languages (default: every type found)
+  --datasources <name...>     Datasources to add
   --dry-run                   Print package-manager commands without running them
 
-remove <provider...>  Remove provider packages
+remove [name...]      Remove datasource packages
   --cwd <dir>                 Consumer project directory (default: .)
-  --ecosystem ts|rust|csharp  Required when more than one project type exists
+  --languages ts|rust|csharp  Project languages (default: every type found)
+  --datasources <name...>     Datasources to remove
   --dry-run                   Print package-manager commands without running them
 
 generate <all|types|repositories|datasource>
                       Types, repository classes, and SQL
+                      https://deterministic-code.github.io/datasources/cli.html#generate
   --dialect csharp|typescript|rust
   --provider <name>           Spec provider (default: deterministic)
   --input <dir>               Deterministic project (default: ./deterministic)
   --output <dir>              Generated files (default: ./generated)
   --no-migrations             Skip SQL migrations (generate all writes them)
-  --no-migrate                Skip migrate-up (generate all applies them)
+  --no-auto-migrate-up        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
+  --pluralize-table-names     Plural table names in SQL and runtime queries (default)
+  --no-pluralize-table-names  Singular table names (procedure names stay plural)
+  --table-names Pascal|Camel|Snake|Kebab|Auto
+  --column-names Pascal|Camel|Snake|Kebab|Auto
+  --object-names Upper|Lower|Auto
+  --sql-keywords Upper|Lower|Auto
+  --file-names Pascal|Camel|Snake|Kebab|Auto
+  --type-names|--types Pascal|Camel|Snake|Kebab|Auto
+  --field-names|--fields Pascal|Camel|Snake|Kebab|Auto
+  --folder-names|--directories Pascal|Camel|Snake|Kebab|Auto
 
 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
+  --pluralize-table-names     Plural table names in SQL (default)
+  --no-pluralize-table-names  Singular table names (procedure names stay plural)
+  --table-names Pascal|Camel|Snake|Kebab|Auto
+  --column-names Pascal|Camel|Snake|Kebab|Auto
+  --object-names Upper|Lower|Auto
+  --sql-keywords Upper|Lower|Auto
 
 version               Snapshot top-level YAML as the next version-*/diff.yaml
   --cwd <dir>                 Consumer project directory (default: .)
@@ -48,7 +68,7 @@ const take = (argv, index, name) => argv[index] ?? (() => {
   throw new Error(`Missing value for ${name}`);
 })();
 const parseArgs = (argv, cwd = ".") => {
-  const flags = { cwd, dryRun: false, yes: false };
+  const flags = { cwd, languages: [], datasources: [], dryRun: false, yes: false };
   const generate = {
     dialect: "",
     provider: "deterministic",
@@ -58,15 +78,29 @@ const parseArgs = (argv, cwd = ".") => {
     migrate: true,
     storedProcedures: false,
     migrationsRoot: "sql",
-    migrationsPath: ""
+    fileNames: void 0,
+    types: void 0,
+    fields: void 0,
+    directories: void 0,
+    pluralizeTableNames: void 0,
+    tableNames: void 0,
+    columnNames: void 0,
+    objectNames: void 0,
+    sqlKeywords: void 0
   };
   const rest = [];
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i];
     if (arg === "--cwd") flags.cwd = argv[++i] ?? flags.cwd;
     else if (arg.startsWith("--cwd=")) flags.cwd = arg.slice("--cwd=".length);
-    else if (arg === "--ecosystem") flags.ecosystem = ecosystem(argv[++i]);
-    else if (arg.startsWith("--ecosystem=")) flags.ecosystem = ecosystem(arg.slice("--ecosystem=".length));
+    else if (arg === "--languages") {
+      i = takeList(argv, ++i, "--languages", (value) => flags.languages.push(language(value)));
+    } else if (arg.startsWith("--languages="))
+      splitList(arg.slice("--languages=".length), "--languages").forEach((value) => flags.languages.push(language(value)));
+    else if (arg === "--datasources") {
+      i = takeList(argv, ++i, "--datasources", (value) => flags.datasources.push(value));
+    } else if (arg.startsWith("--datasources="))
+      flags.datasources.push(...splitList(arg.slice("--datasources=".length), "--datasources"));
     else if (arg === "--dry-run") flags.dryRun = true;
     else if (arg === "--yes" || arg === "-y") flags.yes = true;
     else if (arg === "--dialect") generate.dialect = take(argv, ++i, "--dialect");
@@ -78,23 +112,41 @@ const parseArgs = (argv, cwd = ".") => {
     else if (arg === "--output") generate.output = take(argv, ++i, "--output");
     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 === "--no-auto-migrate-up") generate.migrate = false;
     else if (arg === "--stored-procedures") generate.storedProcedures = true;
+    else if (arg === "--pluralize-table-names") generate.pluralizeTableNames = true;
+    else if (arg === "--no-pluralize-table-names") generate.pluralizeTableNames = false;
+    else if (arg === "--table-names") generate.tableNames = parseCaseFlag(take(argv, ++i, arg), arg);
+    else if (arg.startsWith("--table-names=")) generate.tableNames = parseCaseFlag(arg.slice("--table-names=".length), "--table-names");
+    else if (arg === "--column-names") generate.columnNames = parseCaseFlag(take(argv, ++i, arg), arg);
+    else if (arg.startsWith("--column-names=")) generate.columnNames = parseCaseFlag(arg.slice("--column-names=".length), "--column-names");
+    else if (arg === "--object-names") generate.objectNames = parseLetterCaseFlag(take(argv, ++i, arg), arg);
+    else if (arg.startsWith("--object-names=")) generate.objectNames = parseLetterCaseFlag(arg.slice("--object-names=".length), "--object-names");
+    else if (arg === "--sql-keywords") generate.sqlKeywords = parseLetterCaseFlag(take(argv, ++i, arg), arg);
+    else if (arg.startsWith("--sql-keywords=")) generate.sqlKeywords = parseLetterCaseFlag(arg.slice("--sql-keywords=".length), "--sql-keywords");
     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");
-    else if (arg.startsWith("--migrations-path=")) generate.migrationsPath = arg.slice("--migrations-path=".length);
+    else if (arg === "--file-names" || arg === "--type-names" || arg === "--types" || arg === "--field-names" || arg === "--fields" || arg === "--folder-names" || arg === "--directories") {
+      const key = arg === "--file-names" ? "fileNames" : arg === "--type-names" || arg === "--types" ? "types" : arg === "--field-names" || arg === "--fields" ? "fields" : "directories";
+      generate[key] = parseCaseFlag(take(argv, ++i, arg), arg);
+    } else if (arg.startsWith("--file-names=")) generate.fileNames = parseCaseFlag(arg.slice("--file-names=".length), "--file-names");
+    else if (arg.startsWith("--type-names=")) generate.types = parseCaseFlag(arg.slice("--type-names=".length), "--type-names");
+    else if (arg.startsWith("--types=")) generate.types = parseCaseFlag(arg.slice("--types=".length), "--types");
+    else if (arg.startsWith("--field-names=")) generate.fields = parseCaseFlag(arg.slice("--field-names=".length), "--field-names");
+    else if (arg.startsWith("--fields=")) generate.fields = parseCaseFlag(arg.slice("--fields=".length), "--fields");
+    else if (arg.startsWith("--folder-names=")) generate.directories = parseCaseFlag(arg.slice("--folder-names=".length), "--folder-names");
+    else if (arg.startsWith("--directories=")) generate.directories = parseCaseFlag(arg.slice("--directories=".length), "--directories");
     else if (arg === "--help" || arg === "-h") return { command: { kind: "help" }, flags };
     else rest.push(arg);
   }
   const [verb, ...names] = rest;
-  return { command: commandOf(verb, names, generate), flags };
+  return { command: commandOf(verb, names, flags.datasources, generate), flags };
 };
-const commandOf = (verb, names, generate) => {
+const commandOf = (verb, names, datasources, generate) => {
   if (verb === void 0 || verb === "help") return { kind: "help" };
-  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 === "setup") return { kind: "setup", providers: unique([...datasources, ...names]) };
+  if (verb === "add") return { kind: "add", providers: unique([...datasources, ...names]) };
+  if (verb === "remove") return { kind: "remove", providers: unique([...datasources, ...names]) };
   if (verb === "generate") return generateCommand(names, generate);
   if (verb === "migrations") return migrationsCommand(names, generate);
   if (verb === "version") return versionCommand(names, generate.input);
@@ -111,7 +163,11 @@ ${help}`);
     input: generate.input,
     storedProcedures: generate.storedProcedures,
     migrationsRoot: generate.migrationsRoot,
-    ...generate.migrationsPath === "" ? {} : { migrationsPath: generate.migrationsPath }
+    pluralizeTableNames: generate.pluralizeTableNames,
+    tableNames: generate.tableNames,
+    columnNames: generate.columnNames,
+    objectNames: generate.objectNames,
+    sqlKeywords: generate.sqlKeywords
   };
 };
 const versionCommand = (names, input) => {
@@ -137,12 +193,33 @@ ${help}`);
     migrate: generate.migrate,
     storedProcedures: generate.storedProcedures,
     migrationsRoot: generate.migrationsRoot,
-    ...generate.migrationsPath === "" ? {} : { migrationsPath: generate.migrationsPath }
+    fileNames: generate.fileNames,
+    types: generate.types,
+    fields: generate.fields,
+    directories: generate.directories,
+    pluralizeTableNames: generate.pluralizeTableNames,
+    tableNames: generate.tableNames,
+    columnNames: generate.columnNames,
+    objectNames: generate.objectNames,
+    sqlKeywords: generate.sqlKeywords
   };
 };
-const ecosystem = (value) => value && isEcosystem(value) ? value : (() => {
-  throw new Error(`Unknown --ecosystem ${value}. Use ts|rust|csharp`);
+const language = (value) => value === "typescript" ? "ts" : isEcosystem(value) ? value : (() => {
+  throw new Error(`Unknown --languages ${value}. Use ts|rust|csharp`);
 })();
+const unique = (names) => [...new Set(names)];
+const splitList = (value, name) => {
+  const names = value.split(",").map((part) => part.trim()).filter(Boolean);
+  return names.length ? names : (() => {
+    throw new Error(`Missing value for ${name}`);
+  })();
+};
+const takeList = (argv, index, name, push) => {
+  if (index >= argv.length || argv[index].startsWith("-")) throw new Error(`Missing value for ${name}`);
+  let i = index;
+  while (i < argv.length && !argv[i].startsWith("-")) push(argv[i++]);
+  return i - 1;
+};
 export {
   generateTargets,
   help,

package/dist/run.js

@@ -1,8 +1,7 @@
-import { access, copyFile, mkdir } from "node:fs/promises";
 import { join } from "node:path";
-import { catalog, requireProviders } from "./catalog.js";
+import { requireProviders } from "./catalog.js";
 import { addCommands, removeCommands } from "./commands.js";
-import { csharpTarget, detect, resolveEcosystem } from "./detect.js";
+import { csharpTarget, detect, requireProjects, resolveLanguages } from "./detect.js";
 import { parseEnv, serializeEnv, updateEnvProviders } from "./env.js";
 import { defaultDatasourceYaml } from "./generate/loadSpec.js";
 import {
@@ -15,9 +14,11 @@ import { applyMigrations } from "./generate/applyMigrations.js";
 import { applyMigrateUp } from "./generate/migrateUp.js";
 import { migrateInitCommands, migrateLanguage, sqlMigrateProviders } from "./migrateInit.js";
 import { help, parseArgs } from "./parse.js";
+import { sqlFlagsOf } from "./generate/sqlFlags.js";
 import { applyVersion } from "./version/applyVersion.js";
 import { answersForSetup, envFromAnswers, promptSetup, starterTypesYaml } from "./setup.js";
 import { wireRegister } from "./wireRegister.js";
+import { wireRustProviders } from "./wireRustProviders.js";
 const run = async (argv, deps, cwd = ".") => {
   try {
     const parsed = parseArgs(argv, cwd);
@@ -45,7 +46,7 @@ const dispatch = async (command, flags, deps) => {
         input: command.input,
         storedProcedures: command.storedProcedures,
         migrationsRoot: command.migrationsRoot,
-        ...command.migrationsPath === void 0 ? {} : { migrationsPath: command.migrationsPath }
+        ...sqlFlagsOf(command)
       },
       flags,
       deps
@@ -53,33 +54,41 @@ const dispatch = async (command, flags, deps) => {
   if (command.migrate) await applyMigrateUp(command, flags, deps);
 };
 const needNames = (names, verb) => names.length ? names : (() => {
-  throw new Error(`Usage: datasources ${verb} <provider...>`);
+  throw new Error(`Usage: datasources ${verb} --datasources <name...>`);
 })();
 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);
+  const existing = {
+    ...await readEnv(deps.fs, flags.cwd),
+    ...process.env.INSTALLED_PROVIDERS ? { INSTALLED_PROVIDERS: process.env.INSTALLED_PROVIDERS } : {},
+    ...process.env.PROVIDER ? { PROVIDER: process.env.PROVIDER } : {},
+    ...process.env.DATASOURCE_URL ? { DATASOURCE_URL: process.env.DATASOURCE_URL } : {}
+  };
   const specDir = join(flags.cwd, "deterministic");
   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 ? { ...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 answers = flags.yes ? { ...answersForSetup(existing, requested), languages: flags.languages, scaffold: false } : await promptSetup(deps.prompt, existing, found, flags.languages, missingSpec, requested);
+  const languages = resolveLanguages(found, answers.languages ?? flags.languages);
+  requireProjects(languages, entries);
   const selected = requireProviders(answers.providers);
-  const installed = await readInstalled(deps.fs, flags.cwd, ecosystem, entries);
   if (!flags.dryRun) await writeEnv(deps.fs, flags.cwd, { ...existing, ...envFromAnswers(answers) });
-  await applyPackages(
-    flags,
-    deps,
-    ecosystem,
-    entries,
-    selected.filter((name) => !installed.includes(name)),
-    installed.filter((name) => !selected.includes(name)),
-    selected
-  );
-  await applyMigrateInit(flags, deps, ecosystem, selected);
-  const dialect = migrateLanguage(ecosystem);
-  await wireRegister(flags.cwd, "generated", dialect, flags.dryRun, deps);
+  for (const language of languages) {
+    const installed = await readInstalled(deps.fs, flags.cwd, language, entries);
+    await applyPackages(
+      flags,
+      deps,
+      language,
+      entries,
+      selected.filter((name) => !installed.includes(name)),
+      installed.filter((name) => !selected.includes(name)),
+      selected
+    );
+    await applyMigrateInit(flags, deps, language, selected);
+    const dialect = migrateLanguage(language);
+    await wireRegister(flags.cwd, "generated", dialect, flags.dryRun, deps);
+  }
   if (!answers.scaffold) return;
   if (flags.dryRun) {
     deps.log(typesPath);
@@ -93,16 +102,19 @@ const applySetup = async (flags, deps, requested) => {
 const applyAddRemove = async (flags, deps, add, remove) => {
   const entries = await deps.fs.readdir(flags.cwd);
   const found = detect(entries);
-  const ecosystem = resolveEcosystem(found, flags.ecosystem);
-  const installed = await readInstalled(deps.fs, flags.cwd, ecosystem, entries);
-  const remaining = [
-    ...installed.filter((name) => !remove.includes(name)),
-    ...add.filter((name) => !installed.includes(name))
-  ];
+  const languages = resolveLanguages(found, flags.languages);
+  requireProjects(languages, entries);
   const env = await readEnvFile(deps.fs, join(flags.cwd, ".env"));
   if (env && !flags.dryRun) await writeEnv(deps.fs, flags.cwd, updateEnvProviders(env, add, remove));
-  await applyPackages(flags, deps, ecosystem, entries, add, remove, remaining);
-  await applyMigrateInit(flags, deps, ecosystem, remaining);
+  for (const language of languages) {
+    const installed = await readInstalled(deps.fs, flags.cwd, language, entries);
+    const remaining = [
+      ...installed.filter((name) => !remove.includes(name)),
+      ...add.filter((name) => !installed.includes(name))
+    ];
+    await applyPackages(flags, deps, language, entries, add, remove, remaining);
+    await applyMigrateInit(flags, deps, language, remaining);
+  }
 };
 const applyPackages = async (flags, deps, ecosystem, entries, add, remove, remaining) => {
   const procs = [
@@ -113,17 +125,7 @@ const applyPackages = async (flags, deps, ecosystem, entries, add, remove, remai
     deps.log(`$ ${proc.command} ${proc.args.join(" ")}`);
     if (!flags.dryRun) await deps.run(proc.command, proc.args, flags.cwd);
   }
-  if (ecosystem === "rust") {
-    for (const name of add) {
-      const proc = { command: "cargo", args: ["build", "-p", catalog[name].cargo] };
-      deps.log(`$ ${proc.command} ${proc.args.join(" ")}`);
-      if (!flags.dryRun) {
-        await deps.run(proc.command, proc.args, flags.cwd);
-        const copied = await copyPlugin(flags.cwd, catalog[name].cargo);
-        if (copied) deps.log(`copy ${copied}`);
-      }
-    }
-  }
+  if (ecosystem === "rust") await wireRustProviders(flags.cwd, remaining, flags.dryRun, deps);
 };
 const applyMigrateInit = async (flags, deps, ecosystem, remaining) => {
   for (const proc of migrateInitCommands(sqlMigrateProviders(remaining), migrateLanguage(ecosystem))) {
@@ -161,33 +163,6 @@ const optional = async (fs, path) => {
     return void 0;
   }
 };
-const pluginFileName = (cargoName, platform = process.platform) => {
-  const stem = cargoName.replaceAll("-", "_");
-  return platform === "win32" ? `${stem}.dll` : platform === "darwin" ? `lib${stem}.dylib` : `lib${stem}.so`;
-};
-const copyPlugin = async (cwd, cargoName) => {
-  const file = pluginFileName(cargoName);
-  const source = await firstFile(
-    [0, 1, 2].map((up) => join(cwd, ...Array.from({ length: up }, () => ".."), "target", "debug", file))
-  );
-  if (!source) return void 0;
-  const dest = join(cwd, "plugins", file);
-  await mkdir(join(cwd, "plugins"), { recursive: true });
-  await copyFile(source, dest);
-  return dest;
-};
-const firstFile = async (paths) => {
-  for (const path of paths) {
-    try {
-      await access(path);
-      return path;
-    } catch {
-      continue;
-    }
-  }
-  return void 0;
-};
 export {
-  pluginFileName,
   run
 };

package/dist/setup.js

@@ -15,16 +15,15 @@ types:
             size: 128
 `;
 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 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 })),
-    default: found[0]
-  })));
+  const picked = explicit.length ? explicit : found.length === 1 ? found : found.length === 0 ? [] : (await prompt.checkbox({
+    message: "Languages",
+    choices: found.map((value) => ({ name: value, value, checked: true }))
+  })).filter(isEcosystem);
   const fromUrl = scheme(defaults.url);
   const selected = await prompt.checkbox({
-    message: "Providers",
+    message: "Datasources",
     choices: providers.map((value) => ({
       name: value,
       value,
@@ -37,9 +36,8 @@ const promptSetup = async (prompt, env, found, explicit, askScaffold = false, re
   });
   const schema = await prompt.input({ message: "schema", default: defaults.schema });
   const scaffold = askScaffold ? await prompt.confirm({ message: "Create deterministic directory", default: true }) : false;
-  return { ecosystem, providers: selected, url, schema, scaffold };
+  return { languages: picked.length ? picked : void 0, providers: selected, url, schema, scaffold };
 };
-const ecosystemOr = (value) => isEcosystem(value) ? value : void 0;
 const envFromAnswers = (answers) => {
   const provider = scheme(answers.url) ?? answers.providers[0] ?? "sqlite";
   return {

package/dist/version/applyVersion.js

@@ -1,17 +1,21 @@
 import { isAbsolute, join } from "node:path";
-import { applyDocument, asDocument, parseYaml, render } from "./render.js";
+import { VersionSnapshot } from "@deterministic-code/deterministic-generators-common/parser";
+import { parseYaml, render } from "./render.js";
 const versionDir = /^version-\d{8}T\d{6}Z-(\d{3})$/;
 const at = (root, path) => isAbsolute(path) ? path : join(root, path);
 const applyVersion = async (command, flags, deps, now = () => /* @__PURE__ */ new Date()) => {
   const root = at(flags.cwd, command.input);
   const names = await deps.fs.readdir(root);
   const versions = names.filter((name) => versionDir.test(name)).sort();
-  let before = {};
-  for (const dir of versions) {
-    const text = await optional(deps.fs, join(root, dir, "diff.yaml"));
-    if (text === void 0 || text === "") continue;
-    before = applyDocument(before, asDocument(parseYaml(text), `${dir}/diff.yaml`));
-  }
+  const diffs = (await Promise.all(
+    versions.map(async (dir) => {
+      const listed = await deps.fs.readdir(join(root, dir));
+      if (!listed.includes("diff.yaml")) return void 0;
+      const text = await deps.fs.readFile(join(root, dir, "diff.yaml"));
+      return text === "" ? void 0 : parseYaml(text);
+    })
+  )).filter((diff) => diff !== void 0);
+  const before = VersionSnapshot.combine(diffs).documents;
   const current = names.filter((name) => name.endsWith(".yaml")).sort();
   const paths = [.../* @__PURE__ */ new Set([...Object.keys(before), ...current])];
   const yaml = render(
@@ -39,13 +43,6 @@ const nextSeq = (versions) => {
 };
 const pad = (n) => String(n).padStart(3, "0");
 const stamp = (date) => date.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}/, "");
-const optional = async (fs, path) => {
-  try {
-    return await fs.readFile(path);
-  } catch {
-    return void 0;
-  }
-};
 export {
   applyVersion
 };

package/dist/version/delta.js

@@ -4,20 +4,6 @@ const delta = (before, after) => {
   const value = build(before, after);
   return value === unchanged ? void 0 : value;
 };
-const apply = (before, next) => {
-  if (next == null) return before;
-  if (isKeyedCollection(before) && isKeyedSplit(next)) return applyKeyed(before, next);
-  if (isObject(before) && isObject(next)) return applyObject(before, next);
-  return next;
-};
-const applyFile = (before, envelope) => {
-  if (envelope == null) return before;
-  if (isObject(envelope)) {
-    if (envelope.removed === true && Object.keys(envelope).length === 1) return void 0;
-    if (envelope.added === true) return envelope.content;
-  }
-  return apply(before ?? null, envelope);
-};
 const build = (before, after) => {
   if (isDeepStrictEqual(before, after)) return unchanged;
   if (isKeyedCollection(before) && isKeyedCollection(after)) return keyedSplit(before, after);
@@ -60,40 +46,6 @@ const objectDelta = (beforeObj, afterObj) => {
   if (removed.length) result.removed = removed;
   return Object.keys(result).length === 0 ? unchanged : result;
 };
-const applyKeyed = (beforeVal, split) => {
-  const removed = new Set(split.removed ?? []);
-  const changed = /* @__PURE__ */ new Map();
-  for (const entry of split.changed ?? []) {
-    const key = Object.keys(entry)[0];
-    changed.set(key, entry[key]);
-  }
-  return [
-    ...beforeVal.flatMap((entry) => {
-      const key = Object.keys(entry)[0];
-      if (removed.has(key)) return [];
-      return changed.has(key) ? [{ [key]: apply(entry[key], changed.get(key)) }] : [entry];
-    }),
-    ...split.added ?? []
-  ];
-};
-const applyObject = (beforeVal, next) => {
-  const removed = new Set(Array.isArray(next.removed) ? next.removed : []);
-  const out = {};
-  for (const key of Object.keys(beforeVal)) {
-    if (removed.has(key)) continue;
-    out[key] = key in next ? apply(beforeVal[key], next[key]) : beforeVal[key];
-  }
-  for (const key of Object.keys(next)) {
-    if (key === "removed" && Array.isArray(next.removed)) continue;
-    if (!(key in beforeVal)) out[key] = next[key];
-  }
-  return out;
-};
-const isKeyedSplit = (value) => {
-  if (!isObject(value)) return false;
-  const allowed = /* @__PURE__ */ new Set(["added", "changed", "removed"]);
-  return Object.keys(value).every((key) => allowed.has(key));
-};
 const isObject = (value) => value !== null && value !== void 0 && typeof value === "object" && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
 const isKeyedCollection = (value) => Array.isArray(value) && value.length > 0 && value.every(
   (item) => item !== null && typeof item === "object" && !Array.isArray(item) && Object.keys(item).length === 1
@@ -107,8 +59,6 @@ const keyedMap = (arr) => {
   return map;
 };
 export {
-  apply,
-  applyFile,
   delta,
   isObject
 };

package/dist/version/render.js

@@ -1,5 +1,5 @@
 import { parse, stringify } from "yaml";
-import { applyFile, delta, isObject } from "./delta.js";
+import { delta, isObject } from "./delta.js";
 const render = (files) => {
   const out = {};
   for (const { path, before, after } of files) {
@@ -18,20 +18,10 @@ const render = (files) => {
   return Object.keys(out).length === 0 ? "" : stringify(out);
 };
 const parseYaml = (text) => parse(text);
-const applyDocument = (before, doc) => {
-  const out = { ...before };
-  for (const [path, envelope] of Object.entries(doc)) {
-    const next = applyFile(out[path], envelope);
-    if (next === void 0) delete out[path];
-    else out[path] = next;
-  }
-  return out;
-};
 const asDocument = (value, source) => isObject(value) ? value : (() => {
   throw new Error(`${source}: expected a mapping`);
 })();
 export {
-  applyDocument,
   asDocument,
   parseYaml,
   render