@deterministic-code/datasources-cli 0.1.12 → 0.1.14

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

@@ -1,6 +1,6 @@
 {
   "name": "@deterministic-code/datasources-code-generators",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "type": "module",
   "exports": {
     ".": "./dist/generateSql.js",
@@ -9,7 +9,9 @@
     "./generate-stored-procedures": "./dist/generate-stored-procedures.js",
     "./sql/generate-stored-procedures": "./dist/sql/generate-stored-procedures.js",
     "./common/sql-dialect": "./dist/sql/common/sql-dialect.js",
-    "./sql/common/write-inclusion": "./dist/sql/common/write-inclusion.js"
+    "./sql/common/write-inclusion": "./dist/sql/common/write-inclusion.js",
+    "./sql/common/default-casing": "./dist/sql/common/default-casing.js",
+    "./sql/common/infer-reference-types": "./dist/sql/common/infer-reference-types.js"
   },
   "dependencies": {
     "@deterministic-code/datasources": "^0.1.12",

package/node_modules/@deterministic-code/deterministic-generators-common/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-generators-common/typescript/parser/dist/specification-parser.js

@@ -1355,6 +1355,133 @@ var Parser = class {
     return nested;
   }
 };
+
+// node_modules/@deterministic-code/deterministic-generators-common/typescript/parser/version-snapshot.ts
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { parse as parse2, stringify as stringify2 } from "yaml";
+var versionDir = /^version-\d{8}T\d{6}Z-\d{3}$/;
+var own = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
+var VersionSnapshot = class _VersionSnapshot {
+  documents;
+  constructor(diffsInOrder) {
+    const docs = {};
+    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) {
+    return new _VersionSnapshot(diffsInOrder);
+  }
+  static async read(deterministicRoot) {
+    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) {
+    if (!own(this.documents, path)) throw new Error(`missing ${path}`);
+    return stringify2(this.documents[path]);
+  }
+  async diffOf(root, name) {
+    let text;
+    try {
+      text = await readFile(join(root, name, "diff.yaml"), "utf8");
+    } catch {
+      return void 0;
+    }
+    if (text === "") return void 0;
+    let rootValue;
+    try {
+      rootValue = parse2(text);
+    } 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;
+  }
+  applyFile(before, envelope) {
+    if (this.isNull(envelope)) return before;
+    if (this.isMap(envelope) && this.isTrue(envelope, "removed") && Object.keys(envelope).length === 1)
+      return void 0;
+    if (this.isMap(envelope) && this.isTrue(envelope, "added")) return envelope.content;
+    return this.apply(before, envelope);
+  }
+  apply(before, next) {
+    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;
+  }
+  applyKeyed(beforeVal, split) {
+    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]] : [];
+      })
+    );
+    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)) } : entry
+        ];
+      })
+    ];
+  }
+  applyObject(beforeVal, next) {
+    const removed = new Set(this.strings(next, "removed"));
+    const output = {};
+    for (const [key, value] of Object.entries(beforeVal)) {
+      if (removed.has(key)) continue;
+      output[key] = own(next, key) ? this.apply(value, next[key]) : value;
+    }
+    for (const [key, value] of Object.entries(next)) {
+      if (key === "removed" && Array.isArray(value)) continue;
+      if (!own(beforeVal, key)) output[key] = value;
+    }
+    return output;
+  }
+  isSplit(map) {
+    return Object.keys(map).every((key) => key === "added" || key === "changed" || key === "removed");
+  }
+  isKeyed(value) {
+    return Array.isArray(value) && value.length > 0 && value.every((item) => this.isMap(item) && Object.keys(item).length === 1);
+  }
+  seq(value) {
+    return Array.isArray(value) ? value : [];
+  }
+  strings(map, key) {
+    return this.seq(map[key]).map((item) => this.isScalar(item) ? String(item ?? "") : "");
+  }
+  firstPair(entry) {
+    if (!this.isMap(entry)) return void 0;
+    const key = Object.keys(entry)[0];
+    return key === void 0 ? void 0 : { key, value: entry[key] };
+  }
+  isMap(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+  isTrue(map, key) {
+    return map[key] === true || map[key] === "true" || map[key] === "True";
+  }
+  isNull(value) {
+    return value == null;
+  }
+  isScalar(value) {
+    return value == null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+  }
+};
 export {
-  DeterministicParser
+  DeterministicParser,
+  VersionSnapshot
 };

package/node_modules/@deterministic-code/deterministic-generators-common/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-generators-common/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-generators-common/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/node_modules/@deterministic-code/rust-generators/dist/import-generator.js

@@ -45,7 +45,7 @@ class RustImportGenerator {
     return this.underBase(path);
   }
   datasourceRel(entity) {
-    return this.rel("types/generated/datasource", this.datasource(entity));
+    return this.rel(this.layered("types/generated/datasource"), this.datasource(entity));
   }
   datasourceQual(entity) {
     return this.typeQual(
@@ -63,7 +63,7 @@ class RustImportGenerator {
   }
   datasourceValidatorRel(entity) {
     return this.rel(
-      "types/generated/datasource/validators",
+      this.layered("types/generated/datasource/validators"),
       this.datasourceValidator(entity)
     );
   }
@@ -73,7 +73,7 @@ class RustImportGenerator {
     return this.underBase(path);
   }
   viewRel(entity) {
-    return this.rel("types/generated/views", this.view(entity));
+    return this.rel(this.layered("types/generated/views"), this.view(entity));
   }
   viewQual(entity) {
     return this.typeQual(this.viewRel(entity), this.casing.convertTypes(entity));
@@ -87,7 +87,7 @@ class RustImportGenerator {
   }
   viewValidatorRel(entity) {
     return this.rel(
-      "types/generated/views/validators",
+      this.layered("types/generated/views/validators"),
       this.viewValidator(entity)
     );
   }
@@ -97,31 +97,31 @@ class RustImportGenerator {
     return this.underBase(path);
   }
   serviceRel(entity) {
-    return this.rel("services/generated", this.service(entity));
+    return this.rel(this.layered("services/generated"), this.service(entity));
   }
   serviceCustom(name, module) {
     return this.resolveCustom(name, module, "services");
   }
   serviceCustomRel(entity) {
     const file = `${this.serviceStem(entity)}.rs`;
-    return this.organizeByFeature ? `features/${this.casing.directory(entity)}/custom/${file}` : `services/custom/${file}`;
+    return this.organizeByFeature ? `${this.featuresDir(entity)}/custom/${file}` : `${this.layered("services")}/custom/${file}`;
   }
   serviceTest(entity) {
     return this.test(this.service(entity), `${entity}_service`);
   }
   serviceTestRel(entity) {
-    return this.rel("services/generated/__tests__", this.serviceTest(entity));
+    return this.rel(this.layered("services/generated/__tests__"), this.serviceTest(entity));
   }
   serviceIntegrationTest(entity) {
     const file = this.rsFile(`${entity}_service_integration_tests`);
     if (this.organizeByFeature) {
-      return `features/${this.casing.directory(entity)}/__tests__/${file}`;
+      return `${this.featuresDir(entity)}/__tests__/${file}`;
     }
     return file;
   }
   serviceIntegrationTestRel(entity) {
     return this.rel(
-      "services/generated/__tests__",
+      this.layered("services/generated/__tests__"),
       this.serviceIntegrationTest(entity)
     );
   }
@@ -134,7 +134,7 @@ class RustImportGenerator {
     return this.underBase(path);
   }
   routeRel(entity) {
-    return this.rel("routes/generated", this.route(entity));
+    return this.rel(this.layered("routes/generated"), this.route(entity));
   }
   routeCustom(name, module) {
     return this.resolveCustom(name, module, "routes");
@@ -166,15 +166,17 @@ class RustImportGenerator {
     return this.routeStem(entity);
   }
   appWiring() {
-    return this.organizeByFeature ? "features/app_wiring.rs" : "app_wiring.rs";
+    return this.organizeByFeature ? `${this.casing.convertDirectories("features")}/app_wiring.rs` : "app_wiring.rs";
   }
   validatorFn(kind, entity, fn) {
     if (this.organizeByFeature) {
       const file = kind === "datasource" ? this.datasourceValidator(entity) : this.viewValidator(entity);
       return `${this.spec("", file)}::${fn}`;
     }
-    const ns = kind === "datasource" ? "crate::types::generated::datasource::validators" : "crate::types::generated::views::validators";
-    return `${ns}::${fn}`;
+    const ns = this.layered(
+      kind === "datasource" ? "types/generated/datasource/validators" : "types/generated/views/validators"
+    ).replaceAll("/", "::");
+    return `crate::${ns}::${fn}`;
   }
   apiPath(entity) {
     return pluralSnake(entity).replace(/_/g, "-");
@@ -196,8 +198,16 @@ class RustImportGenerator {
   rsFile(stem) {
     return `${this.casing.fileBase(stem)}.rs`;
   }
+  layered(path) {
+    return path.split("/").map(
+      (segment) => segment === "custom" || segment === "__tests__" ? segment : this.casing.convertDirectories(segment)
+    ).join("/");
+  }
+  featuresDir(entity) {
+    return `${this.casing.convertDirectories("features")}/${this.casing.directory(entity)}`;
+  }
   featurePath(entity, file) {
-    return `features/${this.casing.directory(entity)}/${file}`;
+    return `${this.featuresDir(entity)}/${file}`;
   }
   serviceStem(entity) {
     return this.casing.fileBase(`${entity}_service`);
@@ -217,7 +227,7 @@ class RustImportGenerator {
     const stubFn = layer === "services" ? "generateCustomServiceStub" : "generateCustomRouteStub";
     const file = this.rsFile(name);
     const entity = (featureEntityFromClass(name) || "shared").replace(/-/g, "_");
-    const defaultStub = this.organizeByFeature ? `features/${this.casing.directory(entity)}/custom/${file}` : `../custom/${file}`;
+    const defaultStub = this.organizeByFeature ? `${this.featuresDir(entity)}/custom/${file}` : `../custom/${file}`;
     if (this.organizeByFeature) {
       if (!mod || !mod.startsWith(".") || mod.startsWith("./services/") || mod.startsWith("./routes/")) {
         return defaultStub;

package/node_modules/@deterministic-code/rust-generators/src/import-generator.test.ts

@@ -95,6 +95,17 @@ describe("RustImportGenerator layered (organize_by_feature unset)", () => {
       imports.validatorFn("view", "user", "validate_user"),
       "crate::types::generated::views::validators::validate_user",
     );
+    const pascalDirs = createImportGenerator(".", {
+      "languages.rust.casing.directories": "Pascal",
+    });
+    assert.equal(
+      pascalDirs.datasourceRel("user"),
+      "Types/Generated/Datasource/user.rs",
+    );
+    assert.equal(
+      pascalDirs.validatorFn("datasource", "user", "validate_datasource_user"),
+      "crate::Types::Generated::Datasource::Validators::validate_datasource_user",
+    );
     assert.equal(imports.apiPath("card_payment"), "card-payments");
     assert.equal(imports.apiPath("user"), "users");
     assert.equal(imports.frontend("src/main.rs"), "frontend/src/main.rs");