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

package/node_modules/@deterministic-code/generators-common/dist/casing-strategy.js

@@ -0,0 +1,167 @@
+const CASE_FORMATS = [
+  "Camel",
+  "Pascal",
+  "Snake",
+  "Kebab",
+  "Auto"
+];
+const LANGUAGE_CASING_DEFAULTS = {
+  typescript: {
+    file_names: "Camel",
+    types: "Pascal",
+    fields: "Snake",
+    directories: "Camel"
+  },
+  javascript: {
+    file_names: "Camel",
+    types: "Pascal",
+    fields: "Camel",
+    directories: "Camel"
+  },
+  csharp: {
+    file_names: "Pascal",
+    types: "Pascal",
+    fields: "Pascal",
+    directories: "Pascal"
+  },
+  java: {
+    file_names: "Camel",
+    types: "Pascal",
+    fields: "Camel",
+    directories: "Camel"
+  },
+  python: {
+    file_names: "Camel",
+    types: "Pascal",
+    fields: "Snake",
+    directories: "Camel"
+  },
+  rust: {
+    file_names: "Camel",
+    types: "Pascal",
+    fields: "Snake",
+    directories: "Camel"
+  },
+  sql: {
+    file_names: "Snake",
+    types: "Snake",
+    fields: "Snake",
+    directories: "Snake"
+  },
+  openapi: {
+    file_names: "Kebab",
+    types: "Pascal",
+    fields: "Camel",
+    directories: "Kebab"
+  }
+};
+const LANGUAGE_ALIASES = {
+  ts: "typescript",
+  typescript: "typescript",
+  js: "javascript",
+  javascript: "javascript",
+  py: "python",
+  python: "python",
+  cs: "csharp",
+  csharp: "csharp",
+  "c#": "csharp",
+  java: "java",
+  rs: "rust",
+  rust: "rust",
+  sql: "sql",
+  openapi: "openapi"
+};
+const PARSE_CASE = {
+  camel: "Camel",
+  pascal: "Pascal",
+  snake: "Snake",
+  kebab: "Kebab",
+  auto: "Auto"
+};
+const wordsOf = (name) => name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/[_\-.]+/g, " ").trim().split(/\s+/).filter(Boolean).map((w) => w.toLowerCase());
+const cap = (word) => word.length === 0 ? word : word.charAt(0).toUpperCase() + word.slice(1);
+const toCase = (name, format) => {
+  const words = wordsOf(name);
+  if (words.length === 0) return name;
+  switch (format) {
+    case "Camel":
+      return words.map((w, i) => i === 0 ? w : cap(w)).join("");
+    case "Pascal":
+      return words.map(cap).join("");
+    case "Snake":
+      return words.join("_");
+    case "Kebab":
+      return words.join("-");
+  }
+};
+const parseCaseFormat = (raw, path) => {
+  if (raw === void 0 || raw === "") return "Auto";
+  const parsed = PARSE_CASE[raw.toLowerCase()];
+  if (parsed === void 0) {
+    throw new Error(
+      `${path} must be one of [${CASE_FORMATS.join(", ")}] (got "${raw}").`
+    );
+  }
+  return parsed;
+};
+const resolveCasingLanguage = (language) => {
+  const key = language.toLowerCase().replace(/[\s_]/g, "");
+  const resolved = LANGUAGE_ALIASES[key] ?? LANGUAGE_ALIASES[language.toLowerCase()];
+  if (resolved === void 0 || !(resolved in LANGUAGE_CASING_DEFAULTS)) {
+    throw new Error(
+      `createCasingStrategy: unknown language "${language}". Valid: ${Object.keys(LANGUAGE_CASING_DEFAULTS).join(", ")}.`
+    );
+  }
+  return resolved;
+};
+const resolveLeaf = (override, fallback) => override === "Auto" ? fallback : override;
+class CasingStrategy {
+  #fileNames;
+  #types;
+  #fields;
+  #directories;
+  constructor(resolved) {
+    this.#fileNames = resolved.file_names;
+    this.#types = resolved.types;
+    this.#fields = resolved.fields;
+    this.#directories = resolved.directories;
+  }
+  convertFileName(text) {
+    return toCase(text, this.#fileNames);
+  }
+  convertTypes(text) {
+    return toCase(text, this.#types);
+  }
+  convertFields(text) {
+    return toCase(text, this.#fields);
+  }
+  convertDirectories(text) {
+    return toCase(text, this.#directories);
+  }
+}
+const createCasingStrategy = (language, settings = {}, options) => {
+  const lang = resolveCasingLanguage(language);
+  const defaults = LANGUAGE_CASING_DEFAULTS[lang];
+  const prefix = options?.prefix ?? `languages.${lang}.casing`;
+  return new CasingStrategy({
+    file_names: resolveLeaf(
+      parseCaseFormat(settings[`${prefix}.file_names`], `${prefix}.file_names`),
+      defaults.file_names
+    ),
+    types: resolveLeaf(
+      parseCaseFormat(settings[`${prefix}.types`], `${prefix}.types`),
+      defaults.types
+    ),
+    fields: resolveLeaf(
+      parseCaseFormat(settings[`${prefix}.fields`], `${prefix}.fields`),
+      defaults.fields
+    ),
+    directories: resolveLeaf(
+      parseCaseFormat(settings[`${prefix}.directories`], `${prefix}.directories`),
+      defaults.directories
+    )
+  });
+};
+export {
+  createCasingStrategy
+};

package/node_modules/@deterministic-code/generators-common/dist/datasource-naming.d.ts

@@ -0,0 +1,10 @@
+export type IDatasourceNaming = {
+    isVerbatim: (mapping: string) => boolean;
+    physicalStem: (logicalOrMapping: string) => string;
+    tableName: (stem: string) => string;
+    columnName: (stem: string) => string;
+    resolveTable: (logical: string, mapping?: string) => string;
+    resolveColumn: (logical: string, mapping?: string) => string;
+};
+/** Physical table/column names from `datasource.casing` + last-token pluralize. */
+export declare const createDatasourceNaming: (settings: Record<string, string>) => IDatasourceNaming;

package/node_modules/@deterministic-code/generators-common/dist/datasource-naming.js

@@ -0,0 +1,29 @@
+import { createCasingStrategy } from "./casing-strategy.js";
+import pluralize from "pluralize";
+const SNAKE_STEM = /^[a-z_][a-z0-9_]*$/;
+const lastTokenPluralize = (name) => name ? name.replace(/[^_]+$/, (token) => pluralize(token)) : name;
+const createDatasourceNaming = (settings) => {
+  const casing = createCasingStrategy("sql", settings, {
+    prefix: "datasource.casing"
+  });
+  const pluralizeNames = String(settings["datasource.pluralize_datatable_names"]) !== "false";
+  const isVerbatim = (mapping) => !SNAKE_STEM.test(mapping);
+  const tableName = (stem) => casing.convertTypes(stem);
+  const columnName = (stem) => casing.convertFields(stem);
+  const physicalStem = (name) => isVerbatim(name) ? name : pluralizeNames ? lastTokenPluralize(name) : name;
+  const resolve = (convert, logical, mapping) => {
+    const stem = mapping ?? logical;
+    return isVerbatim(stem) ? stem : convert(stem);
+  };
+  return {
+    isVerbatim,
+    physicalStem,
+    tableName,
+    columnName,
+    resolveTable: (logical, mapping) => resolve((stem) => tableName(physicalStem(stem)), logical, mapping),
+    resolveColumn: (logical, mapping) => resolve(columnName, logical, mapping)
+  };
+};
+export {
+  createDatasourceNaming
+};

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

@@ -0,0 +1,42 @@
+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;
+};
+export declare const datasourceTypeTree: (types: readonly Type[], options?: {
+    multiParent?: "first" | "all";
+}) => DatasourceTypeTree;
+/** Each type appears once; first `references` parent wins. Cycle tops point at root. */
+export declare const datasourceTypeTreeFirst: (types: readonly Type[]) => DatasourceTypeTree;
+/** A type with several parents is nested under each of them. */
+export declare const datasourceTypeTreeAll: (types: readonly Type[]) => DatasourceTypeTree;
+/** Child → parent edges. Parentless types point at root; cycles and multi-parent are kept. */
+export declare const datasourceTypeGraph: (types: readonly Type[]) => DatasourceTypeGraph;
+export declare const datasourceTypeHierarchies: (types: readonly Type[]) => DatasourceTypeHierarchies;
+/** Pre-order walk of the first-parent tree (parent before children, authored sibling order). */
+export declare const datasourceTypeOrder: (types: readonly Type[]) => string[];
+/**
+ * All in-set `references` parents of `name`, recursively, parent before child.
+ * Does not include `name`. Self-edges and cycles are skipped.
+ */
+export declare const datasourceTypeAncestry: (types: readonly Type[], name: string) => string[];
+/** Rank by tree order; names that inherit a type sort just after that type. */
+export declare const compareByDatasourceTypeOrder: (types: readonly Type[], inheritOf?: (name: string) => string | null | undefined) => ((a: string, b: string) => number);
+export declare const datasourceTypeTreeYaml: (tree: DatasourceTypeTree) => string;
+export declare const datasourceTypeTreeJson: (tree: DatasourceTypeTree) => string;
+export declare const datasourceTypeTreeXml: (tree: DatasourceTypeTree) => string;
+export declare const datasourceTypeGraphYaml: (graph: DatasourceTypeGraph) => string;
+export declare const datasourceTypeGraphJson: (graph: DatasourceTypeGraph) => string;
+export declare const datasourceTypeGraphXml: (graph: DatasourceTypeGraph) => string;

package/node_modules/@deterministic-code/generators-common/dist/datasource-type-tree.js

@@ -0,0 +1,240 @@
+import { stringify } from "yaml";
+const ROOT = "root";
+const refTargets = (references) => (Array.isArray(references) ? references : [references]).map(
+  (ref) => ref.split(".")[0] || ""
+);
+const referencedParents = (type, typeNames) => {
+  const parents = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const field of type.fields) {
+    if (field.references === void 0) 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, parent, child) => {
+  const list = children.get(parent);
+  if (list === void 0) {
+    children.set(parent, [child]);
+    return;
+  }
+  if (!list.includes(child)) list.push(child);
+};
+const stronglyConnected = (names, parentsOf) => {
+  let index = 0;
+  let sccCount = 0;
+  const indices = /* @__PURE__ */ new Map();
+  const lows = /* @__PURE__ */ new Map();
+  const stack = [];
+  const onStack = /* @__PURE__ */ new Set();
+  const sccId = /* @__PURE__ */ new Map();
+  const connect = (v) => {
+    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 !== void 0 && wLow !== void 0) {
+          lows.set(v, Math.min(vLow, wLow));
+        }
+      } else if (onStack.has(w)) {
+        const vLow = lows.get(v);
+        const wIndex = indices.get(w);
+        if (vLow !== void 0 && wIndex !== void 0) {
+          lows.set(v, Math.min(vLow, wIndex));
+        }
+      }
+    }
+    if (lows.get(v) === indices.get(v)) {
+      let w;
+      do {
+        w = stack.pop();
+        if (w === void 0) 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;
+};
+const sccsWithExternalParent = (parentLists, sccId) => {
+  const hasExternal = /* @__PURE__ */ new Set();
+  for (const [name, parents] of parentLists) {
+    const from = sccId.get(name);
+    if (from === void 0) continue;
+    for (const parent of parents) {
+      const to = sccId.get(parent);
+      if (to !== void 0 && to !== from) hasExternal.add(from);
+    }
+  }
+  return hasExternal;
+};
+const buildNode = (children, name, path) => {
+  const node = {};
+  for (const child of children.get(name) ?? []) {
+    if (path.has(child)) continue;
+    node[child] = buildNode(children, child, /* @__PURE__ */ new Set([...path, child]));
+  }
+  return node;
+};
+const chosenParents = (types, multiParent) => {
+  const typeNames = new Set(types.map((type) => type.name));
+  const parentLists = /* @__PURE__ */ new Map();
+  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, parentLists) => {
+  const names = types.map((type) => type.name);
+  const sccId = stronglyConnected(names, (name) => parentLists.get(name) ?? []);
+  const hasExternalParent = sccsWithExternalParent(parentLists, sccId);
+  const children = /* @__PURE__ */ new Map();
+  for (const type of types) {
+    const scc = sccId.get(type.name);
+    const parents = parentLists.get(type.name) ?? [];
+    if (scc === void 0 || !hasExternalParent.has(scc)) {
+      addChild(children, ROOT, type.name);
+      continue;
+    }
+    for (const parent of parents) {
+      addChild(children, parent, type.name);
+    }
+  }
+  return { [ROOT]: buildNode(children, ROOT, /* @__PURE__ */ new Set([ROOT])) };
+};
+const datasourceTypeTree = (types, options = {}) => buildTree(types, chosenParents(types, options.multiParent ?? "first"));
+const datasourceTypeTreeFirst = (types) => datasourceTypeTree(types, { multiParent: "first" });
+const datasourceTypeTreeAll = (types) => datasourceTypeTree(types, { multiParent: "all" });
+const datasourceTypeGraph = (types) => {
+  const parentLists = chosenParents(types, "all");
+  const nodes = [ROOT, ...types.map((type) => type.name)];
+  const edges = [];
+  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 };
+};
+const datasourceTypeHierarchies = (types) => ({
+  firstParentTree: datasourceTypeTreeFirst(types),
+  allParentsTree: datasourceTypeTreeAll(types),
+  graph: datasourceTypeGraph(types)
+});
+const datasourceTypeOrder = (types) => {
+  const names = [];
+  const walk = (node) => {
+    for (const [name, child] of Object.entries(node)) {
+      names.push(name);
+      walk(child);
+    }
+  };
+  walk(datasourceTypeTreeFirst(types)[ROOT] ?? {});
+  return names;
+};
+const datasourceTypeAncestry = (types, name) => {
+  const parentLists = chosenParents(types, "all");
+  if (!parentLists.has(name)) return [];
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const walk = (current, path) => {
+    for (const parent of parentLists.get(current) ?? []) {
+      if (path.has(parent) || seen.has(parent)) continue;
+      walk(parent, /* @__PURE__ */ new Set([...path, current]));
+      if (seen.has(parent)) continue;
+      seen.add(parent);
+      out.push(parent);
+    }
+  };
+  walk(name, /* @__PURE__ */ new Set([name]));
+  return out;
+};
+const compareByDatasourceTypeOrder = (types, inheritOf = () => void 0) => {
+  const order = datasourceTypeOrder(types);
+  const rank = new Map(order.map((name, i) => [name, i]));
+  const key = (name) => {
+    const direct = rank.get(name);
+    if (direct !== void 0) return [direct * 2, name];
+    const inherit = inheritOf(name);
+    if (inherit !== null && inherit !== void 0) {
+      const parent = rank.get(inherit);
+      if (parent !== void 0) 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);
+  };
+};
+const datasourceTypeTreeYaml = (tree) => stringify(tree);
+const datasourceTypeTreeJson = (tree) => `${JSON.stringify(tree, null, 2)}
+`;
+const xmlElement = (name, children, indent) => {
+  const keys = Object.keys(children);
+  if (keys.length === 0) return `${indent}<${name}/>
+`;
+  const inner = keys.map((key) => xmlElement(key, children[key] ?? {}, `${indent}  `)).join("");
+  return `${indent}<${name}>
+${inner}${indent}</${name}>
+`;
+};
+const datasourceTypeTreeXml = (tree) => Object.keys(tree).map((key) => xmlElement(key, tree[key] ?? {}, "")).join("");
+const datasourceTypeGraphYaml = (graph) => stringify(graph);
+const datasourceTypeGraphJson = (graph) => `${JSON.stringify(graph, null, 2)}
+`;
+const datasourceTypeGraphXml = (graph) => {
+  const nodes = graph.nodes.map((name) => `    <node>${name}</node>
+`).join("");
+  const edges = graph.edges.map((edge) => `    <edge from="${edge.from}" to="${edge.to}"/>
+`).join("");
+  return `<graph>
+  <nodes>
+${nodes}  </nodes>
+  <edges>
+${edges}  </edges>
+</graph>
+`;
+};
+export {
+  compareByDatasourceTypeOrder,
+  datasourceTypeAncestry,
+  datasourceTypeGraph,
+  datasourceTypeGraphJson,
+  datasourceTypeGraphXml,
+  datasourceTypeGraphYaml,
+  datasourceTypeHierarchies,
+  datasourceTypeOrder,
+  datasourceTypeTree,
+  datasourceTypeTreeAll,
+  datasourceTypeTreeFirst,
+  datasourceTypeTreeJson,
+  datasourceTypeTreeXml,
+  datasourceTypeTreeYaml
+};

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

@@ -0,0 +1,7 @@
+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 declare const EMPTY_UUID = "00000000-0000-0000-0000-000000000000";
+/** Tokens whose value is produced fresh per row (a generator, not a constant). */
+export declare const GENERATIVE_TOKENS: Set<string>;
+export declare const parseDefaultToken: typeof DeterministicDefaultValueConverter.parse;
+export declare const hexToBytes: (hex: string) => number[];

package/node_modules/@deterministic-code/generators-common/dist/default-token.js

@@ -0,0 +1,17 @@
+import { DeterministicDefaultValueConverter } from "./deterministic-default-value-converter.js";
+const EMPTY_UUID = "00000000-0000-0000-0000-000000000000";
+const GENERATIVE_TOKENS = /* @__PURE__ */ new Set(["Now", "UtcNow", "NewId"]);
+const parseDefaultToken = DeterministicDefaultValueConverter.parse;
+const hexToBytes = (hex) => {
+  const out = [];
+  for (let i = 0; i + 1 < hex.length; i += 2) {
+    out.push(parseInt(hex.slice(i, i + 2), 16));
+  }
+  return out;
+};
+export {
+  EMPTY_UUID,
+  GENERATIVE_TOKENS,
+  hexToBytes,
+  parseDefaultToken
+};

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

@@ -0,0 +1,21 @@
+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;
+};
+export declare class DeterministicDefaultValueConverter {
+    static readonly spec: Record<string, Record<string, SpecToken>>;
+    readonly dictionary: Record<string, Record<string, DefaultEntry>>;
+    constructor(dictionary: Record<string, Record<string, DefaultEntry>>);
+    static parse(specType: string, value: unknown): DefaultToken;
+    convert(specType: string, text: string): string | null;
+    reverseConvert(specType: string, native: string): string;
+}
+export {};

package/node_modules/@deterministic-code/generators-common/dist/deterministic-default-value-converter.js

@@ -0,0 +1,128 @@
+const NUMERIC_LITERAL_TYPES = /* @__PURE__ */ new Set([
+  "number",
+  "integer",
+  "unsignedinteger",
+  "smallinteger",
+  "unsignedsmallinteger",
+  "biginteger",
+  "unsignedbiginteger",
+  "float",
+  "decimal",
+  "reference"
+]);
+const CALL_FORM = /^([A-Za-z]+)\('(.*)'\)$/;
+const callTokenName = (name) => name === "uuid" ? "Uuid" : name;
+const identity = (arg) => arg;
+const intLit = { spec: /^-?[0-9]+$/, specText: identity };
+const uintLit = { spec: /^[0-9]+$/, specText: identity };
+const floatLit = {
+  spec: /^-?[0-9]+(\.[0-9]+)?$/,
+  specText: identity
+};
+class DeterministicDefaultValueConverter {
+  static spec = {
+    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: {}
+  };
+  dictionary;
+  constructor(dictionary) {
+    this.dictionary = dictionary;
+  }
+  static parse(specType, value) {
+    if (value === void 0 || 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, text) {
+    const parsed = DeterministicDefaultValueConverter.parse(specType, text);
+    if (parsed.token === "None") return null;
+    const entries = this.dictionary[specType];
+    if (entries === void 0) {
+      throw new Error(`Unknown spec field type: ${specType}`);
+    }
+    const entry = entries[parsed.token];
+    if (entry === void 0) 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 === void 0 ? "" : String(parsed.arg)
+    );
+    return expr === "" ? null : expr;
+  }
+  reverseConvert(specType, native) {
+    const entries = this.dictionary[specType];
+    if (entries === void 0) {
+      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 === void 0 ? token : entry.specText(arg);
+    }
+    throw new Error(
+      `Native default '${native}' is not a valid ${specType} default`
+    );
+  }
+}
+export {
+  DeterministicDefaultValueConverter
+};

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

@@ -0,0 +1,7 @@
+/** Host-supplied access to the deterministic YAML tree (disk, memory, zip, …). */
+export type IDeterministicReader = {
+    read: (name: string) => Promise<string>;
+    exists: (name: string) => Promise<boolean>;
+};
+export declare const memoryReader: (files: Record<string, string>) => IDeterministicReader;
+export declare const fileReader: (root: string) => IDeterministicReader;