@kurotako/parser-prisma 0.1.0 → 0.2.0

package/dist/index.js

@@ -37,18 +37,536 @@ ${prismaMessage}`,
     this.prismaMessage = prismaMessage;
   }
 };
+var PrismaContractError = class extends TakoError {
+  constructor(detail, options) {
+    super(
+      "prisma_contract",
+      `invalid Prisma 8 contract.json: ${detail}`,
+      options
+    );
+  }
+};
+var PrismaContractVersionError = class extends TakoError {
+  found;
+  constructor(found, expected) {
+    super(
+      "prisma_contract_version",
+      `unsupported Prisma contract schemaVersion '${found}' (expected one of: ${expected.join(", ")})`
+    );
+    this.found = found;
+  }
+};
+var PrismaDialectError = class extends TakoError {
+  codecId;
+  constructor(codecId) {
+    const dialect = codecId.split("/")[0] ?? codecId;
+    super(
+      "prisma_dialect",
+      `unsupported Prisma contract dialect '${dialect}' in codec '${codecId}'; only PostgreSQL contracts are supported currently`
+    );
+    this.codecId = codecId;
+  }
+};
+var PrismaEntityCollisionError = class extends TakoError {
+  entityName;
+  models;
+  constructor(entityName, models) {
+    super(
+      "prisma_entity_collision",
+      `Prisma contract models ${models.join(", ")} resolve to the same entity name '${entityName}'`
+    );
+    this.entityName = entityName;
+    this.models = models;
+  }
+};
+var PrismaAmbiguousRelationError = class extends TakoError {
+  constructor(modelName) {
+    super(
+      "prisma_ambiguous_relation",
+      `Prisma contract relation targets '${modelName}', which exists in multiple namespaces; Prisma 8 RC does not resolve this reliably`
+    );
+  }
+};
 
 // src/options.ts
 import * as v from "valibot";
 var PrismaParserOptions = v.strictObject({
   schema: v.optional(v.string(), "./prisma/schema.prisma"),
-  version: v.optional(v.picklist([7, 8]))
+  version: v.optional(v.picklist([7, 8])),
+  namespacePrefix: v.optional(v.record(v.string(), v.string())),
+  rename: v.optional(v.record(v.string(), v.string()))
 });
 
 // src/parser.ts
+import { readFile as readFile3 } from "fs/promises";
 import { dirname as dirname2, resolve as resolve2 } from "path";
 import { defineParser } from "@kurotako/config";
 
+// src/contract/codecs.ts
+var CODECS = {
+  "pg/text": { scalar: "string" },
+  "pg/text-array": { scalar: "string" },
+  "pg/varchar": { scalar: "string", needsLength: true },
+  "sql/varchar": { scalar: "string", needsLength: true },
+  "pg/char": { scalar: "string" },
+  "pg/bpchar": { scalar: "string" },
+  "pg/bool": { scalar: "boolean" },
+  "pg/int": { scalar: "int" },
+  "pg/int2": { scalar: "int" },
+  "pg/int4": { scalar: "int" },
+  "pg/int8": { scalar: "bigint" },
+  "pg/int8number": { scalar: "int" },
+  "pg/unboundedint": { scalar: "bigint" },
+  "pg/float": { scalar: "float" },
+  "pg/float4": { scalar: "float" },
+  "pg/float8": { scalar: "float" },
+  "pg/numeric": { scalar: "decimal" },
+  "pg/uuid": { scalar: "uuid" },
+  "pg/timestamp-string": { scalar: "datetime" },
+  "pg/timestamp-temporal": { scalar: "datetime" },
+  "pg/timestamptz-string": { scalar: "datetime" },
+  "pg/timestamptz-temporal": { scalar: "datetime" },
+  "pg/date-string": { scalar: "date" },
+  "pg/date-temporal": { scalar: "date" },
+  "pg/time-string": { scalar: "datetime", format: "time" },
+  "pg/time-temporal": { scalar: "datetime", format: "time" },
+  "pg/timetz": { scalar: "datetime", format: "time" },
+  "pg/json": { scalar: "json" },
+  "pg/jsonb": { scalar: "json" },
+  "pg/bytea": { scalar: "bytes" }
+};
+function splitCodec(codecId) {
+  const at = codecId.lastIndexOf("@");
+  return at === -1 ? { name: codecId } : { name: codecId.slice(0, at), version: codecId.slice(at + 1) };
+}
+function mapCodec(codecId, logger) {
+  const { name, version } = splitCodec(codecId);
+  if (version !== void 0) {
+    logger?.debug(`prisma parser: contract codec '${name}' version ${version}`);
+  }
+  const entry = CODECS[name];
+  if (entry) {
+    return {
+      type: { kind: "scalar", scalar: entry.scalar },
+      ...entry.format !== void 0 ? { format: entry.format } : {},
+      ...entry.needsLength ? { needsLength: true } : {}
+    };
+  }
+  if (!name.startsWith("pg/") && !name.startsWith("sql/")) {
+    throw new PrismaDialectError(codecId);
+  }
+  logger?.debug(`prisma parser: unknown contract codec '${codecId}'`);
+  return { type: { kind: "unknown", hint: codecId } };
+}
+
+// src/contract/naming.ts
+function resolveNames(models, options) {
+  const names = /* @__PURE__ */ new Map();
+  const collisions = /* @__PURE__ */ new Map();
+  for (const { namespace, name } of models) {
+    const key = `${namespace}.${name}`;
+    const target = options.rename?.[key] ?? `${options.namespacePrefix?.[namespace] ?? ""}${name}`;
+    names.set(key, target);
+    const entries = collisions.get(target) ?? [];
+    entries.push(key);
+    collisions.set(target, entries);
+  }
+  for (const [target, modelsForTarget] of collisions) {
+    if (modelsForTarget.length > 1) {
+      throw new PrismaEntityCollisionError(target, modelsForTarget);
+    }
+  }
+  return names;
+}
+
+// src/contract/schema.ts
+import * as v2 from "valibot";
+var scalarType = v2.looseObject({
+  kind: v2.literal("scalar"),
+  codecId: v2.string(),
+  typeParams: v2.optional(v2.looseObject({ length: v2.optional(v2.number()) }))
+});
+var valueObjectType = v2.looseObject({
+  kind: v2.literal("valueObject"),
+  name: v2.string()
+});
+var field = v2.looseObject({
+  nullable: v2.boolean(),
+  many: v2.optional(v2.boolean()),
+  type: v2.union([scalarType, valueObjectType]),
+  valueSet: v2.optional(v2.looseObject({ entityName: v2.string() }))
+});
+var relation = v2.looseObject({
+  cardinality: v2.picklist(["1:1", "1:N", "N:1", "N:M"]),
+  to: v2.looseObject({ namespace: v2.string(), model: v2.string() }),
+  on: v2.looseObject({
+    localFields: v2.array(v2.string()),
+    targetFields: v2.array(v2.string())
+  })
+});
+var model = v2.looseObject({
+  fields: v2.record(v2.string(), field),
+  relations: v2.optional(v2.record(v2.string(), relation)),
+  storage: v2.looseObject({
+    table: v2.string(),
+    namespaceId: v2.string(),
+    fields: v2.record(v2.string(), v2.looseObject({ column: v2.string() }))
+  })
+});
+var enumDef = v2.looseObject({
+  members: v2.array(v2.looseObject({ name: v2.string(), value: v2.string() }))
+});
+var column = v2.looseObject({
+  codecId: v2.string(),
+  nullable: v2.boolean(),
+  many: v2.optional(v2.boolean()),
+  default: v2.optional(
+    v2.looseObject({
+      kind: v2.picklist(["function", "literal"]),
+      expression: v2.optional(v2.string()),
+      value: v2.optional(
+        v2.union([
+          v2.string(),
+          v2.number(),
+          v2.boolean(),
+          v2.array(v2.union([v2.string(), v2.number(), v2.boolean()]))
+        ])
+      )
+    })
+  )
+});
+var table = v2.looseObject({
+  columns: v2.record(v2.string(), column),
+  primaryKey: v2.optional(v2.looseObject({ columns: v2.array(v2.string()) })),
+  uniques: v2.optional(
+    v2.array(
+      v2.looseObject({
+        columns: v2.array(v2.string()),
+        name: v2.optional(v2.string())
+      })
+    )
+  ),
+  indexes: v2.optional(
+    v2.array(
+      v2.looseObject({
+        columns: v2.array(v2.string()),
+        name: v2.optional(v2.string()),
+        type: v2.optional(v2.string())
+      })
+    )
+  ),
+  foreignKeys: v2.optional(
+    v2.array(
+      v2.looseObject({
+        source: v2.looseObject({ columns: v2.array(v2.string()) }),
+        onDelete: v2.optional(v2.string()),
+        onUpdate: v2.optional(v2.string())
+      })
+    )
+  )
+});
+var ContractSchema = v2.looseObject({
+  schemaVersion: v2.string(),
+  target: v2.string(),
+  targetFamily: v2.string(),
+  domain: v2.looseObject({
+    namespaces: v2.record(
+      v2.string(),
+      v2.looseObject({
+        models: v2.record(v2.string(), model),
+        enum: v2.optional(v2.record(v2.string(), enumDef))
+      })
+    )
+  }),
+  storage: v2.looseObject({
+    namespaces: v2.record(
+      v2.string(),
+      v2.looseObject({
+        entries: v2.looseObject({
+          table: v2.optional(v2.record(v2.string(), table)),
+          valueSet: v2.optional(
+            v2.record(
+              v2.string(),
+              v2.looseObject({ values: v2.array(v2.string()) })
+            )
+          )
+        })
+      })
+    )
+  }),
+  execution: v2.optional(
+    v2.looseObject({
+      mutations: v2.optional(
+        v2.looseObject({
+          defaults: v2.optional(
+            v2.array(
+              v2.looseObject({
+                ref: v2.looseObject({
+                  namespace: v2.string(),
+                  table: v2.string(),
+                  column: v2.string()
+                }),
+                onCreate: v2.optional(
+                  v2.looseObject({ kind: v2.string(), id: v2.string() })
+                ),
+                onUpdate: v2.optional(
+                  v2.looseObject({ kind: v2.string(), id: v2.string() })
+                )
+              })
+            )
+          )
+        })
+      )
+    })
+  )
+});
+function issuePath(err) {
+  if (err instanceof v2.ValiError) {
+    return err.issues.map(
+      (issue) => issue.path?.map((part) => String(part.key)).join(".") ?? "<root>"
+    ).join(", ");
+  }
+  return "<root>";
+}
+function parseContract(raw) {
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch (err) {
+    throw new PrismaContractError("invalid JSON", { cause: err });
+  }
+  try {
+    return v2.parse(ContractSchema, value);
+  } catch (err) {
+    throw new PrismaContractError(`invalid structure at ${issuePath(err)}`, {
+      cause: err
+    });
+  }
+}
+
+// src/contract/version.ts
+var SUPPORTED_SCHEMA_VERSIONS = /* @__PURE__ */ new Set(["1"]);
+function assertSupportedVersion(found) {
+  if (!SUPPORTED_SCHEMA_VERSIONS.has(found)) {
+    throw new PrismaContractVersionError(found, [...SUPPORTED_SCHEMA_VERSIONS]);
+  }
+}
+
+// src/contract/read.ts
+function record3(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function strings(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function storageTable(contract, namespace, tableName) {
+  const namespaces = record3(record3(contract.storage).namespaces);
+  const entries = record3(record3(namespaces[namespace]).entries);
+  return record3(record3(entries.table)[tableName]);
+}
+function defaultValue(value) {
+  const raw = record3(value);
+  if (raw.kind === "literal") {
+    return raw.value;
+  }
+  if (raw.kind === "function" && typeof raw.expression === "string") {
+    const expression = raw.expression;
+    const match = /^(\\w+)\\((.*)\\)$/.exec(expression);
+    return match ? { name: match[1] ?? expression, args: [] } : { name: expression, args: [] };
+  }
+  return void 0;
+}
+function generatorDefault(contract, namespace, table2, column2) {
+  const defaults = record3(
+    record3(record3(contract.execution).mutations).defaults
+  );
+  if (!Array.isArray(defaults)) return void 0;
+  return defaults.map(record3).find((entry) => {
+    const ref = record3(entry.ref);
+    return ref.namespace === namespace && ref.table === table2 && ref.column === column2;
+  });
+}
+function readField(name, raw, storageColumn, generator, logger) {
+  const type = record3(raw.type);
+  if (type.kind === "valueObject") {
+    return {
+      name,
+      type: typeof type.name === "string" ? type.name : "valueObject",
+      kind: "unsupported",
+      isList: raw.many === true,
+      isRequired: raw.nullable !== true,
+      isUnique: false,
+      isUpdatedAt: false,
+      hasDefaultValue: generator !== void 0 || storageColumn.default !== void 0,
+      nativeType: null
+    };
+  }
+  const codecId = String(type.codecId);
+  const mapped = mapCodec(codecId, logger);
+  const valueSet = record3(raw.valueSet);
+  const isEnum = typeof valueSet.entityName === "string";
+  const typeParams = record3(type.typeParams);
+  const maxLength = mapped.needsLength && typeof typeParams.length === "number" ? typeParams.length : void 0;
+  const field2 = {
+    name,
+    type: isEnum ? String(valueSet.entityName) : codecId,
+    kind: isEnum ? "enum" : "scalar",
+    isList: raw.many === true,
+    isRequired: raw.nullable !== true,
+    isUnique: false,
+    isUpdatedAt: record3(generator?.onUpdate).id === "instantNow",
+    hasDefaultValue: generator !== void 0 || storageColumn.default !== void 0,
+    nativeType: null
+  };
+  if (isEnum) return field2;
+  field2.mappedType = mapped.type;
+  field2.scalarOverride = mapped.scalarOverride;
+  field2.format = mapped.format;
+  field2.maxLength = maxLength;
+  const parsedDefault = defaultValue(storageColumn.default);
+  if (parsedDefault !== void 0) field2.default = parsedDefault;
+  return field2;
+}
+function readRelationEdges(relations, names, sourceName, table2) {
+  const foreignKeys = Array.isArray(table2.foreignKeys) ? table2.foreignKeys.map(record3) : [];
+  return Object.entries(relations).map(([fieldName, relation2]) => {
+    const raw = record3(relation2);
+    const to = record3(raw.to);
+    const on = record3(raw.on);
+    const localFields = strings(on.localFields);
+    const targetFields = strings(on.targetFields);
+    const fk = foreignKeys.find((candidate) => {
+      const source = record3(candidate.source);
+      return JSON.stringify(strings(source.columns)) === JSON.stringify(localFields);
+    });
+    const targetKey = `${String(to.namespace)}.${String(to.model)}`;
+    const cardinality = raw.cardinality;
+    const edge = {
+      fieldName,
+      relationName: [sourceName, String(to.model)].sort().join(":") + `:${[...localFields, ...targetFields].sort().join(",")}`,
+      targetEntity: names.get(targetKey) ?? String(to.model),
+      isList: cardinality === "1:N" || cardinality === "N:M",
+      isRequired: cardinality !== "1:N" && cardinality !== "N:M",
+      fromFields: fk ? localFields : [],
+      toFields: fk ? targetFields : []
+    };
+    if (typeof fk?.onDelete === "string") edge.onDelete = fk.onDelete;
+    if (typeof fk?.onUpdate === "string") edge.onUpdate = fk.onUpdate;
+    return edge;
+  });
+}
+function readContract(raw, ctx, options) {
+  const parsed = parseContract(raw);
+  assertSupportedVersion(parsed.schemaVersion);
+  const contract = parsed;
+  const namespaces = record3(record3(contract.domain).namespaces);
+  const models = Object.entries(namespaces).flatMap(
+    ([namespace, rawNamespace]) => Object.keys(record3(record3(rawNamespace).models)).map((name) => ({
+      namespace,
+      name
+    }))
+  );
+  const modelCounts = /* @__PURE__ */ new Map();
+  for (const model2 of models) {
+    modelCounts.set(model2.name, (modelCounts.get(model2.name) ?? 0) + 1);
+  }
+  for (const rawNamespace of Object.values(namespaces)) {
+    for (const rawModel of Object.values(record3(record3(rawNamespace).models))) {
+      for (const relation2 of Object.values(
+        record3(record3(rawModel).relations)
+      )) {
+        const target = record3(record3(relation2).to);
+        if (typeof target.model === "string" && (modelCounts.get(target.model) ?? 0) > 1) {
+          throw new PrismaAmbiguousRelationError(target.model);
+        }
+      }
+    }
+  }
+  const names = resolveNames(models, options);
+  const entities = [];
+  const enums = [];
+  for (const [namespace, rawNamespace] of Object.entries(namespaces)) {
+    const namespaceData = record3(rawNamespace);
+    const modelDefs = record3(namespaceData.models);
+    for (const [sourceName, rawModel] of Object.entries(modelDefs)) {
+      const model2 = record3(rawModel);
+      const bridge = record3(model2.storage);
+      const tableName = String(bridge.table);
+      const table2 = storageTable(
+        contract,
+        String(bridge.namespaceId),
+        tableName
+      );
+      const columns = record3(table2.columns);
+      const bridgeFields = record3(bridge.fields);
+      const fields = Object.entries(record3(model2.fields)).map(
+        ([name, rawField]) => {
+          const column2 = String(record3(bridgeFields[name]).column);
+          return readField(
+            name,
+            record3(rawField),
+            record3(columns[column2]),
+            generatorDefault(
+              contract,
+              String(bridge.namespaceId),
+              tableName,
+              column2
+            ),
+            ctx.logger
+          );
+        }
+      );
+      const uniqueColumns = new Set(
+        (Array.isArray(table2.uniques) ? table2.uniques : []).flatMap(
+          (entry) => strings(record3(entry).columns)
+        )
+      );
+      for (const field2 of fields)
+        field2.isUnique = uniqueColumns.has(field2.name);
+      const entity = {
+        name: names.get(`${namespace}.${sourceName}`) ?? sourceName,
+        dbName: tableName === sourceName ? void 0 : tableName,
+        fields,
+        relationEdges: readRelationEdges(
+          record3(model2.relations),
+          names,
+          sourceName,
+          table2
+        ),
+        primaryKey: strings(record3(table2.primaryKey).columns),
+        uniques: (Array.isArray(table2.uniques) ? table2.uniques : []).map(
+          (entry) => ({
+            fields: strings(record3(entry).columns),
+            ...typeof record3(entry).name === "string" ? { name: String(record3(entry).name) } : {}
+          })
+        ),
+        indexes: (Array.isArray(table2.indexes) ? table2.indexes : []).map(
+          (entry) => ({
+            fields: strings(record3(entry).columns),
+            ...typeof record3(entry).name === "string" ? { name: String(record3(entry).name) } : {},
+            ...typeof record3(entry).type === "string" ? { type: String(record3(entry).type) } : {}
+          })
+        )
+      };
+      entities.push(entity);
+    }
+    for (const [name, rawEnum] of Object.entries(record3(namespaceData.enum))) {
+      const members = Array.isArray(record3(rawEnum).members) ? record3(rawEnum).members : [];
+      enums.push({
+        name,
+        values: members.map((member) => {
+          const value = record3(member);
+          return {
+            name: String(value.name),
+            ...String(value.value) !== String(value.name) ? { dbName: String(value.value) } : {}
+          };
+        })
+      });
+    }
+  }
+  return { model: { entities, enums }, generatorVersion: parsed.schemaVersion };
+}
+
 // src/detect.ts
 import { readdir, readFile, stat } from "fs/promises";
 import { basename, dirname, join, relative, resolve, sep } from "path";
@@ -174,8 +692,8 @@ import { join as join2 } from "path";
 import { pathToFileURL } from "url";
 
 // src/dmmf/read.ts
-function readField(f) {
-  const field = {
+function readField2(f) {
+  const field2 = {
     name: f.name,
     type: f.type,
     kind: f.kind === "enum" ? "enum" : f.kind === "unsupported" ? "unsupported" : "scalar",
@@ -187,12 +705,12 @@ function readField(f) {
     nativeType: f.nativeType ? [f.nativeType[0], [...f.nativeType[1]]] : null
   };
   if (f.default !== void 0) {
-    field.default = f.default;
+    field2.default = f.default;
   }
   if (f.documentation !== void 0) {
-    field.doc = f.documentation;
+    field2.doc = f.documentation;
   }
-  return field;
+  return field2;
 }
 function readEdge(f) {
   const edge = {
@@ -212,16 +730,16 @@ function readEdge(f) {
   }
   return edge;
 }
-function readPrimaryKey(model) {
-  if (model.primaryKey && model.primaryKey.fields.length > 0) {
-    return [...model.primaryKey.fields];
+function readPrimaryKey(model2) {
+  if (model2.primaryKey && model2.primaryKey.fields.length > 0) {
+    return [...model2.primaryKey.fields];
   }
-  const id = model.fields.find((f) => f.isId);
+  const id = model2.fields.find((f) => f.isId);
   return id ? [id.name] : [];
 }
-function readUniques(model) {
-  if (model.uniqueIndexes.length > 0) {
-    return model.uniqueIndexes.map((u) => {
+function readUniques(model2) {
+  if (model2.uniqueIndexes.length > 0) {
+    return model2.uniqueIndexes.map((u) => {
       const entry = { fields: [...u.fields] };
       if (u.name) {
         entry.name = u.name;
@@ -229,7 +747,7 @@ function readUniques(model) {
       return entry;
     });
   }
-  return model.uniqueFields.map((fields) => ({ fields: [...fields] }));
+  return model2.uniqueFields.map((fields) => ({ fields: [...fields] }));
 }
 function readIndexes(modelName, all) {
   if (!all) {
@@ -246,29 +764,29 @@ function readIndexes(modelName, all) {
     return entry;
   });
 }
-function readEntity(model, doc) {
+function readEntity(model2, doc) {
   const fields = [];
   const relationEdges = [];
-  for (const f of model.fields) {
+  for (const f of model2.fields) {
     if (f.kind === "object") {
       relationEdges.push(readEdge(f));
     } else {
-      fields.push(readField(f));
+      fields.push(readField2(f));
     }
   }
   const entity = {
-    name: model.name,
+    name: model2.name,
     fields,
     relationEdges,
-    primaryKey: readPrimaryKey(model),
-    uniques: readUniques(model),
-    indexes: readIndexes(model.name, doc.datamodel.indexes)
+    primaryKey: readPrimaryKey(model2),
+    uniques: readUniques(model2),
+    indexes: readIndexes(model2.name, doc.datamodel.indexes)
   };
-  if (model.dbName) {
-    entity.dbName = model.dbName;
+  if (model2.dbName) {
+    entity.dbName = model2.dbName;
   }
-  if (model.documentation !== void 0) {
-    entity.doc = model.documentation;
+  if (model2.documentation !== void 0) {
+    entity.doc = model2.documentation;
   }
   return entity;
 }
@@ -291,11 +809,27 @@ function readEnum(e) {
   }
   return def;
 }
-function toPrismaModel(doc) {
-  return {
+function toPrismaModel(doc, options) {
+  const result = {
     entities: doc.datamodel.models.map((m) => readEntity(m, doc)),
     enums: doc.datamodel.enums.map(readEnum)
   };
+  if (!options?.rename) {
+    return result;
+  }
+  const names = new Map(
+    result.entities.map((entity) => [
+      entity.name,
+      options.rename?.[entity.name] ?? entity.name
+    ])
+  );
+  for (const entity of result.entities) {
+    entity.name = names.get(entity.name) ?? entity.name;
+    for (const edge of entity.relationEdges) {
+      edge.targetEntity = names.get(edge.targetEntity) ?? edge.targetEntity;
+    }
+  }
+  return result;
 }
 
 // src/dmmf/load.ts
@@ -334,7 +868,7 @@ async function resolveInternals(ctx) {
   }
   return { getDMMF, prismaVersion };
 }
-async function readDmmf(input, ctx) {
+async function readDmmf(input, ctx, options) {
   const { getDMMF, prismaVersion } = await resolveInternals(ctx);
   const datamodel = input.kind === "file" ? input.files[0]?.[1] ?? "" : input.files.map(([path, content]) => [path, content]);
   let doc;
@@ -344,7 +878,7 @@ async function readDmmf(input, ctx) {
     const message = err instanceof Error ? err.message : String(err);
     throw new PrismaSchemaError(ctx.namespace, message, { cause: err });
   }
-  return { model: toPrismaModel(doc), prismaVersion };
+  return { model: toPrismaModel(doc, options), prismaVersion };
 }
 
 // src/map/build.ts
@@ -420,7 +954,7 @@ var NOOP_NATIVE = /* @__PURE__ */ new Set([
   "DateTime2",
   "DateTimeOffset"
 ]);
-function refineNative(native, constraints, result, field, logger) {
+function refineNative(native, constraints, result, field2, logger) {
   const [name, args] = native;
   if (LENGTH_NATIVE.has(name)) {
     const n = Number(args[0]);
@@ -445,27 +979,27 @@ function refineNative(native, constraints, result, field, logger) {
     return;
   }
   logger?.debug(`prisma parser: ignoring unmapped native type @db.${name}`, {
-    field: field.name
+    field: field2.name
   });
 }
-function mapFieldType(field, logger) {
+function mapFieldType(field2, logger) {
   const constraints = {};
-  if (field.kind === "unsupported") {
-    return { type: { kind: "unknown", hint: field.type }, constraints };
+  if (field2.kind === "unsupported") {
+    return { type: { kind: "unknown", hint: field2.type }, constraints };
   }
-  if (field.kind === "enum") {
-    return { type: { kind: "enum", ref: field.type }, constraints };
+  if (field2.kind === "enum") {
+    return { type: { kind: "enum", ref: field2.type }, constraints };
   }
-  const scalar = SCALAR_TABLE[field.type];
+  const scalar = SCALAR_TABLE[field2.type];
   if (scalar === void 0) {
-    return { type: { kind: "unknown", hint: field.type }, constraints };
+    return { type: { kind: "unknown", hint: field2.type }, constraints };
   }
   const result = {
     type: { kind: "scalar", scalar },
     constraints
   };
-  if (field.nativeType) {
-    refineNative(field.nativeType, constraints, result, field, logger);
+  if (field2.nativeType) {
+    refineNative(field2.nativeType, constraints, result, field2, logger);
   }
   return result;
 }
@@ -493,9 +1027,9 @@ 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);
+    const field2 = entity.fields.find((f) => f.name === pkName);
+    if (field2) {
+      const mapped = mapFieldType(field2);
       if (mapped.scalarOverride) {
         return mapped.scalarOverride;
       }
@@ -511,7 +1045,7 @@ function pkScalar(entities, entityName, logger) {
 }
 function normalRelation(edge, back) {
   const owning = edge.fromFields.length > 0;
-  const relation = {
+  const relation2 = {
     name: edge.fieldName,
     target: { namespace: "", entity: edge.targetEntity },
     cardinality: edge.isList ? "many" : "one",
@@ -519,21 +1053,21 @@ function normalRelation(edge, back) {
     owning
   };
   if (owning) {
-    relation.fkFields = [...edge.fromFields];
-    relation.references = [...edge.toFields];
+    relation2.fkFields = [...edge.fromFields];
+    relation2.references = [...edge.toFields];
   }
   if (back) {
-    relation.backRelation = back.fieldName;
+    relation2.backRelation = back.fieldName;
   }
   const onDelete = mapAction(edge.onDelete);
   if (onDelete) {
-    relation.onDelete = onDelete;
+    relation2.onDelete = onDelete;
   }
   const onUpdate = mapAction(edge.onUpdate);
   if (onUpdate) {
-    relation.onUpdate = onUpdate;
+    relation2.onUpdate = onUpdate;
   }
-  return relation;
+  return relation2;
 }
 function materialiseM2M(a, b, relationName, entities, logger) {
   const sorted = [a.owner, b.owner].sort(
@@ -598,17 +1132,17 @@ function materialiseM2M(a, b, relationName, entities, logger) {
     ]
   };
 }
-function buildRelations(model, logger) {
-  const entities = new Map(model.entities.map((e) => [e.name, e]));
+function buildRelations(model2, logger) {
+  const entities = new Map(model2.entities.map((e) => [e.name, e]));
   const relations = /* @__PURE__ */ new Map();
   const syntheticEntities = [];
-  const push = (owner, relation) => {
+  const push = (owner, relation2) => {
     const list = relations.get(owner) ?? [];
-    list.push(relation);
+    list.push(relation2);
     relations.set(owner, list);
   };
   const groups = /* @__PURE__ */ new Map();
-  for (const entity of model.entities) {
+  for (const entity of model2.entities) {
     for (const edge of entity.relationEdges) {
       const list = groups.get(edge.relationName) ?? [];
       list.push({ owner: entity.name, edge });
@@ -626,8 +1160,8 @@ function buildRelations(model, logger) {
         logger
       );
       syntheticEntities.push(synthetic);
-      for (const { owner, relation } of rewrites) {
-        push(owner, relation);
+      for (const { owner, relation: relation2 } of rewrites) {
+        push(owner, relation2);
       }
       continue;
     }
@@ -700,17 +1234,24 @@ function addRelation(eb, rel, namespace) {
     }
   });
 }
-function buildSourceIR(namespace, model, parserVersion, logger) {
+function buildSourceIR(namespace, model2, parserVersion, logger) {
   const b = createSourceIR({ namespace, parser: "prisma", parserVersion });
-  for (const e of model.enums) {
+  for (const e of model2.enums) {
     b.addEnum(e.name, (eb) => fillEnum(eb, e));
   }
-  const { relations, syntheticEntities } = buildRelations(model, logger);
-  for (const entity of model.entities) {
+  const { relations, syntheticEntities } = buildRelations(model2, logger);
+  for (const entity of model2.entities) {
     b.addEntity(entity.name, (eb) => {
-      for (const field of entity.fields) {
-        eb.field(field.name, (fb) => {
-          const mapped = mapFieldType(field, logger);
+      for (const field2 of entity.fields) {
+        eb.field(field2.name, (fb) => {
+          const mapped = field2.mappedType ? {
+            type: field2.mappedType,
+            constraints: {
+              ...field2.maxLength !== void 0 ? { maxLength: field2.maxLength } : {},
+              ...field2.format !== void 0 ? { format: field2.format } : {}
+            },
+            scalarOverride: field2.scalarOverride
+          } : mapFieldType(field2, logger);
           const scalar = mapped.scalarOverride ?? (mapped.type.kind === "scalar" ? mapped.type.scalar : void 0);
           if (scalar !== void 0) {
             fb.scalar(scalar);
@@ -726,7 +1267,7 @@ function buildSourceIR(namespace, model, parserVersion, logger) {
           if (maxLength !== void 0) {
             fb.maxLength(maxLength);
           }
-          const mappedDefault = mapDefault(field.default);
+          const mappedDefault = mapDefault(field2.default);
           if (mappedDefault.default) {
             fb.default(mappedDefault.default);
           }
@@ -736,24 +1277,24 @@ function buildSourceIR(namespace, model, parserVersion, logger) {
               fb.format(format);
             } else {
               logger?.debug(
-                `prisma parser: dropping format '${format}' on non-string field '${entity.name}.${field.name}'`
+                `prisma parser: dropping format '${format}' on non-string field '${entity.name}.${field2.name}'`
               );
             }
           }
-          if (field.isList) {
+          if (field2.isList) {
             fb.list();
           }
-          if (!field.isRequired) {
+          if (!field2.isRequired) {
             fb.nullable();
           }
-          if (field.hasDefaultValue || field.isUpdatedAt) {
+          if (field2.hasDefaultValue || field2.isUpdatedAt) {
             fb.optional();
           }
-          if (field.isUnique) {
+          if (field2.isUnique) {
             fb.unique();
           }
-          if (field.doc !== void 0) {
-            fb.doc(field.doc);
+          if (field2.doc !== void 0) {
+            fb.doc(field2.doc);
           }
         });
       }
@@ -790,8 +1331,8 @@ function buildSourceIR(namespace, model, parserVersion, logger) {
   }
   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));
+      for (const field2 of synthetic.fields) {
+        eb.field(field2.name, (fb) => fb.scalar(field2.scalar));
       }
       eb.primaryKey(...synthetic.primaryKey);
       for (const rel of synthetic.relations) {
@@ -809,16 +1350,24 @@ var prismaParser = defineParser({
   async parse(ctx, options) {
     const input = await resolveInput(ctx.cwd, options, ctx.namespace);
     if (input.mode === 8) {
-      throw new PrismaInputError(
+      const raw = await readFile3(input.contractPath, "utf8");
+      const { model: model3, generatorVersion } = readContract(raw, ctx, options);
+      return buildSourceIR(
         ctx.namespace,
-        input.contractPath,
-        "the Prisma 8 contract.json mode is not implemented in kurotako v1"
+        model3,
+        `prisma-contract@${generatorVersion}`,
+        ctx.logger
+      );
+    }
+    if (options.namespacePrefix) {
+      ctx.logger.warn(
+        "prisma parser: namespacePrefix is ignored in Prisma 7 mode"
       );
     }
-    const { model, prismaVersion } = await readDmmf(input, ctx);
+    const { model: model2, prismaVersion } = await readDmmf(input, ctx, options);
     return buildSourceIR(
       ctx.namespace,
-      model,
+      model2,
       `prisma@${prismaVersion}`,
       ctx.logger
     );
@@ -831,6 +1380,11 @@ var prismaParser = defineParser({
   }
 });
 export {
+  PrismaAmbiguousRelationError,
+  PrismaContractError,
+  PrismaContractVersionError,
+  PrismaDialectError,
+  PrismaEntityCollisionError,
   PrismaInputError,
   PrismaParserOptions,
   PrismaPeerMissingError,