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

package/dist/io.js

@@ -0,0 +1,35 @@
+import { spawn } from "node:child_process";
+import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { checkbox, confirm, input, select } from "@inquirer/prompts";
+const nodeFs = {
+  readFile: (path) => readFile(path, "utf8"),
+  writeFile: async (path, text) => {
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, text);
+  },
+  readdir
+};
+const spawnRunner = (command, args, cwd) => new Promise((resolve, reject) => {
+  const child = spawn(command, args, {
+    cwd,
+    stdio: "inherit",
+    shell: process.platform === "win32"
+  });
+  child.on("error", reject);
+  child.on(
+    "exit",
+    (code) => code === 0 ? resolve() : reject(new Error(`${command} exited ${code}`))
+  );
+});
+const inquirerPrompt = {
+  select: ({ message, choices, default: def }) => select({ message, choices, default: def }),
+  checkbox: ({ message, choices }) => checkbox({ message, choices, required: true }),
+  input: ({ message, default: def }) => input({ message, default: def }),
+  confirm: ({ message, default: def }) => confirm({ message, default: def })
+};
+export {
+  inquirerPrompt,
+  nodeFs,
+  spawnRunner
+};

package/dist/main.js

@@ -0,0 +1,10 @@
+import { inquirerPrompt, nodeFs, spawnRunner } from "./io.js";
+import { run } from "./run.js";
+const code = await run(process.argv.slice(2), {
+  fs: nodeFs,
+  run: spawnRunner,
+  log: (line) => console.log(line),
+  err: (line) => console.error(line),
+  prompt: inquirerPrompt
+});
+process.exit(code);

package/dist/migrateInit.js

@@ -0,0 +1,11 @@
+const migrateProviders = ["sqlite", "postgres", "mysql", "sqlserver", "oracle"];
+const sqlMigrateProviders = (names) => migrateProviders.filter((name) => names.includes(name));
+const migrateInitCommands = (dialects) => dialects.length === 0 ? [] : [
+  { command: "npm", args: ["install", "@deterministic-code/migraters"] },
+  { command: "npx", args: ["migrate-init", ...dialects.flatMap((name) => ["--dialect", name])] }
+];
+export {
+  migrateInitCommands,
+  migrateProviders,
+  sqlMigrateProviders
+};

package/dist/parse.js

@@ -0,0 +1,144 @@
+import { isEcosystem } from "./detect.js";
+import { isDialect } from "./generate/GenerateRequest.js";
+const generateTargets = ["all", "types", "repositories", "datasource"];
+const help = `Usage: datasources <command> [options]
+
+setup                 Interactive .env, provider install, and optional deterministic/
+  --cwd <dir>                 Consumer project directory (default: .)
+  --ecosystem ts|rust|csharp  Required when more than one project type exists
+  --dry-run                   Print package-manager commands without running them
+  --yes                       Setup without prompts (defaults / existing .env)
+
+add <provider...>     Add provider packages
+  --cwd <dir>                 Consumer project directory (default: .)
+  --ecosystem ts|rust|csharp  Required when more than one project type exists
+  --dry-run                   Print package-manager commands without running them
+
+remove <provider...>  Remove provider packages
+  --cwd <dir>                 Consumer project directory (default: .)
+  --ecosystem ts|rust|csharp  Required when more than one project type exists
+  --dry-run                   Print package-manager commands without running them
+
+generate <all|types|repositories|datasource>
+                      Types, repository classes, and SQL
+  --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)
+  --migrations-root <dir>     Root prefix for generate all (default: sql)
+  --migrations-path <dir>     One migrations directory (single SQL dialect)
+
+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)
+
+version               Snapshot top-level YAML as the next version-*/diff.yaml
+  --cwd <dir>                 Consumer project directory (default: .)
+  --input <dir>               Deterministic project (default: ./deterministic)
+  --dry-run                   Print the version path without writing
+`;
+const isTarget = (value) => generateTargets.includes(value);
+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 generate = {
+    dialect: "",
+    provider: "deterministic",
+    input: "deterministic",
+    output: "generated",
+    migrations: true,
+    migrate: true,
+    migrationsRoot: "sql",
+    migrationsPath: ""
+  };
+  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 === "--dry-run") flags.dryRun = true;
+    else if (arg === "--yes" || arg === "-y") flags.yes = true;
+    else if (arg === "--dialect") generate.dialect = take(argv, ++i, "--dialect");
+    else if (arg.startsWith("--dialect=")) generate.dialect = arg.slice("--dialect=".length);
+    else if (arg === "--provider") generate.provider = take(argv, ++i, "--provider");
+    else if (arg.startsWith("--provider=")) generate.provider = arg.slice("--provider=".length);
+    else if (arg === "--input") generate.input = take(argv, ++i, "--input");
+    else if (arg.startsWith("--input=")) generate.input = arg.slice("--input=".length);
+    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 === "--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 === "--help" || arg === "-h") return { command: { kind: "help" }, flags };
+    else rest.push(arg);
+  }
+  const [verb, ...names] = rest;
+  return { command: commandOf(verb, names, generate), flags };
+};
+const commandOf = (verb, names, generate) => {
+  if (verb === void 0 || verb === "help") return { kind: "help" };
+  if (verb === "setup") return { kind: "setup" };
+  if (verb === "add") return { kind: "add", providers: names };
+  if (verb === "remove") return { kind: "remove", providers: names };
+  if (verb === "generate") return generateCommand(names, generate);
+  if (verb === "migrations") return migrationsCommand(names, generate);
+  if (verb === "version") return versionCommand(names, generate.input);
+  throw new Error(`Unknown command: ${verb}
+${help}`);
+};
+const migrationsCommand = (names, generate) => {
+  if (names.length !== 1 || names[0] !== "create")
+    throw new Error(`Usage: datasources migrations create
+${help}`);
+  return {
+    kind: "migrations-create",
+    provider: generate.provider,
+    input: generate.input,
+    migrationsRoot: generate.migrationsRoot,
+    ...generate.migrationsPath === "" ? {} : { migrationsPath: generate.migrationsPath }
+  };
+};
+const versionCommand = (names, input) => {
+  if (names.length) throw new Error(`Usage: datasources version
+${help}`);
+  return { kind: "version", input };
+};
+const generateCommand = (names, generate) => {
+  if (names.length !== 1) throw new Error(`Usage: datasources generate <all|types|repositories|datasource>
+${help}`);
+  const target = names[0];
+  if (!isTarget(target)) throw new Error(`Usage: datasources generate <all|types|repositories|datasource>
+${help}`);
+  if (!isDialect(generate.dialect)) throw new Error("--dialect is required (csharp|typescript|rust)");
+  return {
+    kind: "generate",
+    target,
+    dialect: generate.dialect,
+    provider: generate.provider,
+    input: generate.input,
+    output: generate.output,
+    migrations: generate.migrations,
+    migrate: generate.migrate,
+    migrationsRoot: generate.migrationsRoot,
+    ...generate.migrationsPath === "" ? {} : { migrationsPath: generate.migrationsPath }
+  };
+};
+const ecosystem = (value) => value && isEcosystem(value) ? value : (() => {
+  throw new Error(`Unknown --ecosystem ${value}. Use ts|rust|csharp`);
+})();
+export {
+  generateTargets,
+  help,
+  parseArgs
+};

package/dist/run.js

@@ -0,0 +1,197 @@
+import { access, copyFile, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { catalog, requireProviders } from "./catalog.js";
+import { addCommands, removeCommands } from "./commands.js";
+import { csharpTarget, detect, resolveEcosystem } from "./detect.js";
+import {
+  answersFromEnv,
+  parseEnv,
+  serializeEnv,
+  updateEnvProviders
+} from "./env.js";
+import { defaultDatasourceYaml } from "./generate/loadSpec.js";
+import {
+  cargoProviders,
+  csharpProviders,
+  npmProviders
+} from "./installed.js";
+import { applyGenerate } from "./generate/applyGenerate.js";
+import { applyMigrations } from "./generate/applyMigrations.js";
+import { applyMigrateUp } from "./generate/migrateUp.js";
+import { migrateInitCommands, sqlMigrateProviders } from "./migrateInit.js";
+import { help, parseArgs } from "./parse.js";
+import { applyVersion } from "./version/applyVersion.js";
+import { envFromAnswers, promptSetup, starterTypesYaml } from "./setup.js";
+import { wireRegister } from "./wireRegister.js";
+const run = async (argv, deps, cwd = ".") => {
+  try {
+    const parsed = parseArgs(argv, cwd);
+    await dispatch(parsed.command, parsed.flags, deps);
+    return 0;
+  } catch (error) {
+    deps.err(error instanceof Error ? error.message : "Unknown error");
+    return 1;
+  }
+};
+const dispatch = async (command, flags, deps) => {
+  if (command.kind === "help") return deps.log(help.trimEnd());
+  if (command.kind === "setup") return applySetup(flags, deps);
+  if (command.kind === "add") return applyAddRemove(flags, deps, requireProviders(needNames(command.providers, "add")), []);
+  if (command.kind === "remove") return applyAddRemove(flags, deps, [], requireProviders(needNames(command.providers, "remove")));
+  if (command.kind === "version") return applyVersion(command, flags, deps);
+  if (command.kind === "migrations-create") return applyMigrations(command, flags, deps);
+  await applyGenerate(command, flags, deps);
+  if (command.target !== "all") return;
+  if (command.migrations)
+    await applyMigrations(
+      {
+        kind: "migrations-create",
+        provider: command.provider,
+        input: command.input,
+        migrationsRoot: command.migrationsRoot,
+        ...command.migrationsPath === void 0 ? {} : { migrationsPath: command.migrationsPath }
+      },
+      flags,
+      deps
+    );
+  if (command.migrate) await applyMigrateUp(command, flags, deps);
+};
+const needNames = (names, verb) => names.length ? names : (() => {
+  throw new Error(`Usage: datasources ${verb} <provider...>`);
+})();
+const applySetup = async (flags, deps) => {
+  const entries = await deps.fs.readdir(flags.cwd);
+  const found = detect(entries);
+  const existing = await readEnv(deps.fs, flags.cwd);
+  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 ? { ...answersFromEnv(existing), ecosystem: flags.ecosystem, scaffold: false } : await promptSetup(deps.prompt, existing, found, flags.ecosystem, missingSpec);
+  const ecosystem = resolveEcosystem(found, answers.ecosystem ?? flags.ecosystem);
+  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 = ecosystem === "ts" ? "typescript" : ecosystem;
+  await wireRegister(flags.cwd, "generated", dialect, flags.dryRun, deps);
+  if (!answers.scaffold) return;
+  if (flags.dryRun) {
+    deps.log(typesPath);
+    deps.log(datasourcePath);
+    return;
+  }
+  await deps.fs.writeFile(typesPath, starterTypesYaml);
+  if (await optional(deps.fs, datasourcePath) === void 0)
+    await deps.fs.writeFile(datasourcePath, defaultDatasourceYaml);
+};
+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 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);
+};
+const applyPackages = async (flags, deps, ecosystem, entries, add, remove, remaining) => {
+  const procs = [
+    ...add.length ? addCommands(ecosystem, add, entries) : [],
+    ...remove.length ? removeCommands(ecosystem, remove, remaining, entries) : []
+  ];
+  for (const proc of procs) {
+    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}`);
+      }
+    }
+  }
+};
+const applyMigrateInit = async (flags, deps, ecosystem, remaining) => {
+  if (ecosystem !== "ts") return;
+  for (const proc of migrateInitCommands(sqlMigrateProviders(remaining))) {
+    deps.log(`$ ${proc.command} ${proc.args.join(" ")}`);
+    if (!flags.dryRun) await deps.run(proc.command, proc.args, flags.cwd);
+  }
+};
+const readInstalled = async (fs, cwd, ecosystem, entries) => ({
+  ts: async () => {
+    const text = await optional(fs, join(cwd, "package.json"));
+    return text ? npmProviders(JSON.parse(text)) : [];
+  },
+  rust: async () => {
+    const text = await optional(fs, join(cwd, "Cargo.toml"));
+    return text ? cargoProviders(text) : [];
+  },
+  csharp: async () => {
+    const target = csharpTarget(entries);
+    const text = target.endsWith(".csproj") ? await optional(fs, join(cwd, target)) : void 0;
+    return text ? csharpProviders(text) : [];
+  }
+})[ecosystem]();
+const readEnv = async (fs, cwd) => parseEnv(
+  await optional(fs, join(cwd, ".env")) ?? await optional(fs, join(cwd, ".env.example")) ?? ""
+);
+const readEnvFile = async (fs, path) => {
+  const text = await optional(fs, path);
+  return text === void 0 ? void 0 : parseEnv(text);
+};
+const writeEnv = (fs, cwd, env) => fs.writeFile(join(cwd, ".env"), serializeEnv(env));
+const optional = async (fs, path) => {
+  try {
+    return await fs.readFile(path);
+  } catch {
+    return void 0;
+  }
+};
+const pluginFileName = (cargoName) => {
+  const stem = cargoName.replaceAll("-", "_");
+  return process.platform === "win32" ? `${stem}.dll` : process.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 {
+  run
+};

package/dist/setup.js

@@ -0,0 +1,54 @@
+import { providers } from "./catalog.js";
+import { isEcosystem } from "./detect.js";
+import { answersFromEnv, ensureProviders, scheme, withSchema } from "./env.js";
+const starterTypesYaml = `version: 1.0.0
+types:
+  - item:
+      tags:
+        - datasource_type
+      fields:
+        - id:
+            type: integer
+            is_id: true
+        - name:
+            type: string
+            size: 128
+`;
+const promptSetup = async (prompt, env, found, explicit, askScaffold = false) => {
+  const defaults = answersFromEnv(env);
+  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 fromUrl = scheme(defaults.url);
+  const selected = await prompt.checkbox({
+    message: "Providers",
+    choices: providers.map((value) => ({
+      name: value,
+      value,
+      checked: defaults.providers.includes(value) || value === fromUrl
+    }))
+  });
+  const url = await prompt.input({
+    message: "DATASOURCE_URL",
+    default: defaults.url || (selected.includes("sqlite") ? "sqlite:///:memory:" : "")
+  });
+  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 };
+};
+const ecosystemOr = (value) => isEcosystem(value) ? value : void 0;
+const envFromAnswers = (answers) => {
+  const provider = scheme(answers.url) ?? answers.providers[0] ?? "sqlite";
+  return {
+    INSTALLED_PROVIDERS: ensureProviders(answers.providers, provider).join(","),
+    PROVIDER: provider,
+    DATASOURCE_URL: withSchema(answers.url, answers.schema)
+  };
+};
+export {
+  envFromAnswers,
+  promptSetup,
+  starterTypesYaml
+};

package/dist/version/applyVersion.js

@@ -0,0 +1,51 @@
+import { isAbsolute, join } from "node:path";
+import { applyDocument, asDocument, 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 current = names.filter((name) => name.endsWith(".yaml")).sort();
+  const paths = [.../* @__PURE__ */ new Set([...Object.keys(before), ...current])];
+  const yaml = render(
+    await Promise.all(
+      paths.map(async (path) => ({
+        path,
+        before: before[path],
+        after: current.includes(path) ? parseYaml(await deps.fs.readFile(join(root, path))) : void 0
+      }))
+    )
+  );
+  if (yaml === "") {
+    deps.log("unchanged");
+    return;
+  }
+  const out = join(root, `version-${stamp(now())}-${pad(nextSeq(versions))}`, "diff.yaml");
+  if (!flags.dryRun) await deps.fs.writeFile(out, yaml);
+  deps.log(out);
+};
+const nextSeq = (versions) => {
+  const next = versions.reduce((max, name) => Math.max(max, Number(name.match(versionDir)[1])), 0) + 1;
+  return next <= 999 ? next : (() => {
+    throw new Error("version sequence exceeds 999");
+  })();
+};
+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

@@ -0,0 +1,114 @@
+import { isDeepStrictEqual } from "node:util";
+const unchanged = Symbol("unchanged");
+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);
+  if (isObject(before) && isObject(after)) return objectDelta(before, after);
+  return after;
+};
+const keyedSplit = (beforeArr, afterArr) => {
+  const beforeMap = keyedMap(beforeArr);
+  const afterMap = keyedMap(afterArr);
+  const added = [];
+  const changed = [];
+  for (const entry of afterArr) {
+    const key = Object.keys(entry)[0];
+    const value = entry[key];
+    if (!beforeMap.has(key)) added.push({ [key]: value });
+    else {
+      const nested = build(beforeMap.get(key), value);
+      if (nested !== unchanged) changed.push({ [key]: nested });
+    }
+  }
+  const removed = [...beforeMap.keys()].filter((key) => !afterMap.has(key)).sort();
+  const result = {
+    ...added.length ? { added } : {},
+    ...changed.length ? { changed } : {},
+    ...removed.length ? { removed } : {}
+  };
+  return Object.keys(result).length === 0 ? unchanged : result;
+};
+const objectDelta = (beforeObj, afterObj) => {
+  const result = {};
+  for (const key of Object.keys(afterObj)) {
+    if (!(key in beforeObj)) {
+      result[key] = afterObj[key];
+      continue;
+    }
+    const nested = build(beforeObj[key], afterObj[key]);
+    if (nested !== unchanged) result[key] = nested;
+  }
+  const removed = Object.keys(beforeObj).filter((key) => !(key in afterObj)).sort();
+  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
+);
+const keyedMap = (arr) => {
+  const map = /* @__PURE__ */ new Map();
+  for (const entry of arr) {
+    const key = Object.keys(entry)[0];
+    map.set(key, entry[key]);
+  }
+  return map;
+};
+export {
+  apply,
+  applyFile,
+  delta,
+  isObject
+};

package/dist/version/render.js

@@ -0,0 +1,38 @@
+import { parse, stringify } from "yaml";
+import { applyFile, delta, isObject } from "./delta.js";
+const render = (files) => {
+  const out = {};
+  for (const { path, before, after } of files) {
+    if (before === void 0 && after === void 0) continue;
+    if (before === void 0) {
+      out[path] = { added: true, content: after ?? null };
+      continue;
+    }
+    if (after === void 0) {
+      out[path] = { removed: true };
+      continue;
+    }
+    const nested = delta(before, after);
+    if (nested !== void 0) out[path] = nested;
+  }
+  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
+};