@deterministic-code/datasources-cli 0.1.13 → 0.1.15

package/dist/generate/applyMigrations.js

@@ -1,33 +1,30 @@
 import { isAbsolute, join } from "node:path";
-import { generate as generateSql } from "@deterministic-code/datasources-code-generators/generate-sql";
+import { generateSql } from "@deterministic-code/datasources-code-generators";
 import { memoryReader } from "@deterministic-code/generators-common/deterministic-reader";
+import { destEnv } from "./destEnv.js";
 import { loadSpec } from "./loadSpec.js";
 import { providerByName } from "./providers.js";
+import { overlaySqlFlags } from "./sqlFlags.js";
+import { sqlDialectsFromEnv } from "./sqlDialects.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)
-  });
-  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 entries = await generateSql(
+    {
+      reader: memoryReader(loaded.files),
+      settings: overlaySqlFlags(withStoredProcedures(loaded.settings, command.storedProcedures), command)
+    },
+    sqlDialectsFromEnv(await destEnv(deps.fs, flags.cwd))
+  );
+  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
+};

package/dist/generate/destEnv.js

@@ -0,0 +1,12 @@
+import { join } from "node:path";
+import { overlayEnv, parseEnv } from "../env.js";
+const destEnv = async (fs, cwd) => {
+  try {
+    return overlayEnv(parseEnv(await fs.readFile(join(cwd, ".env"))), process.env);
+  } catch {
+    return overlayEnv({}, process.env);
+  }
+};
+export {
+  destEnv
+};

package/dist/generate/migrateUp.js

@@ -1,30 +1,8 @@
 import { isAbsolute, join } from "node:path";
-import { parseEnv, scheme } from "../env.js";
-import { migrateProviders } from "../migrateInit.js";
+import { overlayEnv, parseEnv, scheme } from "../env.js";
 import { loadSpec } from "./loadSpec.js";
+import { canonical, isSql, sqlDialectsFromEnv } from "./sqlDialects.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")));
@@ -32,20 +10,15 @@ const readEnv = async (fs, cwd) => {
     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);
+  await loadSpec(deps.fs, at(flags.cwd, command.input));
+  const values = overlayEnv(await readEnv(deps.fs, flags.cwd), env);
+  const dialects = sqlDialectsFromEnv(values);
   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)) {
@@ -58,12 +31,9 @@ const applyMigrateUp = async (command, flags, deps, env = process.env) => {
   }
   if (!dialects.includes(provider))
     throw new Error(
-      `migrate-up: provider ${provider} is not in backend.datasources (${dialects.join(", ") || "none"})`
+      `migrate-up: provider ${provider} is not in INSTALLED_PROVIDERS (${dialects.join(", ") || "none"})`
     );
   const npx = (verb, extra = []) => [
-    "--yes",
-    "--package",
-    "@deterministic-code/migraters",
     verb,
     "--provider",
     provider,
@@ -72,10 +42,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/sqlDialects.js

@@ -0,0 +1,29 @@
+import { scheme, splitProviders } from "../env.js";
+import { migrateProviders } from "../migrateInit.js";
+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 sqlDialectsFromEnv = (env) => {
+  const out = [];
+  for (const name of splitProviders(env.INSTALLED_PROVIDERS || env.PROVIDER || scheme(env.DATASOURCE_URL || "") || "")) {
+    const key = canonical(name);
+    if (key !== "" && isSql(key) && !out.includes(key)) out.push(key);
+  }
+  return out;
+};
+export {
+  canonical,
+  isSql,
+  sqlDialectsFromEnv
+};

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