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

package/node_modules/@deterministic-code/deterministic-generators-common/typescript/parser/dist/specification-parser.js

@@ -0,0 +1,1290 @@
+// node_modules/@deterministic-code/deterministic-generators-common/typescript/parser/parser/specification-parser.ts
+import pluralize from "pluralize";
+
+// node_modules/@deterministic-code/deterministic-generators-common/typescript/parser/deterministic.ts
+var Deterministic = class {
+  types;
+  expandedTypes;
+  datasource;
+  datasourceSeeds;
+  services;
+  routes;
+  constructor(args) {
+    this.types = args.types;
+    this.expandedTypes = args.expandedTypes;
+    this.datasource = args.datasource;
+    this.datasourceSeeds = args.datasourceSeeds;
+    this.services = args.services;
+    this.routes = args.routes;
+  }
+};
+
+// node_modules/@deterministic-code/deterministic-generators-common/typescript/parser/ensure-health.ts
+var HEALTH_SERVICE_NAME = "HealthCheckService";
+var HEALTH_SERVICE_METHOD = "check";
+var HEALTH_ROUTE_NAME = "getHealth";
+var HEALTH_ROUTE_PATH = "/api/health";
+var seedService = () => ({
+  name: HEALTH_SERVICE_NAME,
+  methods: [HEALTH_SERVICE_METHOD]
+});
+var seedRoute = () => ({
+  name: HEALTH_ROUTE_NAME,
+  path: HEALTH_ROUTE_PATH,
+  method: "GET",
+  entity: null
+});
+var prepend = (list, match, seed) => {
+  const idx = list.findIndex(match);
+  if (idx === 0) return [...list];
+  if (idx > 0) {
+    return [list[idx], ...list.slice(0, idx), ...list.slice(idx + 1)];
+  }
+  return [seed, ...list];
+};
+var ensureHealth = (deterministic) => new Deterministic({
+  ...deterministic,
+  services: {
+    ...deterministic.services,
+    customs: prepend(
+      deterministic.services.customs,
+      (s) => s.name === HEALTH_SERVICE_NAME,
+      seedService()
+    )
+  },
+  routes: {
+    ...deterministic.routes,
+    customs: prepend(
+      deterministic.routes.customs,
+      (r) => r.path === HEALTH_ROUTE_PATH,
+      seedRoute()
+    )
+  }
+});
+
+// node_modules/@deterministic-code/deterministic-generators-common/typescript/parser/parser/compile-filter.ts
+var ACCESSORS = /* @__PURE__ */ new Set(["type", "tag", "inherits"]);
+var ALLOWED_INTERNAL = /* @__PURE__ */ new Set([
+  "__name",
+  "__tags",
+  "__inherits",
+  "includes",
+  "true",
+  "false",
+  "null",
+  "undefined",
+  ...ACCESSORS
+]);
+var assertKnownIdents = (s, contextLabel) => {
+  for (const ident of s.match(/[A-Za-z_][A-Za-z0-9_]*/g) ?? []) {
+    if (ident.startsWith("__STR")) continue;
+    if (ALLOWED_INTERNAL.has(ident)) continue;
+    throw new Error(
+      `${contextLabel}: unknown identifier or syntax near "${ident}". Supported: \`type == "name"\`, \`tag == "kind"\`, \`inherits == "parent"\`, logical && / ||, parens.`
+    );
+  }
+};
+var compileExpr = (s, contextLabel) => {
+  try {
+    return new Function(
+      "__name",
+      "__tags",
+      "__inherits",
+      `return (${s});`
+    );
+  } catch (e) {
+    throw new Error(
+      `${contextLabel} is not a valid expression: ${e.message}`
+    );
+  }
+};
+var rewriteDslToJs = (input) => input.replace(/\btype\s*(==|!=)\s*(__STR\d+__)/g, (_, op, idx) => {
+  const jsOp = op === "==" ? "===" : "!==";
+  return `(__name ${jsOp} ${idx})`;
+}).replace(/\btag\s*==\s*(__STR\d+__)/g, (_, idx) => `__tags.includes(${idx})`).replace(/\btag\s*!=\s*(__STR\d+__)/g, (_, idx) => `!__tags.includes(${idx})`).replace(/\binherits\s*(==|!=)\s*(__STR\d+__)/g, (_, op, idx) => {
+  const jsOp = op === "==" ? "===" : "!==";
+  return `(__inherits ${jsOp} ${idx})`;
+});
+var compileFilter = (filterExpr, contextLabel = "filter") => {
+  if (!filterExpr) return () => true;
+  const placeholders = [];
+  const withStrings = filterExpr.replace(/"[^"]*"/g, (m) => {
+    placeholders.push(m);
+    return `__STR${placeholders.length - 1}__`;
+  });
+  const rewritten = rewriteDslToJs(withStrings);
+  assertKnownIdents(rewritten, contextLabel);
+  const restored = rewritten.replace(
+    /__STR(\d+)__/g,
+    (_, idx) => placeholders[Number(idx)]
+  );
+  const fn = compileExpr(restored, contextLabel);
+  return (cand) => Boolean(fn(cand.name, cand.tags, cand.inherits ?? ""));
+};
+var compileTypesFilter = (filterExpr) => compileFilter(filterExpr, "types.filter");
+
+// node_modules/@deterministic-code/deterministic-generators-common/typescript/parser/specification.ts
+var TYPES_YAML = "types.yaml";
+var DATASOURCE_YAML = "datasource.yaml";
+var DATASOURCE_SEEDS_YAML = "datasource_seeds.yaml";
+var SERVICES_YAML = "services.yaml";
+var ROUTES_YAML = "routes.yaml";
+var PRIMITIVES = /* @__PURE__ */ new Set([
+  "string",
+  "character",
+  "number",
+  "integer",
+  "unsignedinteger",
+  "biginteger",
+  "unsignedbiginteger",
+  "smallinteger",
+  "unsignedsmallinteger",
+  "float",
+  "decimal",
+  "boolean",
+  "datetime",
+  "binary",
+  "uuid",
+  "reference"
+]);
+var SET_FIELDS = [{
+  name: "id",
+  type: "integer",
+  kind: "primitive",
+  base: "integer",
+  isArray: false,
+  isMap: false,
+  isNullable: false
+}];
+var parseFieldType = (raw) => {
+  const isArray = raw.endsWith("[]");
+  const isMap2 = raw.endsWith("{}");
+  const base = isArray || isMap2 ? raw.slice(0, -2) : raw;
+  return {
+    kind: PRIMITIVES.has(base) ? "primitive" : "type",
+    base,
+    isArray,
+    isMap: isMap2
+  };
+};
+var markedIds = (type) => type.fields.filter((f) => f.isId === true).map((f) => f.name);
+var hasAuthoredIdentity = (type) => type.ids !== void 0 && type.ids.length > 0 || markedIds(type).length > 0;
+var identityColumns = (type) => {
+  if (!type) return ["id"];
+  if (type.ids !== void 0 && type.ids.length > 0) return [...type.ids];
+  const marked = markedIds(type);
+  return marked.length > 0 ? marked : type.inherits === "set" ? ["id"] : [];
+};
+var primaryKeyColumn = (_table, type) => identityColumns(type)[0] ?? "id";
+var uniqueLookupFields = (type, table) => {
+  const out = [];
+  const add = (name) => {
+    if (out.some((e) => e.field === name)) return;
+    const f = type.fields.find((x) => x.name === name);
+    out.push({
+      field: name,
+      type: typeof f?.type === "string" ? f.type : "string",
+      ...typeof f?.size === "number" ? { size: f.size } : {}
+    });
+  };
+  for (const name of identityColumns(type)) add(name);
+  for (const overlay of table?.fields ?? []) if (overlay.isUnique) add(overlay.name);
+  for (const name of table?.uniqueIndexFields ?? []) add(name);
+  return out;
+};
+var splitDot = (value) => {
+  const i = value.indexOf(".");
+  return i === -1 ? void 0 : [value.slice(0, i), value.slice(i + 1)];
+};
+var identityFieldNames = (type, byName, stack = /* @__PURE__ */ new Set()) => {
+  if (!type) return /* @__PURE__ */ new Set();
+  if (stack.has(type.name)) return /* @__PURE__ */ new Set();
+  const local = identityColumns(type);
+  if (local.length > 0) return new Set(local);
+  if (type.inherits && type.inherits !== "dictionary") {
+    stack.add(type.name);
+    return identityFieldNames(byName.get(type.inherits), byName, stack);
+  }
+  return /* @__PURE__ */ new Set();
+};
+var isOwnerIdentityRef = (references, selfName, byName) => {
+  if (references === void 0) return false;
+  const parts = (Array.isArray(references) ? references : [references]).map(
+    (ref) => {
+      const split = splitDot(ref);
+      return split ? { type: split[0], field: split[1] } : { type: "", field: ref };
+    }
+  );
+  const owner = parts[0].type;
+  if (!owner || owner === selfName) return false;
+  const identity = identityFieldNames(byName.get(owner), byName);
+  return parts.every((p) => p.type === owner && identity.has(p.field));
+};
+var extractFields = (fields, extract) => {
+  if (!extract?.length) return fields;
+  const allow = /* @__PURE__ */ new Map();
+  for (const item of extract) {
+    const split = splitDot(item);
+    if (!split) continue;
+    const set = allow.get(split[0]) ?? /* @__PURE__ */ new Set();
+    set.add(split[1]);
+    allow.set(split[0], set);
+  }
+  return fields.filter((f) => {
+    const keep = allow.get(f.source);
+    return !keep || keep.has(f.name);
+  });
+};
+var renameFields = (fields, mapping) => mapping ? fields.map((f) => {
+  const name = mapping[`${f.source}.${f.name}`] ?? mapping[f.name];
+  return name !== void 0 ? { ...f, name } : f;
+}) : fields;
+var assertUniqueFieldNames = (fields, typeName) => {
+  const seen = /* @__PURE__ */ new Map();
+  for (const field of fields) {
+    const prev = seen.get(field.name);
+    if (prev) {
+      throw new Error(
+        `${prev.source}.${prev.original} and ${field.source}.${field.original} collide on the composed shape of ${typeName}; use mapping or remove_fields and give new names`
+      );
+    }
+    seen.set(field.name, field);
+  }
+};
+var keepFields = (fields, remove) => remove?.length ? fields.filter(
+  (f) => !remove.some((item) => {
+    const split = splitDot(item);
+    return split ? f.name === split[1] && f.source === split[0] : f.name === item;
+  })
+) : fields;
+var expandTypes = (types) => {
+  const byName = new Map(types.map((t) => [t.name, t]));
+  const cache = /* @__PURE__ */ new Map();
+  const resolve = (name, stack) => {
+    const hit = cache.get(name);
+    if (hit) return hit;
+    if (name === "set") {
+      cache.set(name, SET_FIELDS);
+      return SET_FIELDS;
+    }
+    if (stack.has(name)) {
+      throw new Error(`circular inherit/union involving "${name}"`);
+    }
+    const type = byName.get(name);
+    if (!type) return [];
+    stack.add(name);
+    const composeSource = (source) => {
+      const fields = resolve(source, stack).map((f) => ({
+        ...f,
+        source,
+        original: f.name
+      }));
+      const srcType = byName.get(source);
+      return srcType?.inherits === "dictionary" ? fields.filter(
+        (f) => !isOwnerIdentityRef(f.references, srcType.name, byName)
+      ) : fields;
+    };
+    const skipSetId = type.inherits === "set" && hasAuthoredIdentity(type);
+    const inherited = [
+      ...type.inherits && !skipSetId ? composeSource(type.inherits) : [],
+      ...(type.union ?? []).flatMap(composeSource)
+    ];
+    stack.delete(name);
+    const merged = [
+      ...keepFields(
+        renameFields(extractFields(inherited, type.extract), type.mapping),
+        type.removeFields
+      ),
+      ...type.fields.map((f) => ({ ...f, source: name, original: f.name }))
+    ];
+    assertUniqueFieldNames(merged, name);
+    const result = merged.map(({ source: _s, original: _o, ...rest }) => rest);
+    cache.set(name, result);
+    return result;
+  };
+  const resolveIds = (name, stack) => {
+    if (stack.has(name)) return void 0;
+    const type = byName.get(name);
+    if (!type) return void 0;
+    if (type.ids !== void 0 && type.ids.length > 0) return type.ids;
+    if (type.fields.some((f) => f.isId === true)) return void 0;
+    if (type.inherits && type.inherits !== "set" && type.inherits !== "dictionary") {
+      stack.add(name);
+      const ids = resolveIds(type.inherits, stack);
+      stack.delete(name);
+      return ids;
+    }
+    return void 0;
+  };
+  return types.map((type) => {
+    const ids = type.ids ?? resolveIds(type.name, /* @__PURE__ */ new Set());
+    return {
+      ...type,
+      ...ids !== void 0 && ids.length > 0 ? { ids } : {},
+      fields: resolve(type.name, /* @__PURE__ */ new Set())
+    };
+  });
+};
+
+// node_modules/@deterministic-code/deterministic-generators-common/typescript/parser/datasource-type-tree.ts
+import { stringify } from "yaml";
+var ROOT = "root";
+var refTargets = (references) => (Array.isArray(references) ? references : [references]).map(
+  (ref) => ref.split(".")[0] || ""
+);
+var 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;
+};
+var 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);
+};
+var 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();
+        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;
+};
+var sccsWithExternalParent = (parentLists, sccId) => {
+  const hasExternal = /* @__PURE__ */ new Set();
+  for (const [name, parents] of parentLists) {
+    const from = sccId.get(name);
+    for (const parent of parents) {
+      const to = sccId.get(parent);
+      if (to !== void 0 && to !== from) hasExternal.add(from);
+    }
+  }
+  return hasExternal;
+};
+var 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;
+};
+var 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;
+};
+var 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 (!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])) };
+};
+var datasourceTypeTree = (types, options = {}) => buildTree(types, chosenParents(types, options.multiParent ?? "first"));
+var datasourceTypeTreeFirst = (types) => datasourceTypeTree(types, { multiParent: "first" });
+var 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;
+};
+var 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);
+  };
+};
+
+// node_modules/@deterministic-code/deterministic-generators-common/typescript/parser/yaml-node.ts
+import { parse } from "yaml";
+var isMap = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var isString = (v) => typeof v === "string";
+var isFiniteNumber = (v) => typeof v === "number" && Number.isFinite(v);
+var isFiniteInt = (v) => isFiniteNumber(v) && Number.isInteger(v);
+var isLiteral = (v) => v === null || typeof v === "string" || typeof v === "number" || typeof v === "boolean";
+var yamlNode = (value, path = "$") => {
+  const record = isMap(value) ? value : void 0;
+  const at = (key) => record?.[key];
+  const pick = (pred) => (key) => {
+    const v = at(key);
+    return pred(v) ? v : void 0;
+  };
+  const child = (key) => yamlNode(at(key), `${path}.${key}`);
+  const items = () => Array.isArray(value) ? value.map((item, i) => yamlNode(item, `${path}[${i}]`)) : [];
+  return {
+    value,
+    path,
+    record,
+    child,
+    has: (key) => record !== void 0 && Object.prototype.hasOwnProperty.call(record, key),
+    str: pick(isString),
+    bool: (key) => at(key) === true,
+    finiteNumber: pick(isFiniteNumber),
+    finiteInt: pick(isFiniteInt),
+    literal: pick(isLiteral),
+    strings: (key) => {
+      const v = at(key);
+      return Array.isArray(v) ? v.filter(isString) : [];
+    },
+    items,
+    namedItems: () => items().flatMap((item) => {
+      const [name, body] = Object.entries(item.record ?? {})[0] ?? [];
+      return name === void 0 ? [] : [{ name, node: yamlNode(body, `${item.path}.${name}`) }];
+    }),
+    namedList: (key) => child(key).namedItems()
+  };
+};
+var YamlNode = Object.assign(yamlNode, {
+  fromYaml: (text, path = "$") => yamlNode(parse(text), path)
+});
+
+// node_modules/@deterministic-code/deterministic-generators-common/typescript/parser/parser/specification-parser.ts
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var SHORTHAND_VERB_RE = /^(get|put|delete)_/i;
+var VERB_TO_METHODS = {
+  get: ["GET"],
+  put: ["PUT"],
+  delete: ["DELETE"]
+};
+var specName = (raw) => raw.replace(/-/g, "_");
+var shorthandField = (raw) => specName(raw).replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
+var specPlural = (name) => {
+  const parts = specName(name).split("_");
+  parts[parts.length - 1] = pluralize.plural(parts[parts.length - 1]);
+  return parts.join("_");
+};
+var inheritsChain = (name, typeByName) => {
+  const chain = [];
+  const seen = /* @__PURE__ */ new Set([name]);
+  let current = typeByName.get(name)?.inherits;
+  while (current !== void 0) {
+    if (current === "set" || current === "dictionary") break;
+    if (seen.has(current)) break;
+    seen.add(current);
+    chain.push(current);
+    current = typeByName.get(current)?.inherits;
+  }
+  return chain;
+};
+var parseSeedKey = (rowKey) => {
+  const m = /^id(\d+)$/.exec(rowKey);
+  if (!m) {
+    throw new Error(
+      `Invalid seed row key "${rowKey}": expected pattern /^id\\d+$/`
+    );
+  }
+  return Number(m[1]);
+};
+var seedCells = (node) => {
+  const rec = node.record;
+  if (rec === void 0) return {};
+  const out = {};
+  for (const key of Object.keys(rec)) {
+    const value = node.literal(key);
+    if (value !== void 0) out[key] = value;
+  }
+  return out;
+};
+var typeKind = (node) => {
+  if (node.str("inherits") !== void 0) return "inherit";
+  if (Array.isArray(node.child("union").value)) return "union";
+  return "shaped";
+};
+var mappingOf = (node) => {
+  const rec = node.child("mapping").record;
+  if (!rec) return void 0;
+  const out = {};
+  for (const [k, v] of Object.entries(rec)) {
+    if (typeof v === "string") out[k] = v;
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+};
+var referencesOf = (node) => {
+  const raw = node.child("references").value;
+  if (typeof raw === "string") return raw;
+  if (Array.isArray(raw) && raw.length === 2 && raw.every((v) => typeof v === "string")) {
+    return [raw[0], raw[1]];
+  }
+  return void 0;
+};
+var sizeOf = (node) => {
+  const raw = node.child("size").value;
+  if (raw === "unlimited") return "unlimited";
+  if (typeof raw === "number" && Number.isFinite(raw)) return raw;
+  if (Array.isArray(raw) && raw.length === 2 && raw.every((v) => typeof v === "number")) {
+    return [raw[0], raw[1]];
+  }
+  return void 0;
+};
+var DeterministicParser = (reader) => {
+  const parser = new Parser(reader);
+  return {
+    parse: (settings, opts) => parser.parse(settings, opts)
+  };
+};
+var Parser = class {
+  #reader;
+  constructor(reader) {
+    this.#reader = reader;
+  }
+  async parse(settings, opts) {
+    const reader = this.#reader;
+    const serviceClassName = opts?.serviceClassName ?? ((entity) => entity);
+    const [hasTypes, hasDs, hasSeeds, hasServices, hasRoutes] = await Promise.all([
+      reader.exists(TYPES_YAML),
+      reader.exists(DATASOURCE_YAML),
+      reader.exists(DATASOURCE_SEEDS_YAML),
+      reader.exists(SERVICES_YAML),
+      reader.exists(ROUTES_YAML)
+    ]);
+    const [typesYaml, datasourceYaml, seedsYaml, servicesYaml, routesYaml] = await Promise.all([
+      hasTypes ? reader.read(TYPES_YAML) : Promise.resolve(void 0),
+      hasDs ? reader.read(DATASOURCE_YAML) : Promise.resolve(void 0),
+      hasSeeds ? reader.read(DATASOURCE_SEEDS_YAML) : Promise.resolve(void 0),
+      hasServices ? reader.read(SERVICES_YAML) : Promise.resolve(void 0),
+      hasRoutes ? reader.read(ROUTES_YAML) : Promise.resolve(void 0)
+    ]);
+    const types = typesYaml !== void 0 ? this.#parseTypes(typesYaml) : [];
+    const expandedTypes = expandTypes(types);
+    const datasource = datasourceYaml !== void 0 ? this.#parseDatasource(datasourceYaml, expandedTypes) : [];
+    const seeds = seedsYaml !== void 0 ? this.#parseDatasourceSeeds(seedsYaml) : /* @__PURE__ */ new Map();
+    const services = servicesYaml !== void 0 ? this.#parseServices({
+      servicesYaml,
+      types: expandedTypes,
+      datasource,
+      routesYaml,
+      serviceClassName
+    }) : { generics: [], customs: [] };
+    const routes = routesYaml !== void 0 ? this.#parseRoutes({
+      routesYaml,
+      types: expandedTypes,
+      datasource
+    }) : {
+      candidates: [],
+      customs: [],
+      nested: [],
+      childrenOnly: /* @__PURE__ */ new Set(),
+      datasource
+    };
+    return ensureHealth(
+      new Deterministic({
+        types,
+        expandedTypes,
+        datasource,
+        datasourceSeeds: seeds,
+        services,
+        routes
+      })
+    );
+  }
+  #parseTypes(yaml) {
+    return YamlNode.fromYaml(yaml).namedList("types").map(({ name, node }) => {
+      const kind = typeKind(node);
+      const mapping = mappingOf(node);
+      const extract = node.strings("extract");
+      const removeFields = node.strings("remove_fields");
+      const ids = node.strings("ids");
+      return {
+        name,
+        tags: node.strings("tags"),
+        kind,
+        ...node.str("inherits") !== void 0 ? { inherits: node.str("inherits") } : {},
+        ...Array.isArray(node.child("union").value) ? { union: node.strings("union") } : {},
+        ...mapping ? { mapping } : {},
+        ...extract.length > 0 ? { extract } : {},
+        ...removeFields.length > 0 ? { removeFields } : {},
+        ...ids.length > 0 ? { ids } : {},
+        fields: node.namedList("fields").map(
+          ({ name: fname, node: fnode }) => this.#readField(fname, fnode)
+        )
+      };
+    });
+  }
+  #readField(name, node) {
+    const rawType = node.str("type") ?? "string";
+    const parsed = parseFieldType(rawType);
+    const references = referencesOf(node);
+    const size = sizeOf(node);
+    const minSize = node.finiteInt("min_size");
+    return {
+      name,
+      type: rawType,
+      kind: parsed.kind,
+      base: parsed.base,
+      isArray: parsed.isArray,
+      isMap: parsed.isMap,
+      isNullable: node.bool("is_nullable"),
+      ...node.bool("is_id") ? { isId: true } : {},
+      ...size !== void 0 ? { size } : {},
+      ...minSize !== void 0 ? { minSize } : {},
+      ...references !== void 0 ? { references } : {},
+      ...node.has("default_value") ? { hasDefault: true, defaultValue: node.literal("default_value") } : {}
+    };
+  }
+  #parseDatasource(yaml, types) {
+    const root = YamlNode.fromYaml(yaml);
+    const tables = root.namedList("types").map(({ name, node }) => {
+      const uniqueIndexFields = [];
+      const indexes = [];
+      for (const { name: indexName, node: indexBody } of node.namedList(
+        "indexes"
+      )) {
+        const rawFields = indexBody.child("fields").value;
+        const fields2 = Array.isArray(rawFields) ? rawFields.filter((f) => typeof f === "string") : [];
+        indexes.push({
+          name: indexName,
+          fields: fields2,
+          isUnique: indexBody.bool("is_unique")
+        });
+        if (indexBody.bool("is_unique") && fields2.length === 1 && fields2[0]) {
+          uniqueIndexFields.push(fields2[0]);
+        }
+      }
+      const fields = node.namedList("fields").map(({ name: fname, node: fnode }) => ({
+        name: fname,
+        ...fnode.has("is_readonly") ? { isReadonly: fnode.bool("is_readonly") } : {},
+        ...fnode.has("is_unique") ? { isUnique: fnode.bool("is_unique") } : {},
+        ...fnode.str("mapping") ? { mapping: fnode.str("mapping") } : {},
+        ...fnode.has("is_fixed_id") ? { isFixedId: fnode.bool("is_fixed_id") } : {},
+        ...fnode.has("is_optimistic_concurrency") ? {
+          isOptimisticConcurrency: fnode.bool(
+            "is_optimistic_concurrency"
+          )
+        } : {},
+        ...fnode.has("use_native_row_version") ? { useNativeRowVersion: fnode.bool("use_native_row_version") } : {}
+      }));
+      return {
+        name,
+        ...node.str("mapping") ? { mapping: node.str("mapping") } : {},
+        fields,
+        indexes,
+        uniqueIndexFields,
+        ...node.has("use_optimistic_concurrency") ? {
+          useOptimisticConcurrency: node.bool(
+            "use_optimistic_concurrency"
+          )
+        } : {}
+      };
+    });
+    const filter = this.#typesFilter(root);
+    if (!filter) return tables;
+    const selected = new Set(
+      types.filter((t) => filter(t)).map((t) => t.name)
+    );
+    const overlayNames = new Set(tables.map((t) => t.name));
+    const extras = types.filter((t) => selected.has(t.name) && !overlayNames.has(t.name)).map(
+      (t) => ({
+        name: t.name,
+        fields: [],
+        indexes: [],
+        uniqueIndexFields: []
+      })
+    );
+    return [...tables.filter((t) => selected.has(t.name)), ...extras];
+  }
+  #parseDatasourceSeeds(yaml) {
+    const byTable = /* @__PURE__ */ new Map();
+    for (const { name, node } of YamlNode.fromYaml(yaml).namedList("seeds")) {
+      byTable.set(
+        name,
+        node.namedItems().map(({ name: rowKey, node: row }) => ({
+          id: parseSeedKey(rowKey),
+          row: seedCells(row)
+        }))
+      );
+    }
+    return byTable;
+  }
+  #typesFilter(root) {
+    const block = this.#includeBlock(root, "types");
+    if (block === void 0) return void 0;
+    return compileTypesFilter(block.str("filter"));
+  }
+  #parseServices(args) {
+    const root = YamlNode.fromYaml(args.servicesYaml);
+    const rawServices = root.child("services").items().flatMap((entry) => {
+      const name = entry.str("name");
+      if (name === void 0) return [];
+      return [{ name, module: entry.str("module") }];
+    });
+    const customEntries = rawServices.filter(
+      (s) => !(typeof s.module === "string" && s.module.startsWith("./services/generated/"))
+    );
+    const explicitCustomNames = new Set(customEntries.map((s) => s.name));
+    const methodsByService = this.#collectRouteServiceMethods(args.routesYaml);
+    const dsByName = new Map(args.datasource.map((d) => [d.name, d]));
+    const predicate = this.#typesFilter(root);
+    let generics = [];
+    if (predicate !== void 0) {
+      const compare = compareByDatasourceTypeOrder(
+        args.types,
+        (name) => args.types.find((t) => t.name === name)?.inherits
+      );
+      generics = args.types.filter((t) => predicate(t)).filter((t) => !explicitCustomNames.has(args.serviceClassName(t.name))).sort((a, b) => compare(a.name, b.name)).map((t) => ({
+        name: t.name,
+        tags: t.tags,
+        inherits: t.inherits,
+        byFields: uniqueLookupFields(t, dsByName.get(t.name))
+      }));
+    }
+    const customs = customEntries.map((entry) => ({
+      name: entry.name,
+      module: entry.module,
+      methods: [...methodsByService.get(entry.name) ?? []].sort()
+    }));
+    return { generics, customs };
+  }
+  #parseRoutes(args) {
+    const root = YamlNode.fromYaml(args.routesYaml);
+    const dsByName = new Map(args.datasource.map((d) => [d.name, d]));
+    const typeByName = new Map(args.types.map((t) => [t.name, t]));
+    const overlays = this.#entityOverlays(root);
+    const allCandidates = args.types.map((t) => {
+      const overlay = overlays.get(t.name);
+      return {
+        name: t.name,
+        tags: t.tags,
+        inherits: t.inherits,
+        byFields: [],
+        ...overlay?.eagerReadPath ? { eagerReadPath: overlay.eagerReadPath } : {},
+        ...overlay?.eagerUpdatePath ? { eagerUpdatePath: overlay.eagerUpdatePath } : {},
+        ...overlay?.eagerReadMemberOnly ? { eagerReadMemberOnly: overlay.eagerReadMemberOnly } : {}
+      };
+    });
+    const childrenOnly = this.#collectCombinedChildNames(root, typeByName);
+    this.#attachByFields(allCandidates, root, dsByName, typeByName);
+    const customs = this.#extractCustomRoutes(root, dsByName, typeByName);
+    const nested = this.#collectNestedDescriptors(root, typeByName);
+    const predicate = this.#typesFilter(root);
+    let candidates = [];
+    if (predicate !== void 0) {
+      const compare = compareByDatasourceTypeOrder(
+        args.types,
+        (name) => typeByName.get(name)?.inherits
+      );
+      candidates = allCandidates.filter((c) => predicate({
+        name: c.name,
+        tags: c.tags,
+        inherits: c.inherits
+      })).filter((c) => !childrenOnly.has(c.name)).sort((a, b) => compare(a.name, b.name));
+    }
+    return {
+      candidates,
+      customs,
+      nested,
+      childrenOnly,
+      datasource: args.datasource
+    };
+  }
+  #entityOverlays(root) {
+    const out = /* @__PURE__ */ new Map();
+    for (const { name, node } of root.namedList("routes")) {
+      const read = node.strings("eager_read_path");
+      const update = node.strings("eager_update_path");
+      const member = node.strings("eager_read_member_only");
+      if (read.length + update.length + member.length === 0) continue;
+      out.set(name, {
+        ...read.length > 0 ? { eagerReadPath: read } : {},
+        ...update.length > 0 ? { eagerUpdatePath: update } : {},
+        ...member.length > 0 ? { eagerReadMemberOnly: member } : {}
+      });
+    }
+    return out;
+  }
+  #includeBlock(root, key) {
+    for (const entry of root.child("includes").items()) {
+      if (entry.child(key).record !== void 0) return entry.child(key);
+    }
+    return void 0;
+  }
+  #collectRouteServiceMethods(routesYaml) {
+    const byService = /* @__PURE__ */ new Map();
+    if (routesYaml === void 0) return byService;
+    const root = YamlNode.fromYaml(routesYaml);
+    const visit = (node) => {
+      if (Array.isArray(node.value)) {
+        for (const item of node.items()) visit(item);
+        return;
+      }
+      if (node.record === void 0) return;
+      const service = node.str("service");
+      const fn = node.str("function");
+      if (service !== void 0 && fn !== void 0) {
+        const set = byService.get(service) ?? /* @__PURE__ */ new Set();
+        set.add(fn);
+        byService.set(service, set);
+      }
+      for (const key of Object.keys(node.record)) visit(node.child(key));
+    };
+    visit(root.child("routes"));
+    visit(root.child("combined_routes"));
+    return byService;
+  }
+  #defaultParentBasePath(parentName) {
+    return `/api/${specPlural(parentName)}/{id}`;
+  }
+  #segmentTailOf(segment) {
+    return segment.split("/").filter(Boolean).pop() ?? "";
+  }
+  #defaultChildSegment(name) {
+    return `/${specPlural(name)}`;
+  }
+  #columnIsUnique(table, type, columnName) {
+    if (columnName === primaryKeyColumn(table, type)) return true;
+    if (table?.fields.some((f) => f.name === columnName && f.isUnique)) {
+      return true;
+    }
+    return table?.uniqueIndexFields.includes(columnName) ?? false;
+  }
+  #singularizeLastToken(snakePlural) {
+    const parts = snakePlural.split("_");
+    parts[parts.length - 1] = pluralize.singular(parts[parts.length - 1]);
+    return parts.join("_");
+  }
+  #entityHasField(type, fieldName) {
+    if (fieldName === "id") return true;
+    return type.fields.some((f) => f.name === fieldName);
+  }
+  #parseVerb(token) {
+    const verbMatch = SHORTHAND_VERB_RE.exec(token);
+    if (!verbMatch) return { methods: null, body: token };
+    return {
+      methods: VERB_TO_METHODS[verbMatch[1].toLowerCase()],
+      body: token.slice(verbMatch[0].length)
+    };
+  }
+  #splitEntityField(token, body) {
+    const splitIdx = body.lastIndexOf("_by_");
+    if (splitIdx < 0) {
+      throw new Error(
+        `parseByFieldEntry: route key \`${token}\` is missing \`_by_\` separator`
+      );
+    }
+    const pluralSnake = body.slice(0, splitIdx);
+    const fieldToken = body.slice(splitIdx + "_by_".length);
+    if (!pluralSnake || !fieldToken) {
+      throw new Error(
+        `parseByFieldEntry: route key \`${token}\` has empty entity or field around \`_by_\``
+      );
+    }
+    return {
+      entity: this.#singularizeLastToken(pluralSnake),
+      byField: shorthandField(fieldToken)
+    };
+  }
+  #parseShorthandByField(token, typeByName) {
+    if (typeof token !== "string" || token.length === 0) {
+      throw new Error("parseByFieldEntry: expected non-empty string token");
+    }
+    const { methods, body } = this.#parseVerb(token);
+    const { entity, byField } = this.#splitEntityField(token, body);
+    const type = typeByName.get(entity);
+    if (type === void 0) {
+      throw new Error(
+        `parseByFieldEntry: unknown entity \`${entity}\` in route \`${token}\``
+      );
+    }
+    if (!this.#entityHasField(type, byField)) {
+      throw new Error(
+        `parseByFieldEntry: field \`${byField}\` not found on entity \`${entity}\` in route \`${token}\``
+      );
+    }
+    return { entity, byField, methods };
+  }
+  #parseVerboseByField(key, def) {
+    if (typeof def.entity !== "string" || typeof def.byField !== "string") {
+      throw new Error(
+        `parseByFieldEntry: route \`${key}\` has non-string entity/byField`
+      );
+    }
+    return {
+      entity: def.entity,
+      byField: def.byField,
+      methods: Array.isArray(def.methods) ? def.methods : null
+    };
+  }
+  #parseByFieldEntry(entry, typeByName) {
+    if (entry == null) return null;
+    if (typeof entry === "string") {
+      return this.#parseShorthandByField(entry, typeByName);
+    }
+    if (!isRecord(entry)) return null;
+    const pairs = Object.entries(entry);
+    if (pairs.length === 0) return null;
+    const [key, def] = pairs[0];
+    if (def == null) {
+      return this.#parseShorthandByField(key, typeByName);
+    }
+    if (!isRecord(def)) return null;
+    if ("entity" in def && "byField" in def) {
+      return this.#parseVerboseByField(key, def);
+    }
+    return null;
+  }
+  #refParent(references) {
+    if (typeof references !== "string") return null;
+    return references.split(".")[0];
+  }
+  #inheritsChain(name, typeByName) {
+    return inheritsChain(name, typeByName);
+  }
+  #refMatchesParent(target, parent, typeByName) {
+    return parent === target || this.#inheritsChain(parent, typeByName).includes(target);
+  }
+  #fkFields(type, typeByName) {
+    const fields = [...type.fields];
+    for (const ancestor of this.#inheritsChain(type.name, typeByName)) {
+      fields.push(...typeByName.get(ancestor)?.fields ?? []);
+    }
+    return fields;
+  }
+  #findForeignKeyTo(child, parentName, typeByName) {
+    for (const field of this.#fkFields(child, typeByName)) {
+      const target = this.#refParent(field.references);
+      if (target !== null && this.#refMatchesParent(target, parentName, typeByName)) {
+        return field.name;
+      }
+    }
+    return null;
+  }
+  #collectCombinedChildNames(root, typeByName) {
+    const childrenOnly = /* @__PURE__ */ new Set();
+    const parents = new Set(
+      root.namedList("combined_routes").map((e) => e.name)
+    );
+    for (const { name: parentName, node } of root.namedList("combined_routes")) {
+      const def = node.record;
+      for (const child of def?.combines ?? []) {
+        let childName;
+        if (typeof child === "string") {
+          childName = specName(child);
+        } else {
+          const [rawName, childDef] = Object.entries(child)[0];
+          if (childDef && (childDef.via || childDef.target)) continue;
+          childName = specName(rawName);
+        }
+        if (parents.has(childName)) continue;
+        const childType = typeByName.get(childName);
+        if (childType !== void 0 && this.#findForeignKeyTo(childType, parentName, typeByName) !== null) {
+          childrenOnly.add(childName);
+        }
+      }
+    }
+    return childrenOnly;
+  }
+  #upsertByField(list, parsed, dsByName, typeByName) {
+    const existing = list.find((e) => e.byField === parsed.byField);
+    if (existing) {
+      if (existing.methods === void 0 || parsed.methods === null) {
+        existing.methods = void 0;
+      } else if (Array.isArray(parsed.methods)) {
+        const union = [...existing.methods];
+        for (const m of parsed.methods) {
+          if (!union.includes(m)) union.push(m);
+        }
+        existing.methods = union;
+      }
+      return;
+    }
+    list.push({
+      byField: parsed.byField,
+      methods: Array.isArray(parsed.methods) ? parsed.methods : void 0,
+      byFieldUnique: this.#columnIsUnique(
+        dsByName.get(parsed.entity),
+        typeByName.get(parsed.entity),
+        parsed.byField
+      )
+    });
+  }
+  #attachByFields(candidates, root, dsByName, typeByName) {
+    const byFieldByEntity = /* @__PURE__ */ new Map();
+    for (const entry of root.child("routes").items()) {
+      const parsed = this.#parseByFieldEntry(entry.value, typeByName);
+      if (parsed === null) continue;
+      if (!byFieldByEntity.has(parsed.entity)) {
+        byFieldByEntity.set(parsed.entity, []);
+      }
+      this.#upsertByField(
+        byFieldByEntity.get(parsed.entity),
+        parsed,
+        dsByName,
+        typeByName
+      );
+    }
+    for (const candidate of candidates) {
+      const list = byFieldByEntity.get(candidate.name);
+      if (list !== void 0 && list.length > 0) {
+        candidate.byFields = list;
+      }
+    }
+  }
+  #extractCustomRoutes(root, dsByName, typeByName) {
+    const customs = [];
+    for (const entry of root.child("routes").items()) {
+      if (entry.record === void 0) continue;
+      if (this.#parseByFieldEntry(entry.value, typeByName) !== null) continue;
+      const [name] = Object.keys(entry.record);
+      if (name === void 0) continue;
+      const node = entry.child(name);
+      if (node.has("eager_read_path") || node.has("eager_update_path") || node.has("eager_read_member_only")) {
+        continue;
+      }
+      if (node.str("path") === void 0) continue;
+      customs.push({
+        name,
+        path: node.str("path"),
+        method: node.str("method"),
+        entity: node.str("entity") ?? null,
+        request: node.str("request"),
+        response: node.str("response"),
+        module: node.str("module"),
+        routeClass: node.str("routeClass")
+      });
+    }
+    return customs;
+  }
+  #normalizeCombinedChild(child) {
+    if (typeof child === "string") {
+      return {
+        name: specName(child),
+        via: null,
+        target: null,
+        route: null
+      };
+    }
+    const [rawName, def] = Object.entries(child)[0];
+    return {
+      name: specName(rawName),
+      via: def && typeof def.via === "string" ? def.via : null,
+      target: def && typeof def.target === "string" ? def.target : null,
+      route: def && typeof def.route === "string" ? def.route : null
+    };
+  }
+  #detectJunction(parentName, childName, typeByName) {
+    const matches = [];
+    for (const [name, def] of typeByName) {
+      if (name === parentName || name === childName) continue;
+      if (!def.tags.includes("many_to_many")) continue;
+      const parentFk = this.#findForeignKeyTo(def, parentName, typeByName);
+      const childFk = this.#findForeignKeyTo(def, childName, typeByName);
+      if (parentFk !== null && childFk !== null) {
+        matches.push({ name, parentFk, childFk });
+      }
+    }
+    if (matches.length === 0) return null;
+    if (matches.length > 1) {
+      const candidates = matches.map((m) => m.name).join(", ");
+      throw new Error(
+        `combined_routes: ambiguous junction between "${parentName}" and "${childName}" \u2014 candidates: ${candidates}. Add via: to disambiguate.`
+      );
+    }
+    return matches[0];
+  }
+  #m2mDescriptor(parentName, parentBasePath, args) {
+    const segment = args.route ?? this.#defaultChildSegment(args.target);
+    return {
+      kind: "m2m",
+      parent: parentName,
+      parentBasePath,
+      parentParam: parentName,
+      junction: args.junction,
+      target: args.target,
+      targetParam: args.target,
+      parentFkField: args.parentFkField,
+      childFkField: args.childFkField,
+      segment,
+      segmentTail: this.#segmentTailOf(segment)
+    };
+  }
+  #directFkDescriptor(parentName, parentBasePath, args) {
+    const segment = args.route ?? this.#defaultChildSegment(args.childName);
+    return {
+      kind: "direct-fk",
+      parent: parentName,
+      parentBasePath,
+      parentParam: parentName,
+      child: { name: args.childName },
+      fkColumn: args.fkColumn,
+      segment,
+      segmentTail: this.#segmentTailOf(segment)
+    };
+  }
+  #collectNestedDescriptors(root, typeByName) {
+    const nested = [];
+    for (const { name: parentName, node } of root.namedList("combined_routes")) {
+      const def = node.record ?? {};
+      const parentBasePath = typeof def.route === "string" && def.route.length > 0 ? def.route : this.#defaultParentBasePath(parentName);
+      for (const rawChild of def.combines ?? []) {
+        const child = this.#normalizeCombinedChild(rawChild);
+        if (child.via || child.target) {
+          const junctionName = child.via;
+          const targetName = child.target;
+          if (!junctionName || !targetName) {
+            throw new Error(
+              `combined_routes: M2M child must declare both via: and target: (parent=${parentName}, child=${child.name})`
+            );
+          }
+          const junctionDef = typeByName.get(junctionName);
+          if (junctionDef === void 0) {
+            throw new Error(
+              `combined_routes: junction "${junctionName}" not found in types.yaml`
+            );
+          }
+          const parentFkField = this.#findForeignKeyTo(
+            junctionDef,
+            parentName,
+            typeByName
+          );
+          const childFkField = this.#findForeignKeyTo(
+            junctionDef,
+            targetName,
+            typeByName
+          );
+          if (parentFkField === null || childFkField === null) {
+            throw new Error(
+              `combined_routes: junction "${junctionName}" missing FK to ${parentName}/${targetName}`
+            );
+          }
+          nested.push(
+            this.#m2mDescriptor(parentName, parentBasePath, {
+              junction: junctionName,
+              target: targetName,
+              parentFkField,
+              childFkField,
+              route: child.route
+            })
+          );
+          continue;
+        }
+        const childDef = typeByName.get(child.name);
+        if (childDef === void 0) {
+          throw new Error(
+            `combined_routes: child "${child.name}" not found in types.yaml`
+          );
+        }
+        const fkColumn = this.#findForeignKeyTo(
+          childDef,
+          parentName,
+          typeByName
+        );
+        if (fkColumn !== null) {
+          nested.push(
+            this.#directFkDescriptor(parentName, parentBasePath, {
+              childName: child.name,
+              fkColumn,
+              route: child.route
+            })
+          );
+          continue;
+        }
+        const junction = this.#detectJunction(parentName, child.name, typeByName);
+        if (junction !== null) {
+          nested.push(
+            this.#m2mDescriptor(parentName, parentBasePath, {
+              junction: junction.name,
+              target: child.name,
+              parentFkField: junction.parentFk,
+              childFkField: junction.childFk,
+              route: child.route
+            })
+          );
+          continue;
+        }
+        throw new Error(
+          `combined_routes: child "${child.name}" has no FK to parent "${parentName}" and no detectable junction table in types.yaml`
+        );
+      }
+    }
+    return nested;
+  }
+};
+export {
+  DeterministicParser
+};