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

package/node_modules/@deterministic-code/generators-common/src/datasource-type-tree.ts

@@ -0,0 +1,333 @@
+import { stringify } from "yaml";
+import type { Type } from "@deterministic-code/deterministic-generators-common/parser";
+
+export type DatasourceTypeTree = { [name: string]: DatasourceTypeTree };
+
+export type DatasourceTypeGraphEdge = {
+  from: string;
+  to: string;
+};
+
+export type DatasourceTypeGraph = {
+  nodes: string[];
+  edges: DatasourceTypeGraphEdge[];
+};
+
+export type DatasourceTypeHierarchies = {
+  firstParentTree: DatasourceTypeTree;
+  allParentsTree: DatasourceTypeTree;
+  graph: DatasourceTypeGraph;
+};
+
+const ROOT = "root";
+
+const refTargets = (references: string | [string, string]): string[] =>
+  (Array.isArray(references) ? references : [references]).map(
+    (ref) => ref.split(".")[0] || "",
+  );
+
+const referencedParents = (
+  type: Type,
+  typeNames: ReadonlySet<string>,
+): string[] => {
+  const parents: string[] = [];
+  const seen = new Set<string>();
+  for (const field of type.fields) {
+    if (field.references === undefined) continue;
+    for (const parent of refTargets(field.references)) {
+      if (
+        parent.length === 0 ||
+        parent === type.name ||
+        !typeNames.has(parent) ||
+        seen.has(parent)
+      ) {
+        continue;
+      }
+      seen.add(parent);
+      parents.push(parent);
+    }
+  }
+  return parents;
+};
+
+const addChild = (
+  children: Map<string, string[]>,
+  parent: string,
+  child: string,
+): void => {
+  const list = children.get(parent);
+  if (list === undefined) {
+    children.set(parent, [child]);
+    return;
+  }
+  if (!list.includes(child)) list.push(child);
+};
+
+/** Child → parent edges. Each SCC id maps to its members. */
+const stronglyConnected = (
+  names: readonly string[],
+  parentsOf: (name: string) => readonly string[],
+): Map<string, number> => {
+  let index = 0;
+  let sccCount = 0;
+  const indices = new Map<string, number>();
+  const lows = new Map<string, number>();
+  const stack: string[] = [];
+  const onStack = new Set<string>();
+  const sccId = new Map<string, number>();
+
+  const connect = (v: string): void => {
+    indices.set(v, index);
+    lows.set(v, index);
+    index += 1;
+    stack.push(v);
+    onStack.add(v);
+    for (const w of parentsOf(v)) {
+      if (!indices.has(w)) {
+        connect(w);
+        const vLow = lows.get(v);
+        const wLow = lows.get(w);
+        if (vLow !== undefined && wLow !== undefined) {
+          lows.set(v, Math.min(vLow, wLow));
+        }
+      } else if (onStack.has(w)) {
+        const vLow = lows.get(v);
+        const wIndex = indices.get(w);
+        if (vLow !== undefined && wIndex !== undefined) {
+          lows.set(v, Math.min(vLow, wIndex));
+        }
+      }
+    }
+    if (lows.get(v) === indices.get(v)) {
+      let w: string | undefined;
+      do {
+        w = stack.pop();
+        if (w === undefined) break;
+        onStack.delete(w);
+        sccId.set(w, sccCount);
+      } while (w !== v);
+      sccCount += 1;
+    }
+  };
+
+  for (const name of names) {
+    if (!indices.has(name)) connect(name);
+  }
+  return sccId;
+};
+
+/** SCCs with no parent outside the component are top-level; those types point at root. */
+const sccsWithExternalParent = (
+  parentLists: ReadonlyMap<string, readonly string[]>,
+  sccId: ReadonlyMap<string, number>,
+): Set<number> => {
+  const hasExternal = new Set<number>();
+  for (const [name, parents] of parentLists) {
+    const from = sccId.get(name);
+    if (from === undefined) continue;
+    for (const parent of parents) {
+      const to = sccId.get(parent);
+      if (to !== undefined && to !== from) hasExternal.add(from);
+    }
+  }
+  return hasExternal;
+};
+
+const buildNode = (
+  children: Map<string, string[]>,
+  name: string,
+  path: ReadonlySet<string>,
+): DatasourceTypeTree => {
+  const node: DatasourceTypeTree = {};
+  for (const child of children.get(name) ?? []) {
+    if (path.has(child)) continue;
+    node[child] = buildNode(children, child, new Set([...path, child]));
+  }
+  return node;
+};
+
+const chosenParents = (
+  types: readonly Type[],
+  multiParent: "first" | "all",
+): Map<string, readonly string[]> => {
+  const typeNames = new Set(types.map((type) => type.name));
+  const parentLists = new Map<string, readonly string[]>();
+  for (const type of types) {
+    const parents = referencedParents(type, typeNames);
+    parentLists.set(
+      type.name,
+      multiParent === "all" ? parents : parents.slice(0, 1),
+    );
+  }
+  return parentLists;
+};
+
+const buildTree = (
+  types: readonly Type[],
+  parentLists: ReadonlyMap<string, readonly string[]>,
+): DatasourceTypeTree => {
+  const names = types.map((type) => type.name);
+  const sccId = stronglyConnected(names, (name) => parentLists.get(name) ?? []);
+  const hasExternalParent = sccsWithExternalParent(parentLists, sccId);
+  const children = new Map<string, string[]>();
+  for (const type of types) {
+    const scc = sccId.get(type.name);
+    const parents = parentLists.get(type.name) ?? [];
+    if (scc === undefined || !hasExternalParent.has(scc)) {
+      addChild(children, ROOT, type.name);
+      continue;
+    }
+    for (const parent of parents) {
+      addChild(children, parent, type.name);
+    }
+  }
+  return { [ROOT]: buildNode(children, ROOT, new Set([ROOT])) };
+};
+
+export const datasourceTypeTree = (
+  types: readonly Type[],
+  options: { multiParent?: "first" | "all" } = {},
+): DatasourceTypeTree =>
+  buildTree(types, chosenParents(types, options.multiParent ?? "first"));
+
+/** Each type appears once; first `references` parent wins. Cycle tops point at root. */
+export const datasourceTypeTreeFirst = (
+  types: readonly Type[],
+): DatasourceTypeTree => datasourceTypeTree(types, { multiParent: "first" });
+
+/** A type with several parents is nested under each of them. */
+export const datasourceTypeTreeAll = (
+  types: readonly Type[],
+): DatasourceTypeTree => datasourceTypeTree(types, { multiParent: "all" });
+
+/** Child → parent edges. Parentless types point at root; cycles and multi-parent are kept. */
+export const datasourceTypeGraph = (
+  types: readonly Type[],
+): DatasourceTypeGraph => {
+  const parentLists = chosenParents(types, "all");
+  const nodes = [ROOT, ...types.map((type) => type.name)];
+  const edges: DatasourceTypeGraphEdge[] = [];
+  for (const type of types) {
+    const parents = parentLists.get(type.name) ?? [];
+    if (parents.length === 0) {
+      edges.push({ from: type.name, to: ROOT });
+      continue;
+    }
+    for (const parent of parents) {
+      edges.push({ from: type.name, to: parent });
+    }
+  }
+  return { nodes, edges };
+};
+
+export const datasourceTypeHierarchies = (
+  types: readonly Type[],
+): DatasourceTypeHierarchies => ({
+  firstParentTree: datasourceTypeTreeFirst(types),
+  allParentsTree: datasourceTypeTreeAll(types),
+  graph: datasourceTypeGraph(types),
+});
+
+/** Pre-order walk of the first-parent tree (parent before children, authored sibling order). */
+export const datasourceTypeOrder = (
+  types: readonly Type[],
+): string[] => {
+  const names: string[] = [];
+  const walk = (node: DatasourceTypeTree) => {
+    for (const [name, child] of Object.entries(node)) {
+      names.push(name);
+      walk(child);
+    }
+  };
+  walk(datasourceTypeTreeFirst(types)[ROOT] ?? {});
+  return names;
+};
+
+/**
+ * All in-set `references` parents of `name`, recursively, parent before child.
+ * Does not include `name`. Self-edges and cycles are skipped.
+ */
+export const datasourceTypeAncestry = (
+  types: readonly Type[],
+  name: string,
+): string[] => {
+  const parentLists = chosenParents(types, "all");
+  if (!parentLists.has(name)) return [];
+  const out: string[] = [];
+  const seen = new Set<string>();
+  const walk = (current: string, path: ReadonlySet<string>): void => {
+    for (const parent of parentLists.get(current) ?? []) {
+      if (path.has(parent) || seen.has(parent)) continue;
+      walk(parent, new Set([...path, current]));
+      if (seen.has(parent)) continue;
+      seen.add(parent);
+      out.push(parent);
+    }
+  };
+  walk(name, new Set([name]));
+  return out;
+};
+
+/** Rank by tree order; names that inherit a type sort just after that type. */
+export const compareByDatasourceTypeOrder = (
+  types: readonly Type[],
+  inheritOf: (name: string) => string | null | undefined = () => undefined,
+): ((a: string, b: string) => number) => {
+  const order = datasourceTypeOrder(types);
+  const rank = new Map(order.map((name, i) => [name, i]));
+  const key = (name: string): [number, string] => {
+    const direct = rank.get(name);
+    if (direct !== undefined) return [direct * 2, name];
+    const inherit = inheritOf(name);
+    if (inherit !== null && inherit !== undefined) {
+      const parent = rank.get(inherit);
+      if (parent !== undefined) return [parent * 2 + 1, name];
+    }
+    return [order.length * 2, name];
+  };
+  return (a, b) => {
+    const [ia, na] = key(a);
+    const [ib, nb] = key(b);
+    return ia - ib || na.localeCompare(nb);
+  };
+};
+
+export const datasourceTypeTreeYaml = (tree: DatasourceTypeTree): string =>
+  stringify(tree);
+
+export const datasourceTypeTreeJson = (tree: DatasourceTypeTree): string =>
+  `${JSON.stringify(tree, null, 2)}\n`;
+
+const xmlElement = (
+  name: string,
+  children: DatasourceTypeTree,
+  indent: string,
+): string => {
+  const keys = Object.keys(children);
+  if (keys.length === 0) return `${indent}<${name}/>\n`;
+  const inner = keys
+    .map((key) => xmlElement(key, children[key] ?? {}, `${indent}  `))
+    .join("");
+  return `${indent}<${name}>\n${inner}${indent}</${name}>\n`;
+};
+
+export const datasourceTypeTreeXml = (tree: DatasourceTypeTree): string =>
+  Object.keys(tree)
+    .map((key) => xmlElement(key, tree[key] ?? {}, ""))
+    .join("");
+
+export const datasourceTypeGraphYaml = (graph: DatasourceTypeGraph): string =>
+  stringify(graph);
+
+export const datasourceTypeGraphJson = (graph: DatasourceTypeGraph): string =>
+  `${JSON.stringify(graph, null, 2)}\n`;
+
+export const datasourceTypeGraphXml = (graph: DatasourceTypeGraph): string => {
+  const nodes = graph.nodes
+    .map((name) => `    <node>${name}</node>\n`)
+    .join("");
+  const edges = graph.edges
+    .map((edge) => `    <edge from="${edge.from}" to="${edge.to}"/>\n`)
+    .join("");
+  return `<graph>\n  <nodes>\n${nodes}  </nodes>\n  <edges>\n${edges}  </edges>\n</graph>\n`;
+};

package/node_modules/@deterministic-code/generators-common/src/default-token.ts

@@ -0,0 +1,17 @@
+import { DeterministicDefaultValueConverter } from "./deterministic-default-value-converter.ts";
+
+/** The all-zero uuid, shared by the SQL and language default renderers for the `Empty` uuid token. */
+export const EMPTY_UUID = "00000000-0000-0000-0000-000000000000";
+
+/** Tokens whose value is produced fresh per row (a generator, not a constant). */
+export const GENERATIVE_TOKENS = new Set(["Now", "UtcNow", "NewId"]);
+
+export const parseDefaultToken = DeterministicDefaultValueConverter.parse;
+
+export const hexToBytes = (hex: string): number[] => {
+  const out: number[] = [];
+  for (let i = 0; i + 1 < hex.length; i += 2) {
+    out.push(parseInt(hex.slice(i, i + 2), 16));
+  }
+  return out;
+};

package/node_modules/@deterministic-code/generators-common/src/deterministic-default-value-converter.test.ts

@@ -0,0 +1,97 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { DeterministicDefaultValueConverter } from "./deterministic-default-value-converter.ts";
+import { parseDefaultToken } from "./default-token.ts";
+
+const EMPTY = "00000000-0000-0000-0000-000000000000";
+const spec = DeterministicDefaultValueConverter.spec;
+
+const sqlString = (arg: string): string => `'${arg.replace(/'/g, "''")}'`;
+
+describe("DeterministicDefaultValueConverter", () => {
+  const converter = new DeterministicDefaultValueConverter({
+    uuid: {
+      NewId: {
+        ...spec.uuid.NewId!,
+        native: () => "NEWID()",
+        reverse: /^NEWID\(\)$/,
+      },
+      Empty: {
+        ...spec.uuid.Empty!,
+        native: () => sqlString(EMPTY),
+        reverse: new RegExp(`^'${EMPTY}'$`),
+      },
+      Uuid: {
+        ...spec.uuid.Uuid!,
+        native: sqlString,
+        reverse: /^'([0-9a-fA-F-]{36})'$/,
+      },
+    },
+    datetime: {
+      Now: {
+        ...spec.datetime.Now!,
+        native: () => "GETDATE()",
+        reverse: /^GETDATE\(\)$/,
+      },
+      DateTime: {
+        ...spec.datetime.DateTime!,
+        native: sqlString,
+        reverse: /^'(.*)'$/,
+      },
+    },
+  });
+
+  it("exposes the dictionary as the mapping table", () => {
+    assert.equal(converter.dictionary.uuid!.NewId!.native(""), "NEWID()");
+  });
+
+  it("parseDefaultToken is the class parser", () => {
+    assert.deepEqual(parseDefaultToken("uuid", "NewId"), { token: "NewId" });
+    assert.deepEqual(
+      parseDefaultToken("uuid", "uuid('11111111-1111-4111-8111-111111111111')"),
+      { token: "Uuid", arg: "11111111-1111-4111-8111-111111111111" },
+    );
+  });
+
+  it("convert renders a bare NewId token", () => {
+    assert.equal(converter.convert("uuid", "NewId"), "NEWID()");
+  });
+
+  it("convert renders uuid('…') with the quoted argument", () => {
+    assert.equal(
+      converter.convert(
+        "uuid",
+        "uuid('11111111-1111-4111-8111-111111111111')",
+      ),
+      "'11111111-1111-4111-8111-111111111111'",
+    );
+  });
+
+  it("convert rejects NewId('…') because NewId has no argument", () => {
+    assert.throws(
+      () => converter.convert("uuid", "NewId('asdf-asdf-asdf-asdf')"),
+      /not a valid uuid NewId default/,
+    );
+  });
+
+  it("convert renders DateTime('…')", () => {
+    assert.equal(
+      converter.convert("datetime", "DateTime('2026-01-01T00:00:00Z')"),
+      "'2026-01-01T00:00:00Z'",
+    );
+  });
+
+  it("reverseConvert maps NEWID() back to NewId", () => {
+    assert.equal(converter.reverseConvert("uuid", "NEWID()"), "NewId");
+  });
+
+  it("reverseConvert rebuilds uuid('…') from a quoted literal", () => {
+    assert.equal(
+      converter.reverseConvert(
+        "uuid",
+        "'11111111-1111-4111-8111-111111111111'",
+      ),
+      "uuid('11111111-1111-4111-8111-111111111111')",
+    );
+  });
+});

package/node_modules/@deterministic-code/generators-common/src/deterministic-default-value-converter.ts

@@ -0,0 +1,148 @@
+export type SpecToken = {
+  spec: RegExp;
+  specText?: (arg: string) => string;
+};
+
+export type DefaultEntry = SpecToken & {
+  native: (arg: string) => string;
+  reverse: RegExp;
+};
+
+type DefaultToken = { token: string; arg?: string | boolean };
+
+const NUMERIC_LITERAL_TYPES = new Set([
+  "number",
+  "integer",
+  "unsignedinteger",
+  "smallinteger",
+  "unsignedsmallinteger",
+  "biginteger",
+  "unsignedbiginteger",
+  "float",
+  "decimal",
+  "reference",
+]);
+
+const CALL_FORM = /^([A-Za-z]+)\('(.*)'\)$/;
+
+const callTokenName = (name: string): string =>
+  name === "uuid" ? "Uuid" : name;
+
+const identity = (arg: string): string => arg;
+
+const intLit: SpecToken = { spec: /^-?[0-9]+$/, specText: identity };
+const uintLit: SpecToken = { spec: /^[0-9]+$/, specText: identity };
+const floatLit: SpecToken = {
+  spec: /^-?[0-9]+(\.[0-9]+)?$/,
+  specText: identity,
+};
+
+export class DeterministicDefaultValueConverter {
+  static readonly spec: Record<string, Record<string, SpecToken>> = {
+    string: { String: { spec: /^.*$/, specText: identity } },
+    character: { String: { spec: /^.+$/, specText: identity } },
+    number: { Numeric: intLit },
+    integer: { Numeric: intLit },
+    unsignedinteger: { Numeric: uintLit },
+    smallinteger: { Numeric: intLit },
+    unsignedsmallinteger: { Numeric: uintLit },
+    biginteger: { Numeric: intLit },
+    unsignedbiginteger: { Numeric: uintLit },
+    float: { Numeric: floatLit },
+    decimal: { Numeric: floatLit, String: { spec: /^.*$/, specText: identity } },
+    boolean: { Boolean: { spec: /^(true|false)$/, specText: identity } },
+    datetime: {
+      Now: { spec: /^Now$/ },
+      UtcNow: { spec: /^UtcNow$/ },
+      DateTime: {
+        spec: /^DateTime\('[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}(Z|[+-][0-9]{2}:[0-9]{2})'\)$/,
+        specText: (arg) => `DateTime('${arg}')`,
+      },
+    },
+    binary: {
+      Hex: {
+        spec: /^Hex\('([0-9a-fA-F]{2})*'\)$/,
+        specText: (arg) => `Hex('${arg}')`,
+      },
+    },
+    uuid: {
+      NewId: { spec: /^NewId$/ },
+      Empty: { spec: /^Empty$/ },
+      Uuid: {
+        spec: /^uuid\('[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}'\)$/,
+        specText: (arg) => `uuid('${arg}')`,
+      },
+    },
+    reference: {},
+  };
+
+  readonly dictionary: Record<string, Record<string, DefaultEntry>>;
+
+  constructor(dictionary: Record<string, Record<string, DefaultEntry>>) {
+    this.dictionary = dictionary;
+  }
+
+  static parse(specType: string, value: unknown): DefaultToken {
+    if (value === undefined || value === null) return { token: "None" };
+    const v = String(value);
+    const call = CALL_FORM.exec(v);
+    if (call !== null) {
+      return { token: callTokenName(call[1]!), arg: call[2] };
+    }
+    if (specType === "boolean") {
+      const arg = typeof value === "boolean" ? value : v === "true";
+      return { token: "Boolean", arg };
+    }
+    if (NUMERIC_LITERAL_TYPES.has(specType)) {
+      return { token: "Numeric", arg: v };
+    }
+    if (specType === "datetime") {
+      if (v === "Now") return { token: "Now" };
+      if (v === "UtcNow") return { token: "UtcNow" };
+      return { token: "DateTime", arg: v };
+    }
+    if (specType === "uuid") {
+      if (v === "NewId") return { token: "NewId" };
+      if (v === "Empty") return { token: "Empty" };
+      return { token: "Uuid", arg: v };
+    }
+    if (specType === "binary") return { token: "Hex", arg: v };
+    return { token: "String", arg: v };
+  }
+
+  convert(specType: string, text: string): string | null {
+    const parsed = DeterministicDefaultValueConverter.parse(specType, text);
+    if (parsed.token === "None") return null;
+    const entries = this.dictionary[specType];
+    if (entries === undefined) {
+      throw new Error(`Unknown spec field type: ${specType}`);
+    }
+    const entry = entries[parsed.token];
+    if (entry === undefined) return null;
+    if (!entry.spec.test(text)) {
+      throw new Error(
+        `default_value '${text}' is not a valid ${specType} ${parsed.token} default`,
+      );
+    }
+    const expr = entry.native(
+      parsed.arg === undefined ? "" : String(parsed.arg),
+    );
+    return expr === "" ? null : expr;
+  }
+
+  reverseConvert(specType: string, native: string): string {
+    const entries = this.dictionary[specType];
+    if (entries === undefined) {
+      throw new Error(`Unknown spec field type: ${specType}`);
+    }
+    for (const [token, entry] of Object.entries(entries)) {
+      const match = entry.reverse.exec(native);
+      if (match === null) continue;
+      const arg = match[1] ?? "";
+      return entry.specText === undefined ? token : entry.specText(arg);
+    }
+    throw new Error(
+      `Native default '${native}' is not a valid ${specType} default`,
+    );
+  }
+}

package/node_modules/@deterministic-code/generators-common/src/deterministic-reader.ts

@@ -0,0 +1,63 @@
+import { access, readFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+
+/** Host-supplied access to the deterministic YAML tree (disk, memory, zip, …). */
+export type IDeterministicReader = {
+  read: (name: string) => Promise<string>;
+  exists: (name: string) => Promise<boolean>;
+};
+
+type Source = {
+  read: (name: string) => Promise<string>;
+  exists: (name: string) => Promise<boolean>;
+};
+
+class DeterministicReader implements IDeterministicReader {
+  #source: Source;
+
+  constructor(source: Source) {
+    this.#source = source;
+  }
+
+  read(name: string): Promise<string> {
+    return this.#source.read(name);
+  }
+
+  exists(name: string): Promise<boolean> {
+    return this.#source.exists(name);
+  }
+}
+
+export const memoryReader = (
+  files: Record<string, string>,
+): IDeterministicReader =>
+  new DeterministicReader({
+    read: async (name) => {
+      if (!(name in files)) {
+        throw new Error(`deterministic reader: missing ${name}`);
+      }
+      return files[name];
+    },
+    exists: async (name) => name in files,
+  });
+
+export const fileReader = (root: string): IDeterministicReader => {
+  const dir = resolve(root);
+  return new DeterministicReader({
+    read: async (name) => {
+      try {
+        return await readFile(join(dir, name), "utf8");
+      } catch {
+        throw new Error(`deterministic reader: missing ${name} in ${dir}`);
+      }
+    },
+    exists: async (name) => {
+      try {
+        await access(join(dir, name));
+        return true;
+      } catch {
+        return false;
+      }
+    },
+  });
+};

package/node_modules/@deterministic-code/generators-common/src/deterministic-type-converter.test.ts

@@ -0,0 +1,34 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { DeterministicTypeConverter } from "./deterministic-type-converter.ts";
+
+describe("DeterministicTypeConverter", () => {
+  const converter = new DeterministicTypeConverter({
+    string: "TEXT",
+    integer: "INTEGER",
+    uuid: "TEXT",
+  });
+
+  it("exposes the dictionary as the mapping table", () => {
+    assert.equal(converter.dictionary.integer, "INTEGER");
+  });
+
+  it("convert maps a spec type to its native type", () => {
+    assert.equal(converter.convert("integer"), "INTEGER");
+  });
+
+  it("convert throws for an unknown spec type", () => {
+    assert.throws(() => converter.convert("bogus"), /Unknown spec field type/);
+  });
+
+  it("reverseConvert maps a unique native type back", () => {
+    assert.equal(converter.reverseConvert("INTEGER"), "integer");
+  });
+
+  it("reverseConvert throws when several spec types share a native type", () => {
+    assert.throws(
+      () => converter.reverseConvert("TEXT"),
+      /maps to multiple spec types: string, uuid/,
+    );
+  });
+});