@deterministic-code/datasources-cli 0.1.14 → 0.1.16

package/dist/commands.js

@@ -1,14 +1,19 @@
 import { catalog, host } from "./catalog.js";
 import { csharpTarget } from "./detect.js";
+import { sqlMigrateProviders } from "./migrateInit.js";
+const npmDialects = (names) => {
+  const dialects = sqlMigrateProviders(names);
+  return dialects.length === 0 ? [] : npmInstall(dialects);
+};
 const addCommands = (ecosystem, names, entries) => ({
   ts: () => npmInstall(names),
-  rust: () => cargoAdd(names),
-  csharp: () => dotnetAdd(names, csharpTarget(entries))
+  rust: () => [...cargoAdd(names), ...npmDialects(names)],
+  csharp: () => [...dotnetAdd(names, csharpTarget(entries)), ...npmDialects(names)]
 })[ecosystem]();
 const removeCommands = (ecosystem, names, _remaining, entries) => ({
   ts: () => npmUninstall(names),
-  rust: () => cargoRemove(names),
-  csharp: () => dotnetRemove(names, csharpTarget(entries))
+  rust: () => [...cargoRemove(names), ...npmUninstall(sqlMigrateProviders(names))],
+  csharp: () => [...dotnetRemove(names, csharpTarget(entries)), ...npmUninstall(sqlMigrateProviders(names))]
 })[ecosystem]();
 const npmInstall = (names) => [
   {

package/dist/env.js

@@ -29,6 +29,12 @@ const withSchema = (url, schema) => {
 };
 const urlOf = (env) => env.DATASOURCE_URL || "";
 const installedOf = (env) => env.INSTALLED_PROVIDERS || scheme(urlOf(env)) || "";
+const overlayEnv = (file, env) => ({
+  ...file,
+  ...env.INSTALLED_PROVIDERS ? { INSTALLED_PROVIDERS: env.INSTALLED_PROVIDERS } : {},
+  ...env.PROVIDER ? { PROVIDER: env.PROVIDER } : {},
+  ...env.DATASOURCE_URL ? { DATASOURCE_URL: env.DATASOURCE_URL } : {}
+});
 const parseEnv = (text) => Object.fromEntries(
   text.split(/\r?\n/).filter((line) => line.trim() && !line.trimStart().startsWith("#") && line.includes("=")).map((line) => {
     const i = line.indexOf("=");
@@ -83,6 +89,7 @@ export {
   answersFromEnv,
   ensureProviders,
   knownEnvKeys,
+  overlayEnv,
   parseEnv,
   schemaOf,
   scheme,

package/dist/generate/DeterministicProvider.js

@@ -13,6 +13,7 @@ import { rustRepositories } from "./RustRepositories.js";
 import { typescriptRepositories } from "./TypeScriptRepositories.js";
 import { planRepositories } from "./RepositoryPlan.js";
 import { datasourceEnginesOf, engineDatasourceOf, overlayDatasource } from "./datasourceYaml.js";
+import { sqlDialectsFromEnv } from "./sqlDialects.js";
 const place = (dir, entries) => entries.map((entry) => ({ ...entry, filename: `${dir}/${entry.filename}` }));
 const remap = (entries, settings, dialect) => {
   const casing = createCasingStrategy(dialect, settings);
@@ -58,14 +59,6 @@ const withProviderWrites = async (request, models) => {
     )
   }));
 };
-const dialectsOf = (settings) => {
-  const out = [];
-  for (const name of (settings["backend.datasources"] ?? "").split(",")) {
-    const key = name.trim();
-    if (key !== "" && !out.includes(key)) out.push(key);
-  }
-  return out;
-};
 const deterministic = {
   name: "deterministic",
   generateTypes: async (request) => {
@@ -96,7 +89,7 @@ const deterministic = {
       request.dialect
     );
   },
-  generateDatasource: async (request) => place("sql", await generateSql(context(request), dialectsOf(request.settings)))
+  generateDatasource: async (request) => place("sql", await generateSql(context(request), sqlDialectsFromEnv(request.env ?? {})))
 };
 export {
   deterministic

package/dist/generate/applyGenerate.js

@@ -1,5 +1,6 @@
 import { isAbsolute, join } from "node:path";
 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 { withStoredProcedures } from "./storedProcedures.js";
@@ -19,7 +20,8 @@ const applyGenerate = async (command, flags, deps) => {
   const request = {
     dialect: command.dialect,
     reader: memoryReader(loaded.files),
-    settings
+    settings,
+    env: await destEnv(deps.fs, flags.cwd)
   };
   const entries = await {
     all: async () => [

package/dist/generate/applyMigrations.js

@@ -1,19 +1,24 @@
 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 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: overlaySqlFlags(withStoredProcedures(loaded.settings, command.storedProcedures), command)
-  });
+  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 entries) deps.log(join(root, entry.filename));

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,16 +10,11 @@ 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) {
@@ -58,7 +31,7 @@ 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 = []) => [
     verb,

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/wireRegister.js

@@ -22,12 +22,21 @@ pub mod repositories;
 pub use repositories::${rustIdent(casing.convertFileName("repository_registry"))}::Repositories;
 `;
 };
-const cargoWithCtor = (cargo) => /^\s*ctor\s*=/m.test(cargo) ? void 0 : cargo.includes("[dependencies]") ? cargo.replace("[dependencies]", `[dependencies]
-ctor = "0.4"`) : `${cargo.trimEnd()}
+const rustCargoLine = (cargo, name, line) => new RegExp(`^\\s*${name}\\s*=`, "m").test(cargo) ? void 0 : line;
+const cargoWithCtor = (cargo) => {
+  const add = [
+    rustCargoLine(cargo, "ctor", 'ctor = "0.4"'),
+    rustCargoLine(cargo, "tokio", 'tokio = { version = "1", features = ["macros", "rt-multi-thread"] }')
+  ].filter((line) => line !== void 0);
+  if (add.length === 0) return void 0;
+  const block = add.join("\n");
+  return cargo.includes("[dependencies]") ? cargo.replace("[dependencies]", `[dependencies]
+${block}`) : `${cargo.trimEnd()}
 
 [dependencies]
-ctor = "0.4"
+${block}
 `;
+};
 const attached = (dialect, entry, entryPath, hook) => dialect === "typescript" ? entry.includes("datasources-register") ? void 0 : `import "${specFrom(entryPath, hook)}";
 ${entry}` : entry.includes("datasources_register") ? void 0 : `mod datasources_register;
 use datasources_register::Repositories;

package/dist/wireRustProviders.js

@@ -1,5 +1,18 @@
 import { dirname, join } from "node:path";
 import { catalog } from "./catalog.js";
+const rustDriver = {
+  json: "JsonDriver",
+  memory: "MemoryDriver",
+  sqlite: "SqliteDriver",
+  xml: "XmlDriver",
+  yaml: "YamlDriver",
+  mysql: "MysqlDriver",
+  sqlserver: "SqlServerDriver",
+  postgres: "PostgresDriver",
+  oracle: "OracleDriver",
+  mongodb: "MongoDbDriver",
+  dynamodb: "DynamoDbDriver"
+};
 const optional = async (fs, path) => {
   try {
     return await fs.readFile(path);
@@ -15,10 +28,25 @@ const firstFile = async (fs, cwd, names) => {
   }
   return void 0;
 };
-const rustBindContents = (names) => names.map((name) => `use ${catalog[name].cargo.replaceAll("-", "_")} as _;
-`).join("");
-const attachedProviders = (entry) => entry.includes("datasources_providers") ? void 0 : `mod datasources_providers;
+const rustBindContents = (names) => `pub fn register() {
+${names.map((name) => {
+  const crate = catalog[name].cargo.replaceAll("-", "_");
+  return `    datasources::register("${name}", std::sync::Arc::new(${crate}::${rustDriver[name]}));`;
+}).join("\n")}
+}
+`;
+const withMod = (entry) => entry.includes("datasources_providers") ? entry : `mod datasources_providers;
 ${entry}`;
+const withRegisterCall = (entry) => {
+  if (entry.includes("datasources_providers::register()")) return entry;
+  const main = /((?:async\s+)?fn\s+main\s*\([^)]*\)(?:\s*->\s*[^{]+)?\s*)\{(\s*)/;
+  return entry.replace(main, (_, sig, ws) => `${sig}{
+    datasources_providers::register();${ws === "" ? "\n" : ws}`);
+};
+const attachedProviders = (entry) => {
+  const next = withRegisterCall(withMod(entry));
+  return next === entry ? void 0 : next;
+};
 const wireRustProviders = async (cwd, names, dryRun, deps) => {
   const entry = await firstFile(deps.fs, cwd, ["src/lib.rs", "src/main.rs", "lib.rs", "main.rs"]);
   const bind = join(entry ? dirname(entry.path) : cwd, "datasources_providers.rs");

package/node_modules/@deterministic-code/datasources-code-generators/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deterministic-code/datasources-code-generators",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "type": "module",
   "exports": {
     ".": "./dist/generateSql.js",
@@ -14,12 +14,12 @@
     "./sql/common/infer-reference-types": "./dist/sql/common/infer-reference-types.js"
   },
   "dependencies": {
-    "@deterministic-code/datasources": "^0.1.12",
-    "@deterministic-code/datasources-mysql": "^0.1.12",
-    "@deterministic-code/datasources-oracle": "^0.1.12",
-    "@deterministic-code/datasources-postgres": "^0.1.12",
-    "@deterministic-code/datasources-sqlite": "^0.1.12",
-    "@deterministic-code/datasources-sqlserver": "^0.1.12",
+    "@deterministic-code/datasources": "^0.1.14",
+    "@deterministic-code/datasources-mysql": "^0.1.14",
+    "@deterministic-code/datasources-oracle": "^0.1.14",
+    "@deterministic-code/datasources-postgres": "^0.1.14",
+    "@deterministic-code/datasources-sqlite": "^0.1.14",
+    "@deterministic-code/datasources-sqlserver": "^0.1.14",
     "@deterministic-code/deterministic-generators-common": "0.1.0",
     "@deterministic-code/generators-common": "0.0.1",
     "pluralize": "^8.0.0",

package/node_modules/@deterministic-code/deterministic-specifications-typescript/README.md

@@ -2,7 +2,7 @@
 
 Parser and validators for the [deterministic-specifications](https://github.com/deterministic-code/deterministic-specifications) contract. Each language is its own library. Specs and samples stay in the specifications repo; these libraries only read them.
 
-- [`typescript/`](typescript) — npm package `@deterministic-code/deterministic-generators-common` (`DeterministicParser` on the `./parser` export, validators on the package root)
+- [`typescript/`](typescript) — npm package `@deterministic-code/deterministic-generators-common` (`DeterministicParser` and `VersionSnapshot` on the `./parser` export, validators on the package root)
 - [`rust/`](rust) — crate `deterministic_generators_common` (path/git dependency)
 - [`csharp/`](csharp) — `Deterministic.Generators.Common` (`net10.0` class library)
 
@@ -15,8 +15,68 @@ deterministic_generators_common = { git = "https://github.com/deterministic-code
 <ProjectReference Include="path/to/deterministic-generators-common/csharp/Deterministic.Generators.Common/Deterministic.Generators.Common.csproj" />
 ```
 
+```xml
+<PackageReference Include="Deterministic.Generators.Common" Version="0.1.1" />
+```
+
+TypeScript packs pin `#main`:
+
+```json
+"@deterministic-code/deterministic-generators-common": "github:deterministic-code/deterministic-generators-common#main"
+```
+
+C# first-party consumers use the `ProjectReference`. Out-of-repo C# can take the NuGet package.
+
+```text
+npm run publish:nuget                 # pack and smoke-test
+npm run publish:nuget -- --publish    # push to nuget.org (NUGET_API_KEY)
+```
+
 ```text
 npm test                         # TypeScript parser + validator (100% coverage)
 sh rust/coverage.sh              # cargo llvm-cov, 100% lines + functions
 dotnet test csharp/Deterministic.Generators.Common.slnx --settings csharp/coverlet.runsettings
 ```
+
+## VersionSnapshot
+
+`VersionSnapshot` reconstructs specification YAML by folding every `deterministic/version-*/diff.yaml` in name order. Documents are the library YAML AST (`YamlValue` / `YamlMap` / `YamlSeq` / `YamlScalar`), not compiled `IDeterministic` and not `DeterministicParser` output.
+
+| API | Role |
+| --- | --- |
+| `Combine` / `combine` | Fold already-parsed diff trees (mappings), in order |
+| `Read` / `read` | Scan a `deterministic/` directory and fold matching version dirs |
+| `Documents` / `documents` | Reconstructed file path → tree |
+| `Yaml` / `yaml(path)` | Serialize one reconstructed file with the library serializer |
+
+Apply helpers are private instance methods. Version directories must match `^version-\d{8}T\d{6}Z-\d{3}$`. Missing or empty `diff.yaml` is skipped. A non-mapping diff throws `expected a mapping`. TypeScript `read` is async; C# and Rust `Read` are sync.
+
+```csharp
+var snapshot = VersionSnapshot.Read(deterministicRoot);
+var types = snapshot.Yaml("types.yaml");
+var datasource = snapshot.Yaml("datasource.yaml");
+```
+
+```typescript
+import { VersionSnapshot } from "@deterministic-code/deterministic-generators-common/parser";
+
+const snapshot = await VersionSnapshot.read(deterministicRoot);
+const types = snapshot.yaml("types.yaml");
+```
+
+```rust
+let snapshot = VersionSnapshot::read(deterministic_root)?;
+let types = snapshot.yaml("types.yaml")?;
+```
+
+`Combine` takes an ordered list of parsed mappings, not YAML strings. To compare a fold to a live file, wrap the live tree as `{ added: true, content }` and compare `Yaml` strings from the same serializer — do not string-compare authored YAML (comments and flow sequences differ).
+
+Per file key in a diff:
+
+- `{ added: true, content }` inserts `content` (`true` or the strings `"true"` / `"True"`).
+- `{ removed: true }` deletes the file.
+- Object merge: nested apply, `removed:` string list deletes keys, new keys are appended.
+- Keyed collections (sequence of single-key maps): `{ added, changed, removed }`. Added entries are prepended.
+- Otherwise the next value replaces.
+
+`Read` does not grow `IDeterministicReader`.

package/node_modules/@deterministic-code/deterministic-specifications-typescript/typescript/parser/specification-parser.ts

@@ -1,5 +1,6 @@
 export type { IDeterministic } from "./deterministic.ts";
 export { DeterministicParser } from "./parser/specification-parser.ts";
+export { VersionSnapshot } from "./version-snapshot.ts";
 export type {
   CustomRouteEntry,
   CustomServiceEntry,

package/node_modules/@deterministic-code/deterministic-specifications-typescript/typescript/parser/version-snapshot.ts

@@ -0,0 +1,154 @@
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { parse, stringify } from "yaml";
+import type { YamlMap, YamlValue } from "./yaml-node.ts";
+
+const versionDir = /^version-\d{8}T\d{6}Z-\d{3}$/;
+const own = (obj: object, key: string) => Object.prototype.hasOwnProperty.call(obj, key);
+
+export class VersionSnapshot {
+  readonly documents: Readonly<Record<string, YamlValue | undefined>>;
+
+  private constructor(diffsInOrder: Array<YamlValue | null | undefined>) {
+    const docs: Record<string, YamlValue | undefined> = {};
+    for (const diff of diffsInOrder) {
+      if (diff == null) continue;
+      if (!this.isMap(diff)) throw new Error("expected a mapping");
+      for (const [path, envelope] of Object.entries(diff)) {
+        const next = this.applyFile(docs[path], envelope);
+        if (this.isNull(next)) delete docs[path];
+        else docs[path] = next;
+      }
+    }
+    this.documents = docs;
+  }
+
+  static combine(diffsInOrder: Array<YamlValue | null | undefined>): VersionSnapshot {
+    return new VersionSnapshot(diffsInOrder);
+  }
+
+  static async read(deterministicRoot: string): Promise<VersionSnapshot> {
+    const names = (await readdir(deterministicRoot, { withFileTypes: true }))
+      .filter((entry) => entry.isDirectory() && versionDir.test(entry.name))
+      .map((entry) => entry.name)
+      .sort();
+    const snapshot = new VersionSnapshot([]);
+    return VersionSnapshot.combine(await Promise.all(names.map((name) => snapshot.diffOf(deterministicRoot, name))));
+  }
+
+  yaml(path: string): string {
+    if (!own(this.documents, path)) throw new Error(`missing ${path}`);
+    return stringify(this.documents[path]);
+  }
+
+  private async diffOf(root: string, name: string): Promise<YamlValue | undefined> {
+    let text: string;
+    try {
+      text = await readFile(join(root, name, "diff.yaml"), "utf8");
+    } catch {
+      return undefined;
+    }
+    if (text === "") return undefined;
+    let rootValue: YamlValue;
+    try {
+      rootValue = parse(text) as YamlValue;
+    } catch (error) {
+      throw new Error(`${name}/diff.yaml: ${String(error)}`);
+    }
+    if (!this.isMap(rootValue)) throw new Error(`${name}/diff.yaml: expected a mapping`);
+    return rootValue;
+  }
+
+  private applyFile(before: YamlValue | undefined, envelope: YamlValue | undefined): YamlValue | undefined {
+    if (this.isNull(envelope)) return before;
+    if (this.isMap(envelope) && this.isTrue(envelope, "removed") && Object.keys(envelope).length === 1)
+      return undefined;
+    if (this.isMap(envelope) && this.isTrue(envelope, "added")) return envelope.content;
+    return this.apply(before, envelope);
+  }
+
+  private apply(before: YamlValue | undefined, next: YamlValue | undefined): YamlValue | undefined {
+    if (this.isNull(next)) return before;
+    if (this.isKeyed(before) && this.isMap(next) && this.isSplit(next)) return this.applyKeyed(before, next);
+    if (this.isMap(before) && this.isMap(next)) return this.applyObject(before, next);
+    return next;
+  }
+
+  private applyKeyed(beforeVal: YamlMap[], split: YamlMap): YamlValue {
+    const removed = new Set(this.strings(split, "removed"));
+    const changed = new Map(
+      this.seq(split.changed).flatMap((entry) => {
+        const pair = this.firstPair(entry);
+        return pair ? [[pair.key, pair.value] as const] : [];
+      }),
+    );
+    return [
+      ...this.seq(split.added),
+      ...beforeVal.flatMap((entry) => {
+        const pair = this.firstPair(entry);
+        if (!pair || removed.has(pair.key)) return [];
+        return [
+          changed.has(pair.key)
+            ? { [pair.key]: this.apply(pair.value, changed.get(pair.key)) as YamlValue }
+            : entry,
+        ];
+      }),
+    ];
+  }
+
+  private applyObject(beforeVal: YamlMap, next: YamlMap): YamlMap {
+    const removed = new Set(this.strings(next, "removed"));
+    const output: Record<string, YamlValue> = {};
+    for (const [key, value] of Object.entries(beforeVal)) {
+      if (removed.has(key)) continue;
+      output[key] = (own(next, key) ? this.apply(value, next[key]) : value) as YamlValue;
+    }
+    for (const [key, value] of Object.entries(next)) {
+      if (key === "removed" && Array.isArray(value)) continue;
+      if (!own(beforeVal, key)) output[key] = value;
+    }
+    return output;
+  }
+
+  private isSplit(map: YamlMap) {
+    return Object.keys(map).every((key) => key === "added" || key === "changed" || key === "removed");
+  }
+
+  private isKeyed(value: YamlValue | undefined): value is YamlMap[] {
+    return (
+      Array.isArray(value) &&
+      value.length > 0 &&
+      value.every((item) => this.isMap(item) && Object.keys(item).length === 1)
+    );
+  }
+
+  private seq(value: YamlValue | undefined): YamlValue[] {
+    return Array.isArray(value) ? value : [];
+  }
+
+  private strings(map: YamlMap, key: string) {
+    return this.seq(map[key]).map((item) => (this.isScalar(item) ? String(item ?? "") : ""));
+  }
+
+  private firstPair(entry: YamlValue | undefined) {
+    if (!this.isMap(entry)) return undefined;
+    const key = Object.keys(entry)[0];
+    return key === undefined ? undefined : { key, value: entry[key] };
+  }
+
+  private isMap(value: YamlValue | undefined | null): value is YamlMap {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+
+  private isTrue(map: YamlMap, key: string) {
+    return map[key] === true || map[key] === "true" || map[key] === "True";
+  }
+
+  private isNull(value: YamlValue | undefined | null) {
+    return value == null;
+  }
+
+  private isScalar(value: YamlValue | undefined) {
+    return value == null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+  }
+}

package/node_modules/@deterministic-code/deterministic-specifications-typescript/typescript/parser/yaml-node.ts

@@ -1,8 +1,8 @@
 import { parse } from "yaml";
 
 type YamlLiteral = string | number | boolean | null;
-type YamlMap = { readonly [key: string]: YamlValue };
-type YamlValue = YamlLiteral | YamlValue[] | YamlMap;
+export type YamlMap = { readonly [key: string]: YamlValue };
+export type YamlValue = YamlLiteral | YamlValue[] | YamlMap;
 type FieldDefault = YamlLiteral | YamlValue[] | YamlMap;
 type Named = { name: string; node: YamlNode };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deterministic-code/datasources-cli",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "type": "module",
   "bin": {
     "datasources": "./bin/datasources.mjs"
@@ -13,7 +13,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@deterministic-code/datasources-code-generators": "0.1.14",
+    "@deterministic-code/datasources-code-generators": "0.1.16",
     "@deterministic-code/generators-common": "0.0.1",
     "@deterministic-code/deterministic-generators-common": "0.1.0",
     "@deterministic-code/typescript-generators": "0.0.1",
@@ -21,12 +21,12 @@
     "@deterministic-code/rust-generators": "0.0.1",
     "@deterministic-code/generators-openapi": "0.0.1",
     "@deterministic-code/patch-merger": "0.1.0",
-    "@deterministic-code/datasources": "^0.1.12",
-    "@deterministic-code/datasources-sqlite": "^0.1.12",
-    "@deterministic-code/datasources-mysql": "^0.1.12",
-    "@deterministic-code/datasources-postgres": "^0.1.12",
-    "@deterministic-code/datasources-sqlserver": "^0.1.12",
-    "@deterministic-code/datasources-oracle": "^0.1.12",
+    "@deterministic-code/datasources": "^0.1.14",
+    "@deterministic-code/datasources-sqlite": "^0.1.14",
+    "@deterministic-code/datasources-mysql": "^0.1.14",
+    "@deterministic-code/datasources-postgres": "^0.1.14",
+    "@deterministic-code/datasources-sqlserver": "^0.1.14",
+    "@deterministic-code/datasources-oracle": "^0.1.14",
     "@inquirer/prompts": "^7.8.0",
     "yaml": "^2.6.0",
     "mustache": "^4.2.0",