@kurotako/ir 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1006 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CompositeUniqueSchema: () => CompositeUniqueSchema,
+  ConstraintsSchema: () => ConstraintsSchema,
+  DefaultValueSchema: () => DefaultValueSchema,
+  EntitySchema: () => EntitySchema,
+  EnumDefSchema: () => EnumDefSchema,
+  EnumValueSchema: () => EnumValueSchema,
+  FieldSchema: () => FieldSchema,
+  FieldTypeSchema: () => FieldTypeSchema,
+  IR_VERSION: () => IR_VERSION,
+  IndexDefSchema: () => IndexDefSchema,
+  IndexTypeSchema: () => IndexTypeSchema,
+  IrBuildError: () => IrBuildError,
+  IrSchema: () => IrSchema,
+  IrValidationError: () => IrValidationError,
+  JsonValueSchema: () => JsonValueSchema,
+  ReferentialActionSchema: () => ReferentialActionSchema,
+  RelationSchema: () => RelationSchema,
+  RelationTargetSchema: () => RelationTargetSchema,
+  ScalarTypeSchema: () => ScalarTypeSchema,
+  SourceIrSchema: () => SourceIrSchema,
+  StringFormatSchema: () => StringFormatSchema,
+  assertIR: () => assertIR,
+  assertSourceIR: () => assertSourceIR,
+  createFields: () => createFields,
+  createSourceIR: () => createSourceIR,
+  getSource: () => getSource,
+  isCompatible: () => isCompatible,
+  isCreateOptional: () => isCreateOptional,
+  isCrossSource: () => isCrossSource,
+  isDbAssigned: () => isDbAssigned,
+  iterEntities: () => iterEntities,
+  iterFields: () => iterFields,
+  parseIR: () => parseIR,
+  primaryKeyFields: () => primaryKeyFields,
+  resolveEntity: () => resolveEntity,
+  resolveEnum: () => resolveEnum,
+  resolveRelationTarget: () => resolveRelationTarget,
+  scalarTsType: () => scalarTsType,
+  updateFields: () => updateFields,
+  validateIR: () => validateIR,
+  validateSourceIR: () => validateSourceIR
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/builder.ts
+var v3 = __toESM(require("valibot"), 1);
+
+// src/schemas.ts
+var v = __toESM(require("valibot"), 1);
+var JsonValueSchema = v.lazy(
+  () => v.union([
+    v.null(),
+    v.boolean(),
+    v.number(),
+    v.string(),
+    v.array(JsonValueSchema),
+    v.record(v.string(), JsonValueSchema)
+  ])
+);
+var ScalarTypeSchema = v.picklist([
+  "string",
+  "boolean",
+  "int",
+  "bigint",
+  "float",
+  "decimal",
+  "date",
+  "datetime",
+  "uuid",
+  "bytes",
+  "json"
+]);
+var StringFormatSchema = v.picklist([
+  "email",
+  "url",
+  "uuid",
+  "cuid",
+  "cuid2",
+  "ulid",
+  "datetime",
+  "date",
+  "time",
+  "duration",
+  "ipv4",
+  "ipv6"
+]);
+var ReferentialActionSchema = v.picklist([
+  "cascade",
+  "restrict",
+  "setNull",
+  "setDefault",
+  "noAction"
+]);
+var IndexTypeSchema = v.picklist([
+  "btree",
+  "hash",
+  "gin",
+  "gist",
+  "brin",
+  "spgist"
+]);
+var FieldTypeSchema = v.variant("kind", [
+  v.object({ kind: v.literal("scalar"), scalar: ScalarTypeSchema }),
+  v.object({ kind: v.literal("enum"), ref: v.string() }),
+  v.object({ kind: v.literal("unknown"), hint: v.optional(v.string()) })
+]);
+var ConstraintsSchema = v.object({
+  min: v.optional(v.number()),
+  max: v.optional(v.number()),
+  minLength: v.optional(v.number()),
+  maxLength: v.optional(v.number()),
+  regex: v.optional(v.string()),
+  format: v.optional(StringFormatSchema),
+  unique: v.optional(v.boolean())
+});
+var DefaultValueSchema = v.variant("kind", [
+  v.object({ kind: v.literal("value"), value: JsonValueSchema }),
+  v.object({
+    kind: v.literal("expr"),
+    expr: v.string(),
+    args: v.optional(v.array(JsonValueSchema))
+  })
+]);
+var FieldSchema = v.object({
+  name: v.string(),
+  type: FieldTypeSchema,
+  list: v.boolean(),
+  optional: v.boolean(),
+  nullable: v.boolean(),
+  constraints: ConstraintsSchema,
+  default: v.optional(DefaultValueSchema),
+  doc: v.optional(v.string()),
+  dbName: v.optional(v.string())
+});
+var RelationTargetSchema = v.object({
+  namespace: v.string(),
+  entity: v.string()
+});
+var RelationSchema = v.object({
+  name: v.string(),
+  target: RelationTargetSchema,
+  cardinality: v.picklist(["one", "many"]),
+  optional: v.boolean(),
+  owning: v.boolean(),
+  backRelation: v.optional(v.string()),
+  fkFields: v.optional(v.array(v.string())),
+  references: v.optional(v.array(v.string())),
+  onDelete: v.optional(ReferentialActionSchema),
+  onUpdate: v.optional(ReferentialActionSchema)
+});
+var EnumValueSchema = v.object({
+  name: v.string(),
+  dbName: v.optional(v.string()),
+  doc: v.optional(v.string())
+});
+var EnumDefSchema = v.object({
+  name: v.string(),
+  values: v.array(EnumValueSchema),
+  doc: v.optional(v.string()),
+  dbName: v.optional(v.string())
+});
+var IndexDefSchema = v.object({
+  fields: v.array(v.string()),
+  name: v.optional(v.string()),
+  type: v.optional(IndexTypeSchema)
+});
+var CompositeUniqueSchema = v.object({
+  fields: v.array(v.string()),
+  name: v.optional(v.string())
+});
+var EntitySchema = v.object({
+  name: v.string(),
+  fields: v.array(FieldSchema),
+  relations: v.array(RelationSchema),
+  enums: v.optional(v.record(v.string(), EnumDefSchema)),
+  primaryKey: v.optional(v.array(v.string())),
+  indexes: v.array(IndexDefSchema),
+  uniques: v.array(CompositeUniqueSchema),
+  doc: v.optional(v.string()),
+  dbName: v.optional(v.string())
+});
+var SourceIrSchema = v.object({
+  namespace: v.string(),
+  parser: v.string(),
+  parserVersion: v.optional(v.string()),
+  entities: v.record(v.string(), EntitySchema),
+  enums: v.record(v.string(), EnumDefSchema)
+});
+var IrSchema = v.object({
+  irVersion: v.string(),
+  sources: v.record(v.string(), SourceIrSchema)
+});
+
+// src/validate.ts
+var v2 = __toESM(require("valibot"), 1);
+
+// src/version.ts
+var IR_VERSION = "1";
+function isCompatible(irVersion) {
+  return irVersion === IR_VERSION;
+}
+
+// src/validate.ts
+var IrValidationError = class extends Error {
+  issues;
+  constructor(issues) {
+    const detail = issues.map((i) => `${i.path === "" ? "<root>" : i.path}: ${i.message}`).join("; ");
+    super(`invalid IR: ${detail}`);
+    this.name = "IrValidationError";
+    this.issues = issues;
+  }
+};
+function normaliseValibotIssues(issues) {
+  return issues.map((issue) => ({
+    path: v2.getDotPath(issue) ?? "",
+    code: "shape",
+    message: issue.message
+  }));
+}
+function pushIssue(issues, path, code, message) {
+  issues.push({ path, code, message });
+}
+function checkConstraints(issues, path, c) {
+  if (c.min !== void 0 && c.max !== void 0 && c.min > c.max) {
+    pushIssue(
+      issues,
+      path,
+      "invalid_constraint",
+      `min (${c.min}) is greater than max (${c.max})`
+    );
+  }
+  if (c.minLength !== void 0 && c.maxLength !== void 0 && c.minLength > c.maxLength) {
+    pushIssue(
+      issues,
+      path,
+      "invalid_constraint",
+      `minLength (${c.minLength}) is greater than maxLength (${c.maxLength})`
+    );
+  }
+  if (c.regex !== void 0) {
+    try {
+      new RegExp(c.regex);
+    } catch {
+      pushIssue(
+        issues,
+        path,
+        "invalid_regex",
+        `regex does not compile: ${c.regex}`
+      );
+    }
+  }
+}
+function checkEnumValues(issues, path, values) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    if (seen.has(value.name)) {
+      pushIssue(
+        issues,
+        `${path}.${value.name}`,
+        "duplicate_enum_value",
+        `duplicate enum value '${value.name}'`
+      );
+    }
+    seen.add(value.name);
+  }
+}
+function checkSource(namespace, source, lookupEntity, isNamespacePresent, issues) {
+  for (const [key, def] of Object.entries(source.enums)) {
+    if (def.name !== key) {
+      pushIssue(
+        issues,
+        `${namespace}.enums.${key}`,
+        "entity_key_mismatch",
+        `enum key '${key}' does not match enum name '${def.name}'`
+      );
+    }
+    checkEnumValues(issues, `${namespace}.enums.${key}`, def.values);
+  }
+  for (const [key, entity] of Object.entries(source.entities)) {
+    const ePath = `${namespace}.${key}`;
+    if (entity.name !== key) {
+      pushIssue(
+        issues,
+        ePath,
+        "entity_key_mismatch",
+        `entity key '${key}' does not match entity name '${entity.name}'`
+      );
+    }
+    const fieldNames = /* @__PURE__ */ new Set();
+    for (const field of entity.fields) {
+      const fPath = `${ePath}.${field.name}`;
+      if (fieldNames.has(field.name)) {
+        pushIssue(
+          issues,
+          fPath,
+          "duplicate_field",
+          `duplicate field '${field.name}'`
+        );
+      }
+      fieldNames.add(field.name);
+      checkConstraints(issues, `${fPath}.constraints`, field.constraints);
+      if (field.type.kind === "enum") {
+        const resolved = entity.enums?.[field.type.ref] ?? source.enums[field.type.ref];
+        if (resolved === void 0) {
+          pushIssue(
+            issues,
+            fPath,
+            "unresolved_enum_ref",
+            `field '${field.name}' references unknown enum '${field.type.ref}'`
+          );
+        }
+      }
+    }
+    for (const [localKey, def] of Object.entries(entity.enums ?? {})) {
+      if (def.name !== localKey) {
+        pushIssue(
+          issues,
+          `${ePath}.enums.${localKey}`,
+          "entity_key_mismatch",
+          `local enum key '${localKey}' does not match name '${def.name}'`
+        );
+      }
+      checkEnumValues(issues, `${ePath}.enums.${localKey}`, def.values);
+    }
+    const hasField = (name) => fieldNames.has(name);
+    for (const pk of entity.primaryKey ?? []) {
+      if (!hasField(pk)) {
+        pushIssue(
+          issues,
+          `${ePath}.primaryKey`,
+          "unresolved_field_ref",
+          `primaryKey references unknown field '${pk}'`
+        );
+      }
+    }
+    entity.indexes.forEach((idx, i) => {
+      for (const f of idx.fields) {
+        if (!hasField(f)) {
+          pushIssue(
+            issues,
+            `${ePath}.indexes.${i}`,
+            "unresolved_field_ref",
+            `index references unknown field '${f}'`
+          );
+        }
+      }
+    });
+    entity.uniques.forEach((u, i) => {
+      for (const f of u.fields) {
+        if (!hasField(f)) {
+          pushIssue(
+            issues,
+            `${ePath}.uniques.${i}`,
+            "unresolved_field_ref",
+            `unique references unknown field '${f}'`
+          );
+        }
+      }
+    });
+    entity.relations.forEach((rel, i) => {
+      const rPath = `${ePath}.relations.${rel.name === "" ? i : rel.name}`;
+      for (const fk of rel.fkFields ?? []) {
+        if (!hasField(fk)) {
+          pushIssue(
+            issues,
+            rPath,
+            "unresolved_field_ref",
+            `relation '${rel.name}' fkField references unknown field '${fk}'`
+          );
+        }
+      }
+      const targetNs = rel.target.namespace;
+      if (targetNs === "") {
+        return;
+      }
+      const sameNs = targetNs === namespace;
+      if (!sameNs && !isNamespacePresent(targetNs)) {
+        return;
+      }
+      const targetEntity = lookupEntity(targetNs, rel.target.entity);
+      if (targetEntity === void 0) {
+        pushIssue(
+          issues,
+          rPath,
+          "unresolved_relation_target",
+          `relation '${rel.name}' target ${targetNs}.${rel.target.entity} does not exist`
+        );
+        return;
+      }
+      if (rel.backRelation !== void 0 && !targetEntity.relations.some((r) => r.name === rel.backRelation)) {
+        pushIssue(
+          issues,
+          rPath,
+          "unresolved_back_relation",
+          `backRelation '${rel.backRelation}' not found on ${targetNs}.${rel.target.entity}`
+        );
+      }
+      for (const ref of rel.references ?? []) {
+        if (!targetEntity.fields.some((f) => f.name === ref)) {
+          pushIssue(
+            issues,
+            rPath,
+            "unresolved_field_ref",
+            `relation '${rel.name}' references unknown field '${ref}' on ${targetNs}.${rel.target.entity}`
+          );
+        }
+      }
+    });
+  }
+}
+function validateSourceIR(value) {
+  const parsed = v2.safeParse(SourceIrSchema, value);
+  if (!parsed.success) {
+    return { ok: false, issues: normaliseValibotIssues(parsed.issues) };
+  }
+  const source = parsed.output;
+  const issues = [];
+  const lookup = (ns, name) => ns === source.namespace ? source.entities[name] : void 0;
+  const isPresent = (ns) => ns === source.namespace;
+  checkSource(source.namespace, source, lookup, isPresent, issues);
+  return issues.length > 0 ? { ok: false, issues } : { ok: true, value: source };
+}
+function validateIR(value) {
+  const parsed = v2.safeParse(IrSchema, value);
+  if (!parsed.success) {
+    return { ok: false, issues: normaliseValibotIssues(parsed.issues) };
+  }
+  const ir = parsed.output;
+  const issues = [];
+  if (!isCompatible(ir.irVersion)) {
+    pushIssue(
+      issues,
+      "irVersion",
+      "version_incompatible",
+      `IR version '${ir.irVersion}' is not compatible with supported version '${IR_VERSION}'`
+    );
+  }
+  const lookup = (ns, name) => ir.sources[ns]?.entities[name];
+  const isPresent = (ns) => ns in ir.sources;
+  for (const [key, source] of Object.entries(ir.sources)) {
+    if (source.namespace !== key) {
+      pushIssue(
+        issues,
+        `sources.${key}`,
+        "namespace_key_mismatch",
+        `source key '${key}' does not match namespace '${source.namespace}'`
+      );
+    }
+    checkSource(source.namespace, source, lookup, isPresent, issues);
+  }
+  return issues.length > 0 ? { ok: false, issues } : { ok: true, value: ir };
+}
+function assertIR(value) {
+  const result = validateIR(value);
+  if (!result.ok) {
+    throw new IrValidationError(result.issues);
+  }
+}
+function assertSourceIR(value) {
+  const result = validateSourceIR(value);
+  if (!result.ok) {
+    throw new IrValidationError(result.issues);
+  }
+}
+function parseIR(json) {
+  const value = JSON.parse(json);
+  assertIR(value);
+  return value;
+}
+
+// src/builder.ts
+var IrBuildError = class extends Error {
+  path;
+  issues;
+  constructor(path, message, issues) {
+    super(`${path}: ${message}`);
+    this.name = "IrBuildError";
+    this.path = path;
+    this.issues = issues;
+  }
+};
+var EnumBuilderImpl = class {
+  #def;
+  constructor(name) {
+    this.#def = { name, values: [] };
+  }
+  value(name, opts) {
+    const entry = { name };
+    if (opts?.dbName !== void 0) {
+      entry.dbName = opts.dbName;
+    }
+    if (opts?.doc !== void 0) {
+      entry.doc = opts.doc;
+    }
+    this.#def.values.push(entry);
+    return this;
+  }
+  doc(text) {
+    this.#def.doc = text;
+    return this;
+  }
+  dbName(name) {
+    this.#def.dbName = name;
+    return this;
+  }
+  build() {
+    return this.#def;
+  }
+};
+var FieldBuilderImpl = class {
+  #path;
+  #field;
+  #onPrimary;
+  constructor(path, name, onPrimary) {
+    this.#path = path;
+    this.#onPrimary = onPrimary;
+    this.#field = {
+      name,
+      type: { kind: "unknown" },
+      list: false,
+      optional: false,
+      nullable: false,
+      constraints: {}
+    };
+  }
+  scalar(t) {
+    if (!v3.is(ScalarTypeSchema, t)) {
+      throw new IrBuildError(this.#path, `unknown scalar type '${t}'`);
+    }
+    this.#field.type = { kind: "scalar", scalar: t };
+    return this;
+  }
+  enum(ref) {
+    this.#field.type = { kind: "enum", ref };
+    return this;
+  }
+  unknown(hint) {
+    this.#field.type = hint === void 0 ? { kind: "unknown" } : { kind: "unknown", hint };
+    return this;
+  }
+  list() {
+    this.#field.list = true;
+    return this;
+  }
+  optional() {
+    this.#field.optional = true;
+    return this;
+  }
+  nullable() {
+    this.#field.nullable = true;
+    return this;
+  }
+  primary() {
+    if (this.#field.list) {
+      throw new IrBuildError(
+        this.#path,
+        "primary() cannot be used on a list field"
+      );
+    }
+    this.#onPrimary(this.#field.name);
+    return this;
+  }
+  unique() {
+    this.#field.constraints.unique = true;
+    return this;
+  }
+  min(n) {
+    this.#field.constraints.min = n;
+    return this;
+  }
+  max(n) {
+    this.#field.constraints.max = n;
+    return this;
+  }
+  minLength(n) {
+    this.#field.constraints.minLength = n;
+    return this;
+  }
+  maxLength(n) {
+    this.#field.constraints.maxLength = n;
+    return this;
+  }
+  regex(src) {
+    this.#field.constraints.regex = src;
+    return this;
+  }
+  format(f) {
+    if (this.#field.type.kind !== "scalar" || this.#field.type.scalar !== "string") {
+      throw new IrBuildError(
+        this.#path,
+        "format() requires a string scalar field"
+      );
+    }
+    this.#field.constraints.format = f;
+    return this;
+  }
+  default(d) {
+    this.#field.default = d;
+    return this;
+  }
+  doc(text) {
+    this.#field.doc = text;
+    return this;
+  }
+  dbName(name) {
+    this.#field.dbName = name;
+    return this;
+  }
+  build() {
+    return this.#field;
+  }
+};
+var RelationBuilderImpl = class {
+  #rel;
+  constructor(name) {
+    this.#rel = {
+      name,
+      target: { namespace: "", entity: "" },
+      cardinality: "one",
+      optional: false,
+      owning: false
+    };
+  }
+  to(namespace, entity) {
+    this.#rel.target = { namespace, entity };
+    return this;
+  }
+  one() {
+    this.#rel.cardinality = "one";
+    return this;
+  }
+  many() {
+    this.#rel.cardinality = "many";
+    return this;
+  }
+  optional() {
+    this.#rel.optional = true;
+    return this;
+  }
+  owning() {
+    this.#rel.owning = true;
+    return this;
+  }
+  backRelation(name) {
+    this.#rel.backRelation = name;
+    return this;
+  }
+  fkFields(...fields) {
+    this.#rel.fkFields = fields;
+    return this;
+  }
+  references(...fields) {
+    this.#rel.references = fields;
+    return this;
+  }
+  onDelete(action) {
+    this.#rel.onDelete = action;
+    return this;
+  }
+  onUpdate(action) {
+    this.#rel.onUpdate = action;
+    return this;
+  }
+  build() {
+    return this.#rel;
+  }
+};
+var EntityBuilderImpl = class {
+  #namespace;
+  #name;
+  #fields = [];
+  #fieldNames = /* @__PURE__ */ new Set();
+  #relations = [];
+  #localEnums = {};
+  #primaryKey = [];
+  #indexes = [];
+  #uniques = [];
+  #doc;
+  #dbName;
+  constructor(namespace, name) {
+    this.#namespace = namespace;
+    this.#name = name;
+  }
+  #addPrimary(field) {
+    if (!this.#primaryKey.includes(field)) {
+      this.#primaryKey.push(field);
+    }
+  }
+  field(name, def) {
+    if (this.#fieldNames.has(name)) {
+      throw new IrBuildError(
+        `${this.#namespace}.${this.#name}.${name}`,
+        `duplicate field '${name}'`
+      );
+    }
+    this.#fieldNames.add(name);
+    const builder = new FieldBuilderImpl(
+      `${this.#namespace}.${this.#name}.${name}`,
+      name,
+      (pk) => this.#addPrimary(pk)
+    );
+    def(builder);
+    this.#fields.push(builder);
+    return this;
+  }
+  relation(name, def) {
+    const builder = new RelationBuilderImpl(name);
+    def(builder);
+    this.#relations.push(builder);
+    return this;
+  }
+  localEnum(name, def) {
+    const builder = new EnumBuilderImpl(name);
+    def(builder);
+    this.#localEnums[name] = builder.build();
+    return this;
+  }
+  primaryKey(...fields) {
+    for (const field of fields) {
+      this.#addPrimary(field);
+    }
+    return this;
+  }
+  index(fields, opts) {
+    const idx = { fields };
+    if (opts?.name !== void 0) {
+      idx.name = opts.name;
+    }
+    if (opts?.type !== void 0) {
+      idx.type = opts.type;
+    }
+    this.#indexes.push(idx);
+    return this;
+  }
+  unique(fields, opts) {
+    const entry = { fields };
+    if (opts?.name !== void 0) {
+      entry.name = opts.name;
+    }
+    this.#uniques.push(entry);
+    return this;
+  }
+  doc(text) {
+    this.#doc = text;
+    return this;
+  }
+  dbName(name) {
+    this.#dbName = name;
+    return this;
+  }
+  build() {
+    const entity = {
+      name: this.#name,
+      fields: this.#fields.map((f) => f.build()),
+      relations: this.#relations.map((r) => r.build()),
+      indexes: this.#indexes,
+      uniques: this.#uniques
+    };
+    if (Object.keys(this.#localEnums).length > 0) {
+      entity.enums = this.#localEnums;
+    }
+    if (this.#primaryKey.length > 0) {
+      entity.primaryKey = this.#primaryKey;
+    }
+    if (this.#doc !== void 0) {
+      entity.doc = this.#doc;
+    }
+    if (this.#dbName !== void 0) {
+      entity.dbName = this.#dbName;
+    }
+    return entity;
+  }
+};
+var SourceIrBuilderImpl = class {
+  #namespace;
+  #parser;
+  #parserVersion;
+  #entities = [];
+  #entityNames = /* @__PURE__ */ new Set();
+  #enums = {};
+  constructor(init) {
+    this.#namespace = init.namespace;
+    this.#parser = init.parser;
+    this.#parserVersion = init.parserVersion;
+  }
+  addEnum(name, def) {
+    const builder = new EnumBuilderImpl(name);
+    def(builder);
+    this.#enums[name] = builder.build();
+    return this;
+  }
+  addEntity(name, def) {
+    if (this.#entityNames.has(name)) {
+      throw new IrBuildError(
+        `${this.#namespace}.${name}`,
+        `duplicate entity '${name}'`
+      );
+    }
+    this.#entityNames.add(name);
+    const builder = new EntityBuilderImpl(this.#namespace, name);
+    def(builder);
+    this.#entities.push(builder);
+    return this;
+  }
+  build() {
+    const source = {
+      namespace: this.#namespace,
+      parser: this.#parser,
+      entities: Object.fromEntries(
+        this.#entities.map((e) => {
+          const built = e.build();
+          return [built.name, built];
+        })
+      ),
+      enums: this.#enums
+    };
+    if (this.#parserVersion !== void 0) {
+      source.parserVersion = this.#parserVersion;
+    }
+    try {
+      assertSourceIR(source);
+    } catch (err) {
+      if (err instanceof IrValidationError) {
+        const first = err.issues[0];
+        throw new IrBuildError(
+          first?.path ?? this.#namespace,
+          first?.message ?? "invalid SourceIR",
+          err.issues
+        );
+      }
+      throw err;
+    }
+    return source;
+  }
+};
+function createSourceIR(init) {
+  return new SourceIrBuilderImpl(init);
+}
+
+// src/helpers.ts
+function getSource(ir, namespace) {
+  return ir.sources[namespace];
+}
+function resolveEntity(ir, namespace, name) {
+  return ir.sources[namespace]?.entities[name];
+}
+function resolveEnum(source, entity, ref) {
+  return entity?.enums?.[ref] ?? source.enums[ref];
+}
+function isCrossSource(fromNamespace, rel) {
+  return rel.target.namespace !== fromNamespace;
+}
+function resolveRelationTarget(ir, fromNamespace, rel) {
+  const ns = isCrossSource(fromNamespace, rel) ? rel.target.namespace : fromNamespace;
+  return ir.sources[ns]?.entities[rel.target.entity];
+}
+function* iterEntities(ir) {
+  for (const [namespace, source] of Object.entries(ir.sources)) {
+    for (const entity of Object.values(source.entities)) {
+      yield { namespace, entity };
+    }
+  }
+}
+function* iterFields(entity) {
+  yield* entity.fields;
+}
+function primaryKeyFields(entity) {
+  const pk = entity.primaryKey;
+  if (pk === void 0) {
+    return [];
+  }
+  const byName = new Map(entity.fields.map((f) => [f.name, f]));
+  const out = [];
+  for (const name of pk) {
+    const field = byName.get(name);
+    if (field !== void 0) {
+      out.push(field);
+    }
+  }
+  return out;
+}
+function isDbAssigned(field) {
+  return field.default?.kind === "expr";
+}
+function createFields(entity) {
+  const pk = new Set(entity.primaryKey ?? []);
+  return entity.fields.filter(
+    (field) => !(pk.has(field.name) && isDbAssigned(field))
+  );
+}
+function isCreateOptional(field) {
+  return field.optional || field.default !== void 0 || isDbAssigned(field);
+}
+function updateFields(entity) {
+  const pk = new Set(entity.primaryKey ?? []);
+  return entity.fields.filter((field) => !pk.has(field.name));
+}
+function scalarTsType(type) {
+  switch (type.kind) {
+    case "enum":
+      return type.ref;
+    case "unknown":
+      return "unknown";
+    case "scalar":
+      return mapScalar(type.scalar);
+  }
+}
+function mapScalar(scalar) {
+  switch (scalar) {
+    case "string":
+    case "uuid":
+    case "decimal":
+      return "string";
+    case "boolean":
+      return "boolean";
+    case "int":
+    case "float":
+      return "number";
+    case "bigint":
+      return "bigint";
+    case "date":
+    case "datetime":
+      return "Date";
+    case "bytes":
+      return "Uint8Array";
+    case "json":
+      return "JsonValue";
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CompositeUniqueSchema,
+  ConstraintsSchema,
+  DefaultValueSchema,
+  EntitySchema,
+  EnumDefSchema,
+  EnumValueSchema,
+  FieldSchema,
+  FieldTypeSchema,
+  IR_VERSION,
+  IndexDefSchema,
+  IndexTypeSchema,
+  IrBuildError,
+  IrSchema,
+  IrValidationError,
+  JsonValueSchema,
+  ReferentialActionSchema,
+  RelationSchema,
+  RelationTargetSchema,
+  ScalarTypeSchema,
+  SourceIrSchema,
+  StringFormatSchema,
+  assertIR,
+  assertSourceIR,
+  createFields,
+  createSourceIR,
+  getSource,
+  isCompatible,
+  isCreateOptional,
+  isCrossSource,
+  isDbAssigned,
+  iterEntities,
+  iterFields,
+  parseIR,
+  primaryKeyFields,
+  resolveEntity,
+  resolveEnum,
+  resolveRelationTarget,
+  scalarTsType,
+  updateFields,
+  validateIR,
+  validateSourceIR
+});
+//# sourceMappingURL=index.cjs.map