@kurotako/parser-prisma 0.1.0

package/dist/index.cjs

@@ -0,0 +1,879 @@
+"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, {
+  PrismaInputError: () => PrismaInputError,
+  PrismaParserOptions: () => PrismaParserOptions,
+  PrismaPeerMissingError: () => PrismaPeerMissingError,
+  PrismaSchemaError: () => PrismaSchemaError,
+  prismaParser: () => prismaParser
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var import_core = require("@kurotako/core");
+var PrismaInputError = class extends import_core.TakoError {
+  namespace;
+  resolvedPath;
+  constructor(namespace, resolvedPath, detail) {
+    super(
+      "prisma_input",
+      `prisma parser (namespace '${namespace}'): ${detail} (resolved path: ${resolvedPath})`
+    );
+    this.namespace = namespace;
+    this.resolvedPath = resolvedPath;
+  }
+};
+var PrismaPeerMissingError = class extends import_core.TakoError {
+  namespace;
+  constructor(namespace, options) {
+    super(
+      "prisma_peer_missing",
+      `prisma parser (namespace '${namespace}'): '@prisma/internals' could not be resolved. Add it as a devDependency (\`bun add -d @prisma/internals\`, matching your Prisma major). In a monorepo it is resolved from the directory holding the schema, so it may be installed in the sub-project that owns the schema rather than at the repo root. Note: installing it pulls @prisma/engines, whose postinstall downloads a schema-engine binary.`,
+      options
+    );
+    this.namespace = namespace;
+  }
+};
+var PrismaSchemaError = class extends import_core.TakoError {
+  namespace;
+  prismaMessage;
+  constructor(namespace, prismaMessage, options) {
+    super(
+      "prisma_schema",
+      `prisma parser (namespace '${namespace}'): the Prisma schema is invalid:
+${prismaMessage}`,
+      options
+    );
+    this.namespace = namespace;
+    this.prismaMessage = prismaMessage;
+  }
+};
+
+// src/options.ts
+var v = __toESM(require("valibot"), 1);
+var PrismaParserOptions = v.strictObject({
+  schema: v.optional(v.string(), "./prisma/schema.prisma"),
+  version: v.optional(v.picklist([7, 8]))
+});
+
+// src/parser.ts
+var import_node_path3 = require("path");
+var import_config = require("@kurotako/config");
+
+// src/detect.ts
+var import_promises = require("fs/promises");
+var import_node_path = require("path");
+var PRISMA_EXT = ".prisma";
+var CONTRACT_FILE = "contract.json";
+function toPosix(p) {
+  return import_node_path.sep === "/" ? p : p.split(import_node_path.sep).join("/");
+}
+async function pathKind(p) {
+  try {
+    const s = await (0, import_promises.stat)(p);
+    return s.isDirectory() ? "dir" : "file";
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return "missing";
+    }
+    throw err;
+  }
+}
+async function collectPrismaFiles(dir) {
+  const found = [];
+  const entries = await (0, import_promises.readdir)(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = (0, import_node_path.join)(dir, entry.name);
+    if (entry.isFile() && entry.name.endsWith(PRISMA_EXT)) {
+      found.push(full);
+    } else if (entry.isDirectory()) {
+      const nested = await (0, import_promises.readdir)(full, { withFileTypes: true });
+      for (const child of nested) {
+        if (child.isFile() && child.name.endsWith(PRISMA_EXT)) {
+          found.push((0, import_node_path.join)(full, child.name));
+        }
+      }
+    }
+  }
+  return found;
+}
+async function dirHasContract(dir) {
+  return await pathKind((0, import_node_path.join)(dir, CONTRACT_FILE)) === "file";
+}
+async function readTuples(root, files) {
+  const tuples = await Promise.all(
+    files.map(
+      async (file) => [
+        toPosix((0, import_node_path.relative)(root, file)),
+        await (0, import_promises.readFile)(file, "utf8")
+      ]
+    )
+  );
+  return tuples.sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+}
+async function resolveMode7(namespace, resolved, kind) {
+  if (kind === "file") {
+    return {
+      mode: 7,
+      kind: "file",
+      files: await readTuples((0, import_node_path.dirname)(resolved), [resolved])
+    };
+  }
+  const files = await collectPrismaFiles(resolved);
+  if (files.length === 0) {
+    throw new PrismaInputError(
+      namespace,
+      resolved,
+      "the schema folder contains no .prisma file"
+    );
+  }
+  return { mode: 7, kind: "folder", files: await readTuples(resolved, files) };
+}
+async function resolveMode8(namespace, resolved, kind) {
+  if (kind === "dir") {
+    const contractPath = (0, import_node_path.join)(resolved, CONTRACT_FILE);
+    if (await pathKind(contractPath) !== "file") {
+      throw new PrismaInputError(
+        namespace,
+        resolved,
+        `version 8 mode expects a ${CONTRACT_FILE} in the folder`
+      );
+    }
+    return { mode: 8, kind: "contract", contractPath };
+  }
+  return { mode: 8, kind: "contract", contractPath: resolved };
+}
+async function resolveInput(cwd, o, namespace = "<unknown>") {
+  const resolved = (0, import_node_path.resolve)(cwd, o.schema);
+  const kind = await pathKind(resolved);
+  if (kind === "missing") {
+    throw new PrismaInputError(
+      namespace,
+      resolved,
+      "the schema path does not exist"
+    );
+  }
+  if (o.version === 8) {
+    return resolveMode8(namespace, resolved, kind);
+  }
+  if (o.version === 7) {
+    return resolveMode7(namespace, resolved, kind);
+  }
+  if (kind === "file") {
+    if ((0, import_node_path.basename)(resolved) === CONTRACT_FILE) {
+      return { mode: 8, kind: "contract", contractPath: resolved };
+    }
+    if (resolved.endsWith(PRISMA_EXT)) {
+      return resolveMode7(namespace, resolved, "file");
+    }
+    throw new PrismaInputError(
+      namespace,
+      resolved,
+      `not a .prisma file or a ${CONTRACT_FILE}`
+    );
+  }
+  if (await dirHasContract(resolved)) {
+    return resolveMode8(namespace, resolved, "dir");
+  }
+  return resolveMode7(namespace, resolved, "dir");
+}
+
+// src/dmmf/load.ts
+var import_promises2 = require("fs/promises");
+var import_node_module = require("module");
+var import_node_path2 = require("path");
+var import_node_url = require("url");
+
+// src/dmmf/read.ts
+function readField(f) {
+  const field = {
+    name: f.name,
+    type: f.type,
+    kind: f.kind === "enum" ? "enum" : f.kind === "unsupported" ? "unsupported" : "scalar",
+    isList: f.isList,
+    isRequired: f.isRequired,
+    isUnique: f.isUnique,
+    isUpdatedAt: f.isUpdatedAt ?? false,
+    hasDefaultValue: f.hasDefaultValue,
+    nativeType: f.nativeType ? [f.nativeType[0], [...f.nativeType[1]]] : null
+  };
+  if (f.default !== void 0) {
+    field.default = f.default;
+  }
+  if (f.documentation !== void 0) {
+    field.doc = f.documentation;
+  }
+  return field;
+}
+function readEdge(f) {
+  const edge = {
+    fieldName: f.name,
+    relationName: f.relationName ?? "",
+    targetEntity: f.type,
+    isList: f.isList,
+    isRequired: f.isRequired,
+    fromFields: [...f.relationFromFields ?? []],
+    toFields: [...f.relationToFields ?? []]
+  };
+  if (f.relationOnDelete !== void 0) {
+    edge.onDelete = f.relationOnDelete;
+  }
+  if (f.relationOnUpdate !== void 0) {
+    edge.onUpdate = f.relationOnUpdate;
+  }
+  return edge;
+}
+function readPrimaryKey(model) {
+  if (model.primaryKey && model.primaryKey.fields.length > 0) {
+    return [...model.primaryKey.fields];
+  }
+  const id = model.fields.find((f) => f.isId);
+  return id ? [id.name] : [];
+}
+function readUniques(model) {
+  if (model.uniqueIndexes.length > 0) {
+    return model.uniqueIndexes.map((u) => {
+      const entry = { fields: [...u.fields] };
+      if (u.name) {
+        entry.name = u.name;
+      }
+      return entry;
+    });
+  }
+  return model.uniqueFields.map((fields) => ({ fields: [...fields] }));
+}
+function readIndexes(modelName, all) {
+  if (!all) {
+    return [];
+  }
+  return all.filter((idx) => idx.model === modelName && idx.type === "normal").map((idx) => {
+    const entry = { fields: idx.fields.map((f) => f.name) };
+    if (idx.name) {
+      entry.name = idx.name;
+    }
+    if (idx.algorithm) {
+      entry.type = idx.algorithm.toLowerCase();
+    }
+    return entry;
+  });
+}
+function readEntity(model, doc) {
+  const fields = [];
+  const relationEdges = [];
+  for (const f of model.fields) {
+    if (f.kind === "object") {
+      relationEdges.push(readEdge(f));
+    } else {
+      fields.push(readField(f));
+    }
+  }
+  const entity = {
+    name: model.name,
+    fields,
+    relationEdges,
+    primaryKey: readPrimaryKey(model),
+    uniques: readUniques(model),
+    indexes: readIndexes(model.name, doc.datamodel.indexes)
+  };
+  if (model.dbName) {
+    entity.dbName = model.dbName;
+  }
+  if (model.documentation !== void 0) {
+    entity.doc = model.documentation;
+  }
+  return entity;
+}
+function readEnum(e) {
+  const def = {
+    name: e.name,
+    values: e.values.map((value) => {
+      const entry = { name: value.name };
+      if (value.dbName) {
+        entry.dbName = value.dbName;
+      }
+      return entry;
+    })
+  };
+  if (e.dbName) {
+    def.dbName = e.dbName;
+  }
+  if (e.documentation !== void 0) {
+    def.doc = e.documentation;
+  }
+  return def;
+}
+function toPrismaModel(doc) {
+  return {
+    entities: doc.datamodel.models.map((m) => readEntity(m, doc)),
+    enums: doc.datamodel.enums.map(readEnum)
+  };
+}
+
+// src/dmmf/load.ts
+async function resolveInternals(ctx) {
+  const base = ctx.anchorDir ?? ctx.cwd;
+  const require2 = (0, import_node_module.createRequire)((0, import_node_path2.join)(base, "noop.js"));
+  let entry;
+  try {
+    entry = require2.resolve("@prisma/internals");
+  } catch (err) {
+    throw new PrismaPeerMissingError(ctx.namespace, { cause: err });
+  }
+  let mod;
+  try {
+    mod = await import((0, import_node_url.pathToFileURL)(entry).href);
+  } catch (err) {
+    throw new PrismaPeerMissingError(ctx.namespace, { cause: err });
+  }
+  const getDMMF = mod.default?.getDMMF ?? mod.getDMMF;
+  if (typeof getDMMF !== "function") {
+    throw new PrismaPeerMissingError(ctx.namespace);
+  }
+  let prismaVersion = "unknown";
+  try {
+    const pkg = JSON.parse(
+      await (0, import_promises2.readFile)(require2.resolve("@prisma/internals/package.json"), "utf8")
+    );
+    if (typeof pkg.version === "string") {
+      prismaVersion = pkg.version;
+    }
+  } catch {
+    ctx.logger.debug(
+      "prisma parser: could not read @prisma/internals version",
+      { namespace: ctx.namespace }
+    );
+  }
+  return { getDMMF, prismaVersion };
+}
+async function readDmmf(input, ctx) {
+  const { getDMMF, prismaVersion } = await resolveInternals(ctx);
+  const datamodel = input.kind === "file" ? input.files[0]?.[1] ?? "" : input.files.map(([path, content]) => [path, content]);
+  let doc;
+  try {
+    doc = await getDMMF({ datamodel });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new PrismaSchemaError(ctx.namespace, message, { cause: err });
+  }
+  return { model: toPrismaModel(doc), prismaVersion };
+}
+
+// src/map/build.ts
+var import_ir = require("@kurotako/ir");
+
+// src/map/defaults.ts
+var ID_FORMATS = {
+  uuid: "uuid",
+  cuid: "cuid",
+  ulid: "ulid"
+};
+function isCall(raw) {
+  return typeof raw === "object" && !Array.isArray(raw) && raw !== null;
+}
+function mapDefault(raw) {
+  if (raw === void 0) {
+    return {};
+  }
+  if (!isCall(raw)) {
+    return { default: { kind: "value", value: raw } };
+  }
+  const { name, args } = raw;
+  if (name === "dbgenerated") {
+    return { default: { kind: "expr", expr: "dbgenerated", args: [...args] } };
+  }
+  const idFormat = ID_FORMATS[name];
+  if (idFormat !== void 0) {
+    const format = name === "cuid" && args[0] === 2 ? "cuid2" : idFormat;
+    return { default: { kind: "expr", expr: `${name}()` }, format };
+  }
+  return { default: { kind: "expr", expr: `${name}()` } };
+}
+
+// src/map/scalars.ts
+var SCALAR_TABLE = {
+  String: "string",
+  Boolean: "boolean",
+  Int: "int",
+  BigInt: "bigint",
+  Float: "float",
+  Decimal: "decimal",
+  DateTime: "datetime",
+  Json: "json",
+  Bytes: "bytes"
+};
+var LENGTH_NATIVE = /* @__PURE__ */ new Set(["VarChar", "Char", "NVarChar", "String"]);
+var UUID_NATIVE = /* @__PURE__ */ new Set(["Uuid", "ObjectId"]);
+var NOOP_NATIVE = /* @__PURE__ */ new Set([
+  "Text",
+  "Citext",
+  "Xml",
+  "Bit",
+  "VarBit",
+  "Inet",
+  "Line",
+  "LongText",
+  "MediumText",
+  "TinyText",
+  "SmallInt",
+  "MediumInt",
+  "UnsignedInt",
+  "UnsignedBigInt",
+  "Money",
+  "Real",
+  "DoublePrecision",
+  "Decimal",
+  "Numeric",
+  "SmallMoney",
+  "Timestamp",
+  "Timestamptz",
+  "DateTime2",
+  "DateTimeOffset"
+]);
+function refineNative(native, constraints, result, field, logger) {
+  const [name, args] = native;
+  if (LENGTH_NATIVE.has(name)) {
+    const n = Number(args[0]);
+    if (Number.isFinite(n)) {
+      constraints.maxLength = n;
+    }
+    return;
+  }
+  if (UUID_NATIVE.has(name)) {
+    result.scalarOverride = "uuid";
+    return;
+  }
+  if (name === "Date") {
+    result.scalarOverride = "date";
+    return;
+  }
+  if (name === "Time" || name === "Timetz") {
+    constraints.format = "time";
+    return;
+  }
+  if (NOOP_NATIVE.has(name)) {
+    return;
+  }
+  logger?.debug(`prisma parser: ignoring unmapped native type @db.${name}`, {
+    field: field.name
+  });
+}
+function mapFieldType(field, logger) {
+  const constraints = {};
+  if (field.kind === "unsupported") {
+    return { type: { kind: "unknown", hint: field.type }, constraints };
+  }
+  if (field.kind === "enum") {
+    return { type: { kind: "enum", ref: field.type }, constraints };
+  }
+  const scalar = SCALAR_TABLE[field.type];
+  if (scalar === void 0) {
+    return { type: { kind: "unknown", hint: field.type }, constraints };
+  }
+  const result = {
+    type: { kind: "scalar", scalar },
+    constraints
+  };
+  if (field.nativeType) {
+    refineNative(field.nativeType, constraints, result, field, logger);
+  }
+  return result;
+}
+
+// src/map/relations.ts
+var ACTION_MAP = {
+  Cascade: "cascade",
+  Restrict: "restrict",
+  SetNull: "setNull",
+  SetDefault: "setDefault",
+  NoAction: "noAction"
+};
+function mapAction(raw) {
+  return raw === void 0 ? void 0 : ACTION_MAP[raw];
+}
+function lcfirst(s) {
+  return s.length === 0 ? s : s.charAt(0).toLowerCase() + s.slice(1);
+}
+function isImplicitM2M(edges) {
+  return edges.length === 2 && edges.every(
+    ({ edge }) => edge.isList && edge.fromFields.length === 0 && edge.toFields.length === 0
+  );
+}
+function pkScalar(entities, entityName, logger) {
+  const entity = entities.get(entityName);
+  if (entity && entity.primaryKey.length === 1) {
+    const pkName = entity.primaryKey[0];
+    const field = entity.fields.find((f) => f.name === pkName);
+    if (field) {
+      const mapped = mapFieldType(field);
+      if (mapped.scalarOverride) {
+        return mapped.scalarOverride;
+      }
+      if (mapped.type.kind === "scalar") {
+        return mapped.type.scalar;
+      }
+    }
+  }
+  logger?.debug(
+    `prisma parser: could not resolve primary-key scalar of '${entityName}', defaulting to string`
+  );
+  return "string";
+}
+function normalRelation(edge, back) {
+  const owning = edge.fromFields.length > 0;
+  const relation = {
+    name: edge.fieldName,
+    target: { namespace: "", entity: edge.targetEntity },
+    cardinality: edge.isList ? "many" : "one",
+    optional: !edge.isRequired,
+    owning
+  };
+  if (owning) {
+    relation.fkFields = [...edge.fromFields];
+    relation.references = [...edge.toFields];
+  }
+  if (back) {
+    relation.backRelation = back.fieldName;
+  }
+  const onDelete = mapAction(edge.onDelete);
+  if (onDelete) {
+    relation.onDelete = onDelete;
+  }
+  const onUpdate = mapAction(edge.onUpdate);
+  if (onUpdate) {
+    relation.onUpdate = onUpdate;
+  }
+  return relation;
+}
+function materialiseM2M(a, b, relationName, entities, logger) {
+  const sorted = [a.owner, b.owner].sort(
+    (l, r) => l < r ? -1 : l > r ? 1 : 0
+  );
+  const x = sorted[0] ?? a.owner;
+  const y = sorted[1] ?? b.owner;
+  const defaultName = `${x}To${y}`;
+  const name = relationName !== "" && relationName !== defaultName ? relationName : `${x}${y}`;
+  const fkX = `${lcfirst(x)}Id`;
+  const fkY = `${lcfirst(y)}Id`;
+  const relX = lcfirst(x);
+  const relY = lcfirst(y);
+  const pkX = entities.get(x)?.primaryKey[0] ?? "id";
+  const pkY = entities.get(y)?.primaryKey[0] ?? "id";
+  const synthetic = {
+    name,
+    fields: [
+      { name: fkX, scalar: pkScalar(entities, x, logger) },
+      { name: fkY, scalar: pkScalar(entities, y, logger) }
+    ],
+    primaryKey: [fkX, fkY],
+    relations: [
+      {
+        name: relX,
+        target: { namespace: "", entity: x },
+        cardinality: "one",
+        optional: false,
+        owning: true,
+        fkFields: [fkX],
+        references: [pkX],
+        onDelete: "cascade"
+      },
+      {
+        name: relY,
+        target: { namespace: "", entity: y },
+        cardinality: "one",
+        optional: false,
+        owning: true,
+        fkFields: [fkY],
+        references: [pkY],
+        onDelete: "cascade"
+      }
+    ]
+  };
+  const mkRewrite = (edge, backName) => ({
+    owner: edge.owner,
+    relation: {
+      name: edge.edge.fieldName,
+      target: { namespace: "", entity: name },
+      cardinality: "many",
+      optional: false,
+      owning: false,
+      backRelation: backName
+    }
+  });
+  return {
+    synthetic,
+    rewrites: [
+      mkRewrite(a, a.owner === x ? relX : relY),
+      mkRewrite(b, b.owner === x ? relX : relY)
+    ]
+  };
+}
+function buildRelations(model, logger) {
+  const entities = new Map(model.entities.map((e) => [e.name, e]));
+  const relations = /* @__PURE__ */ new Map();
+  const syntheticEntities = [];
+  const push = (owner, relation) => {
+    const list = relations.get(owner) ?? [];
+    list.push(relation);
+    relations.set(owner, list);
+  };
+  const groups = /* @__PURE__ */ new Map();
+  for (const entity of model.entities) {
+    for (const edge of entity.relationEdges) {
+      const list = groups.get(edge.relationName) ?? [];
+      list.push({ owner: entity.name, edge });
+      groups.set(edge.relationName, list);
+    }
+  }
+  for (const [relationName, edges] of groups) {
+    if (isImplicitM2M(edges)) {
+      const [a, b] = edges;
+      const { synthetic, rewrites } = materialiseM2M(
+        a,
+        b,
+        relationName,
+        entities,
+        logger
+      );
+      syntheticEntities.push(synthetic);
+      for (const { owner, relation } of rewrites) {
+        push(owner, relation);
+      }
+      continue;
+    }
+    for (const { owner, edge } of edges) {
+      const back = edges.find((e) => e.edge !== edge)?.edge;
+      push(owner, normalRelation(edge, back));
+    }
+  }
+  return { relations, syntheticEntities };
+}
+
+// src/map/build.ts
+var INDEX_TYPES = /* @__PURE__ */ new Set([
+  "btree",
+  "hash",
+  "gin",
+  "gist",
+  "brin",
+  "spgist"
+]);
+function asIndexType(raw) {
+  return raw !== void 0 && INDEX_TYPES.has(raw) ? raw : void 0;
+}
+function fillEnum(eb, e) {
+  for (const value of e.values) {
+    const opts = {};
+    if (value.dbName !== void 0) {
+      opts.dbName = value.dbName;
+    }
+    if (value.doc !== void 0) {
+      opts.doc = value.doc;
+    }
+    eb.value(value.name, opts);
+  }
+  if (e.doc !== void 0) {
+    eb.doc(e.doc);
+  }
+  if (e.dbName !== void 0) {
+    eb.dbName(e.dbName);
+  }
+}
+function addRelation(eb, rel, namespace) {
+  eb.relation(rel.name, (rb) => {
+    rb.to(namespace, rel.target.entity);
+    if (rel.cardinality === "many") {
+      rb.many();
+    } else {
+      rb.one();
+    }
+    if (rel.optional) {
+      rb.optional();
+    }
+    if (rel.owning) {
+      rb.owning();
+    }
+    if (rel.backRelation !== void 0) {
+      rb.backRelation(rel.backRelation);
+    }
+    if (rel.fkFields) {
+      rb.fkFields(...rel.fkFields);
+    }
+    if (rel.references) {
+      rb.references(...rel.references);
+    }
+    if (rel.onDelete) {
+      rb.onDelete(rel.onDelete);
+    }
+    if (rel.onUpdate) {
+      rb.onUpdate(rel.onUpdate);
+    }
+  });
+}
+function buildSourceIR(namespace, model, parserVersion, logger) {
+  const b = (0, import_ir.createSourceIR)({ namespace, parser: "prisma", parserVersion });
+  for (const e of model.enums) {
+    b.addEnum(e.name, (eb) => fillEnum(eb, e));
+  }
+  const { relations, syntheticEntities } = buildRelations(model, logger);
+  for (const entity of model.entities) {
+    b.addEntity(entity.name, (eb) => {
+      for (const field of entity.fields) {
+        eb.field(field.name, (fb) => {
+          const mapped = mapFieldType(field, logger);
+          const scalar = mapped.scalarOverride ?? (mapped.type.kind === "scalar" ? mapped.type.scalar : void 0);
+          if (scalar !== void 0) {
+            fb.scalar(scalar);
+          } else if (mapped.type.kind === "enum") {
+            fb.enum(mapped.type.ref);
+          } else {
+            fb.unknown(
+              mapped.type.kind === "unknown" ? mapped.type.hint : void 0
+            );
+          }
+          const isString = scalar === "string";
+          const { maxLength, format: nativeFormat } = mapped.constraints;
+          if (maxLength !== void 0) {
+            fb.maxLength(maxLength);
+          }
+          const mappedDefault = mapDefault(field.default);
+          if (mappedDefault.default) {
+            fb.default(mappedDefault.default);
+          }
+          const format = mappedDefault.format ?? nativeFormat;
+          if (format !== void 0) {
+            if (isString) {
+              fb.format(format);
+            } else {
+              logger?.debug(
+                `prisma parser: dropping format '${format}' on non-string field '${entity.name}.${field.name}'`
+              );
+            }
+          }
+          if (field.isList) {
+            fb.list();
+          }
+          if (!field.isRequired) {
+            fb.nullable();
+          }
+          if (field.hasDefaultValue || field.isUpdatedAt) {
+            fb.optional();
+          }
+          if (field.isUnique) {
+            fb.unique();
+          }
+          if (field.doc !== void 0) {
+            fb.doc(field.doc);
+          }
+        });
+      }
+      if (entity.primaryKey.length > 0) {
+        eb.primaryKey(...entity.primaryKey);
+      }
+      for (const unique of entity.uniques) {
+        eb.unique(
+          unique.fields,
+          unique.name ? { name: unique.name } : void 0
+        );
+      }
+      for (const index of entity.indexes) {
+        const opts = {};
+        if (index.name) {
+          opts.name = index.name;
+        }
+        const type = asIndexType(index.type);
+        if (type) {
+          opts.type = type;
+        }
+        eb.index(index.fields, opts);
+      }
+      if (entity.doc !== void 0) {
+        eb.doc(entity.doc);
+      }
+      if (entity.dbName !== void 0) {
+        eb.dbName(entity.dbName);
+      }
+      for (const rel of relations.get(entity.name) ?? []) {
+        addRelation(eb, rel, namespace);
+      }
+    });
+  }
+  for (const synthetic of syntheticEntities) {
+    b.addEntity(synthetic.name, (eb) => {
+      for (const field of synthetic.fields) {
+        eb.field(field.name, (fb) => fb.scalar(field.scalar));
+      }
+      eb.primaryKey(...synthetic.primaryKey);
+      for (const rel of synthetic.relations) {
+        addRelation(eb, rel, namespace);
+      }
+    });
+  }
+  return b.build();
+}
+
+// src/parser.ts
+var prismaParser = (0, import_config.defineParser)({
+  name: "prisma",
+  optionsSchema: PrismaParserOptions,
+  async parse(ctx, options) {
+    const input = await resolveInput(ctx.cwd, options, ctx.namespace);
+    if (input.mode === 8) {
+      throw new PrismaInputError(
+        ctx.namespace,
+        input.contractPath,
+        "the Prisma 8 contract.json mode is not implemented in kurotako v1"
+      );
+    }
+    const { model, prismaVersion } = await readDmmf(input, ctx);
+    return buildSourceIR(
+      ctx.namespace,
+      model,
+      `prisma@${prismaVersion}`,
+      ctx.logger
+    );
+  },
+  async watchPaths(ctx, options) {
+    return [(0, import_node_path3.resolve)(ctx.cwd, options.schema)];
+  },
+  anchor(rootDir, options) {
+    return (0, import_node_path3.dirname)((0, import_node_path3.resolve)(rootDir, options.schema));
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PrismaInputError,
+  PrismaParserOptions,
+  PrismaPeerMissingError,
+  PrismaSchemaError,
+  prismaParser
+});
+//# sourceMappingURL=index.cjs.map