prisma-guard 1.1.0

package/dist/generator/index.js

@@ -0,0 +1,893 @@
+#!/usr/bin/env node
+
+// src/generator/index.ts
+import pkg from "@prisma/generator-helper";
+import { writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+
+// src/generator/emit-scope-map.ts
+function isScopeRoot(documentation) {
+  if (!documentation)
+    return false;
+  const tokens = documentation.split(/[\s\n\r]+/);
+  return tokens.some((t) => t === "@scope-root");
+}
+function emitScopeMap(dmmf, onAmbiguousScope) {
+  const rootModels = /* @__PURE__ */ new Set();
+  for (const model of dmmf.datamodel.models) {
+    if (isScopeRoot(model.documentation)) {
+      rootModels.add(model.name);
+    }
+  }
+  const scopeMap = {};
+  for (const model of dmmf.datamodel.models) {
+    if (rootModels.has(model.name))
+      continue;
+    const relations = [];
+    for (const field of model.fields) {
+      if (!field.relationFromFields || field.relationFromFields.length === 0)
+        continue;
+      if (!rootModels.has(field.type))
+        continue;
+      if (field.relationFromFields.length > 1) {
+        const msg = `Model "${model.name}" has a composite foreign key to scope root "${field.type}" via relation "${field.name}" (fields: ${field.relationFromFields.join(", ")}). Composite scope relations are not supported.`;
+        if (onAmbiguousScope === "error") {
+          throw new Error(`prisma-guard: ${msg}`);
+        }
+        if (onAmbiguousScope === "warn") {
+          console.warn(`prisma-guard: ${msg} Excluding model from scope map.`);
+        }
+        continue;
+      }
+      relations.push({
+        fks: [...field.relationFromFields],
+        root: field.type,
+        relationName: field.name
+      });
+    }
+    if (relations.length === 0)
+      continue;
+    const relationsByRoot = {};
+    for (const rel of relations) {
+      if (!relationsByRoot[rel.root])
+        relationsByRoot[rel.root] = [];
+      relationsByRoot[rel.root].push(rel);
+    }
+    const entries = [];
+    for (const [root, rels] of Object.entries(relationsByRoot)) {
+      if (rels.length > 1) {
+        const relNames = rels.map((r) => r.relationName);
+        const msg = `Model "${model.name}" has multiple relations to scope root "${root}" (${relNames.join(", ")}).`;
+        if (onAmbiguousScope === "error") {
+          throw new Error(
+            `prisma-guard: Ambiguous scope detected. Resolve these or set onAmbiguousScope to "warn" or "ignore":
+  - ${msg}`
+          );
+        }
+        if (onAmbiguousScope === "warn") {
+          console.warn(`prisma-guard: ${msg} Excluding model from scope map.`);
+        }
+        continue;
+      }
+      entries.push({
+        fk: rels[0].fks[0],
+        root: rels[0].root,
+        relationName: rels[0].relationName
+      });
+    }
+    if (entries.length > 0) {
+      scopeMap[model.name] = entries;
+    }
+  }
+  const roots = Array.from(rootModels).sort();
+  const mapEntries = Object.entries(scopeMap).map(([model, entries]) => {
+    const entriesStr = entries.map((e) => `{ fk: ${JSON.stringify(e.fk)}, root: ${JSON.stringify(e.root)}, relationName: ${JSON.stringify(e.relationName)} }`).join(", ");
+    return `  ${model}: [${entriesStr}],`;
+  }).join("\n");
+  const scopeRootType = roots.length > 0 ? roots.map((r) => `'${r}'`).join(" | ") : "never";
+  const source = `export const SCOPE_MAP = {
+${mapEntries}
+} as const
+
+export type ScopeRoot = ${scopeRootType}
+`;
+  return { source, roots };
+}
+
+// src/generator/emit-zod-chains.ts
+import { z as z2 } from "zod";
+
+// src/generator/validate-directive.ts
+var ALLOWED_ZOD_METHODS = /* @__PURE__ */ new Set([
+  "min",
+  "max",
+  "length",
+  "email",
+  "url",
+  "uuid",
+  "cuid",
+  "cuid2",
+  "ulid",
+  "trim",
+  "toLowerCase",
+  "toUpperCase",
+  "startsWith",
+  "endsWith",
+  "includes",
+  "datetime",
+  "ip",
+  "cidr",
+  "date",
+  "time",
+  "duration",
+  "base64",
+  "nanoid",
+  "emoji",
+  "int",
+  "positive",
+  "nonnegative",
+  "negative",
+  "nonpositive",
+  "finite",
+  "safe",
+  "multipleOf",
+  "step",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "nonempty",
+  "regex",
+  "readonly",
+  "optional",
+  "nullable",
+  "nullish",
+  "default",
+  "catch"
+]);
+var METHOD_ARITY = {
+  min: [1, 2],
+  max: [1, 2],
+  length: [1, 2],
+  email: [0, 1],
+  url: [0, 1],
+  uuid: [0, 1],
+  cuid: [0, 1],
+  cuid2: [0, 1],
+  ulid: [0, 1],
+  trim: [0, 0],
+  toLowerCase: [0, 0],
+  toUpperCase: [0, 0],
+  startsWith: [1, 2],
+  endsWith: [1, 2],
+  includes: [1, 2],
+  datetime: [0, 1],
+  ip: [0, 1],
+  cidr: [0, 1],
+  date: [0, 1],
+  time: [0, 1],
+  duration: [0, 1],
+  base64: [0, 1],
+  nanoid: [0, 1],
+  emoji: [0, 1],
+  int: [0, 1],
+  positive: [0, 1],
+  nonnegative: [0, 1],
+  negative: [0, 1],
+  nonpositive: [0, 1],
+  finite: [0, 1],
+  safe: [0, 1],
+  multipleOf: [1, 2],
+  step: [1, 2],
+  gt: [1, 2],
+  gte: [1, 2],
+  lt: [1, 2],
+  lte: [1, 2],
+  nonempty: [0, 1],
+  regex: [1, 2],
+  readonly: [0, 0],
+  optional: [0, 0],
+  nullable: [0, 0],
+  nullish: [0, 0],
+  default: [1, 1],
+  catch: [1, 1]
+};
+var MAX_DIRECTIVE_LENGTH = 1024;
+var MAX_CHAIN_DEPTH = 20;
+function validateDirective(raw) {
+  if (raw.length > MAX_DIRECTIVE_LENGTH) {
+    return { valid: false, reason: "Directive exceeds maximum length" };
+  }
+  const input = raw.trim();
+  if (input.length === 0) {
+    return { valid: false, reason: "Empty directive" };
+  }
+  if (input[0] !== ".") {
+    return { valid: false, reason: 'Directive must start with "."' };
+  }
+  let pos = 0;
+  let chainCount = 0;
+  const methods = [];
+  function peek() {
+    return input[pos] ?? "";
+  }
+  function advance() {
+    return input[pos++] ?? "";
+  }
+  function skipWhitespace() {
+    while (pos < input.length && (input[pos] === " " || input[pos] === "	")) {
+      pos++;
+    }
+  }
+  function parseString() {
+    const quote = peek();
+    if (quote !== '"' && quote !== "'")
+      return null;
+    advance();
+    while (pos < input.length) {
+      const ch = input[pos];
+      if (ch === "\\") {
+        const next = input[pos + 1];
+        if (next === "'" || next === '"' || next === "\\") {
+          pos += 2;
+          continue;
+        }
+        return { valid: false, reason: `Invalid escape sequence "\\${next ?? ""}" in string` };
+      }
+      if (ch === quote) {
+        advance();
+        return null;
+      }
+      if (ch.charCodeAt(0) < 32) {
+        return { valid: false, reason: "Control character in string" };
+      }
+      advance();
+    }
+    return { valid: false, reason: "Unterminated string" };
+  }
+  function parseNumber() {
+    const start = pos;
+    if (peek() === "-")
+      advance();
+    if (pos >= input.length || !/[0-9]/.test(peek())) {
+      pos = start;
+      return null;
+    }
+    if (peek() === "0" && pos + 1 < input.length && /[0-9]/.test(input[pos + 1])) {
+      return { valid: false, reason: "Leading zeros not allowed in numbers" };
+    }
+    while (pos < input.length && /[0-9]/.test(peek()))
+      advance();
+    if (peek() === ".") {
+      advance();
+      if (!/[0-9]/.test(peek())) {
+        return { valid: false, reason: "Invalid number: expected digit after decimal point" };
+      }
+      while (pos < input.length && /[0-9]/.test(peek()))
+        advance();
+    }
+    if (peek() === "e" || peek() === "E") {
+      advance();
+      if (peek() === "-")
+        advance();
+      if (peek() === "+") {
+        return { valid: false, reason: 'Invalid number: "+" not allowed in exponent' };
+      }
+      if (!/[0-9]/.test(peek())) {
+        return { valid: false, reason: "Invalid number: expected digit in exponent" };
+      }
+      while (pos < input.length && /[0-9]/.test(peek()))
+        advance();
+    }
+    return null;
+  }
+  function parseRegex() {
+    advance();
+    if (peek() === "/" || peek() === "*") {
+      return { valid: false, reason: "Empty or comment-like regex pattern" };
+    }
+    let inCharClass = false;
+    while (pos < input.length) {
+      const ch = input[pos];
+      if (ch === "\\") {
+        if (pos + 1 >= input.length) {
+          return { valid: false, reason: "Unterminated escape in regex" };
+        }
+        pos += 2;
+        continue;
+      }
+      if (ch === "[" && !inCharClass) {
+        inCharClass = true;
+        pos++;
+        continue;
+      }
+      if (ch === "]" && inCharClass) {
+        inCharClass = false;
+        pos++;
+        continue;
+      }
+      if (ch === "/" && !inCharClass) {
+        advance();
+        while (pos < input.length && /[gimsuy]/.test(peek())) {
+          advance();
+        }
+        return null;
+      }
+      if (ch.charCodeAt(0) < 32 && ch !== "	") {
+        return { valid: false, reason: "Control character in regex" };
+      }
+      pos++;
+    }
+    return { valid: false, reason: "Unterminated regex literal" };
+  }
+  function parseObjectKey() {
+    skipWhitespace();
+    const ch = peek();
+    if (ch === '"' || ch === "'") {
+      return parseString();
+    }
+    if (/[a-zA-Z_]/.test(ch)) {
+      while (pos < input.length && /[a-zA-Z0-9_]/.test(peek())) {
+        advance();
+      }
+      return null;
+    }
+    return { valid: false, reason: "Expected object key (identifier or string)" };
+  }
+  function parseArg() {
+    skipWhitespace();
+    const ch = peek();
+    if (ch === "}") {
+      return { valid: false, reason: 'Unexpected "}" in directive args' };
+    }
+    if (ch === "`") {
+      return { valid: false, reason: "Template literals not allowed in directive args" };
+    }
+    if (ch !== "" && ch.charCodeAt(0) < 32) {
+      return { valid: false, reason: "Control character not allowed outside strings" };
+    }
+    if (ch === '"' || ch === "'") {
+      return parseString();
+    }
+    if (ch === "/") {
+      return parseRegex();
+    }
+    if (ch === "{") {
+      advance();
+      skipWhitespace();
+      if (peek() === "}") {
+        advance();
+        return null;
+      }
+      const keyErr = parseObjectKey();
+      if (keyErr)
+        return keyErr;
+      skipWhitespace();
+      if (peek() !== ":") {
+        return { valid: false, reason: 'Expected ":" after object key' };
+      }
+      advance();
+      const valErr = parseArg();
+      if (valErr)
+        return valErr;
+      skipWhitespace();
+      while (peek() === ",") {
+        advance();
+        skipWhitespace();
+        if (peek() === "}")
+          break;
+        const nextKeyErr = parseObjectKey();
+        if (nextKeyErr)
+          return nextKeyErr;
+        skipWhitespace();
+        if (peek() !== ":") {
+          return { valid: false, reason: 'Expected ":" after object key' };
+        }
+        advance();
+        const nextValErr = parseArg();
+        if (nextValErr)
+          return nextValErr;
+        skipWhitespace();
+      }
+      if (peek() !== "}") {
+        return { valid: false, reason: 'Expected "}" to close object' };
+      }
+      advance();
+      return null;
+    }
+    if (ch === "[") {
+      advance();
+      skipWhitespace();
+      if (peek() === "]") {
+        advance();
+        return null;
+      }
+      const firstErr = parseArg();
+      if (firstErr)
+        return firstErr;
+      skipWhitespace();
+      while (peek() === ",") {
+        advance();
+        skipWhitespace();
+        if (peek() === "]")
+          break;
+        const elemErr = parseArg();
+        if (elemErr)
+          return elemErr;
+        skipWhitespace();
+      }
+      if (peek() !== "]") {
+        return { valid: false, reason: 'Expected "]" to close array' };
+      }
+      advance();
+      return null;
+    }
+    if (ch === "-" || /[0-9]/.test(ch)) {
+      return parseNumber();
+    }
+    if (input.startsWith("true", pos)) {
+      const after = input[pos + 4];
+      if (!after || !/[a-zA-Z0-9_]/.test(after)) {
+        pos += 4;
+        return null;
+      }
+    }
+    if (input.startsWith("false", pos)) {
+      const after = input[pos + 5];
+      if (!after || !/[a-zA-Z0-9_]/.test(after)) {
+        pos += 5;
+        return null;
+      }
+    }
+    if (input.startsWith("NaN", pos)) {
+      return { valid: false, reason: "NaN not allowed" };
+    }
+    if (input.startsWith("Infinity", pos)) {
+      return { valid: false, reason: "Infinity not allowed" };
+    }
+    if (input.startsWith("null", pos)) {
+      return { valid: false, reason: "null not allowed as argument value" };
+    }
+    if (ch === "+") {
+      return { valid: false, reason: '"+" prefix not allowed on numbers' };
+    }
+    if (/[a-zA-Z_]/.test(ch)) {
+      return { valid: false, reason: "Identifiers not allowed as argument values" };
+    }
+    return { valid: false, reason: `Unexpected character "${ch}"` };
+  }
+  while (pos < input.length) {
+    skipWhitespace();
+    if (pos >= input.length)
+      break;
+    if (peek() !== ".") {
+      return { valid: false, reason: `Expected "." at position ${pos}, got "${peek()}"` };
+    }
+    advance();
+    if (!/[a-zA-Z_]/.test(peek())) {
+      return { valid: false, reason: `Expected method name after "." at position ${pos}` };
+    }
+    let ident = "";
+    while (pos < input.length && /[a-zA-Z0-9_]/.test(peek())) {
+      ident += advance();
+    }
+    if (!ALLOWED_ZOD_METHODS.has(ident)) {
+      return { valid: false, reason: `Unknown zod method: ${ident}` };
+    }
+    skipWhitespace();
+    if (peek() !== "(") {
+      return { valid: false, reason: `Expected "(" after method "${ident}"` };
+    }
+    advance();
+    skipWhitespace();
+    let argCount = 0;
+    if (peek() !== ")") {
+      const argErr = parseArg();
+      if (argErr)
+        return argErr;
+      argCount = 1;
+      skipWhitespace();
+      while (peek() === ",") {
+        advance();
+        skipWhitespace();
+        if (peek() === ")")
+          break;
+        const nextArgErr = parseArg();
+        if (nextArgErr)
+          return nextArgErr;
+        argCount++;
+        skipWhitespace();
+      }
+    }
+    if (peek() !== ")") {
+      return { valid: false, reason: `Expected ")" to close method "${ident}"` };
+    }
+    advance();
+    const arity = METHOD_ARITY[ident];
+    if (arity) {
+      const [minArgs, maxArgs] = arity;
+      if (argCount < minArgs || argCount > maxArgs) {
+        if (minArgs === maxArgs) {
+          return { valid: false, reason: `Method "${ident}" expects ${minArgs} argument(s), got ${argCount}` };
+        }
+        return { valid: false, reason: `Method "${ident}" expects ${minArgs}-${maxArgs} arguments, got ${argCount}` };
+      }
+    }
+    methods.push(ident);
+    chainCount++;
+    if (chainCount > MAX_CHAIN_DEPTH) {
+      return { valid: false, reason: "Directive exceeds maximum chain depth" };
+    }
+  }
+  if (chainCount === 0) {
+    return { valid: false, reason: "No method calls found" };
+  }
+  return { valid: true, methods };
+}
+
+// src/shared/scalar-base.ts
+import { z } from "zod";
+function isJsonSafe(value) {
+  const stack = [value];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (current === void 0)
+      return false;
+    if (current === null)
+      continue;
+    switch (typeof current) {
+      case "string":
+      case "boolean":
+        continue;
+      case "number":
+        if (!Number.isFinite(current))
+          return false;
+        continue;
+      case "object": {
+        if (Array.isArray(current)) {
+          for (let i = 0; i < current.length; i++) {
+            stack.push(current[i]);
+          }
+          continue;
+        }
+        const proto = Object.getPrototypeOf(current);
+        if (proto !== Object.prototype && proto !== null)
+          return false;
+        const values = Object.values(current);
+        for (let i = 0; i < values.length; i++) {
+          stack.push(values[i]);
+        }
+        continue;
+      }
+      default:
+        return false;
+    }
+  }
+  return true;
+}
+var SCALAR_BASE = {
+  String: () => z.string(),
+  Int: () => z.number().int(),
+  Float: () => z.number(),
+  Decimal: () => z.union([
+    z.number(),
+    z.string().refine(
+      (s) => /^-?(\d+\.?\d*|\.\d+)([eE]-?\d+)?$/.test(s),
+      "Invalid decimal string"
+    )
+  ]),
+  BigInt: () => z.union([
+    z.bigint(),
+    z.number().int().refine(
+      (v) => v >= Number.MIN_SAFE_INTEGER && v <= Number.MAX_SAFE_INTEGER,
+      "Number exceeds safe integer range for BigInt conversion"
+    ).transform((v) => BigInt(v)),
+    z.string().regex(/^-?\d+$/).transform((v) => BigInt(v))
+  ]),
+  Boolean: () => z.boolean(),
+  DateTime: () => z.union([
+    z.date(),
+    z.string().datetime({ offset: true }),
+    z.string().datetime()
+  ]).pipe(z.coerce.date()),
+  Json: () => z.unknown().refine(isJsonSafe, "Value must be JSON-serializable (no undefined, functions, symbols, class instances, NaN, or Infinity)"),
+  Bytes: () => z.union([
+    z.string(),
+    z.custom((v) => v instanceof Uint8Array)
+  ])
+};
+
+// src/generator/emit-zod-chains.ts
+function buildGenerationBase(fieldType, isList, isEnum, enumValues) {
+  let base;
+  if (isEnum) {
+    const values = enumValues && enumValues.length > 0 ? enumValues : ["__placeholder__"];
+    base = z2.enum(values);
+  } else {
+    const factory = SCALAR_BASE[fieldType];
+    if (!factory)
+      return null;
+    base = factory();
+  }
+  if (isList)
+    base = z2.array(base);
+  return base;
+}
+function checkChainCompatibility(fieldType, isList, isEnum, enumValues, methods) {
+  const base = buildGenerationBase(fieldType, isList, isEnum, enumValues);
+  if (!base)
+    return null;
+  for (const method of methods) {
+    if (typeof base[method] !== "function") {
+      return method;
+    }
+  }
+  return null;
+}
+function findZodInDoc(documentation) {
+  return documentation.split("\n").filter((line) => {
+    const trimmed = line.trim();
+    return /^@zod(?:\s|$|\.)/.test(trimmed);
+  });
+}
+function emitZodChains(dmmf, onInvalidZod) {
+  const enumNames = new Set(dmmf.datamodel.enums.map((e) => e.name));
+  const enumValues = {};
+  for (const e of dmmf.datamodel.enums) {
+    enumValues[e.name] = e.values.map((v) => v.name);
+  }
+  const modelChains = {};
+  for (const model of dmmf.datamodel.models) {
+    for (const field of model.fields) {
+      if (!field.documentation)
+        continue;
+      const zodLines = findZodInDoc(field.documentation);
+      if (zodLines.length === 0)
+        continue;
+      if (zodLines.length > 1) {
+        const msg = `prisma-guard: Multiple @zod directives on ${model.name}.${field.name}. Only one @zod per field allowed.`;
+        if (onInvalidZod === "error") {
+          throw new Error(msg);
+        }
+        console.warn(msg);
+        continue;
+      }
+      const line = zodLines[0];
+      const idx = line.indexOf("@zod");
+      const chainStr = line.slice(idx + 4).trim();
+      if (chainStr.length === 0) {
+        const msg = `prisma-guard: Empty @zod directive on ${model.name}.${field.name}. Add a method chain (e.g. @zod .min(1)) or remove the directive.`;
+        if (onInvalidZod === "error") {
+          throw new Error(msg);
+        }
+        console.warn(msg);
+        continue;
+      }
+      const result = validateDirective(chainStr);
+      if (!result.valid) {
+        const msg = `prisma-guard: Invalid @zod directive on ${model.name}.${field.name}: ${result.reason}`;
+        if (onInvalidZod === "error") {
+          throw new Error(msg);
+        }
+        console.warn(msg);
+        continue;
+      }
+      const isEnum = enumNames.has(field.type);
+      const incompatible = checkChainCompatibility(
+        field.type,
+        field.isList,
+        isEnum,
+        isEnum ? enumValues[field.type] : void 0,
+        result.methods
+      );
+      if (incompatible) {
+        const msg = `prisma-guard: @zod method "${incompatible}" on ${model.name}.${field.name} is not compatible with type "${field.type}"${field.isList ? "[]" : ""}`;
+        if (onInvalidZod === "error") {
+          throw new Error(msg);
+        }
+        console.warn(msg);
+        continue;
+      }
+      if (!modelChains[model.name])
+        modelChains[model.name] = {};
+      modelChains[model.name][field.name] = chainStr;
+    }
+  }
+  const hasChains = Object.keys(modelChains).length > 0;
+  if (!hasChains) {
+    return { source: "export const ZOD_CHAINS = {}\n", hasChains: false };
+  }
+  const entries = Object.entries(modelChains).map(([model, fields]) => {
+    const fieldEntries = Object.entries(fields).map(([field, chain]) => `    ${JSON.stringify(field)}: (base: any) => base${chain},`).join("\n");
+    return `  ${JSON.stringify(model)}: {
+${fieldEntries}
+  },`;
+  }).join("\n");
+  return {
+    source: `export const ZOD_CHAINS = {
+${entries}
+}
+`,
+    hasChains: true
+  };
+}
+
+// src/generator/emit-type-map.ts
+var SKIP_FIELD_KINDS = /* @__PURE__ */ new Set(["unsupported"]);
+function collectUniqueConstraints(model) {
+  const seen = /* @__PURE__ */ new Set();
+  const constraints = [];
+  function add(fields) {
+    const key = fields.join("\0");
+    if (seen.has(key))
+      return;
+    seen.add(key);
+    constraints.push(fields);
+  }
+  for (const field of model.fields) {
+    if (field.isId)
+      add([field.name]);
+  }
+  if (model.primaryKey) {
+    add([...model.primaryKey.fields]);
+  }
+  for (const field of model.fields) {
+    if (field.isUnique)
+      add([field.name]);
+  }
+  for (const fields of model.uniqueFields) {
+    add([...fields]);
+  }
+  return constraints;
+}
+function emitTypeMap(dmmf) {
+  const enumNames = new Set(dmmf.datamodel.enums.map((e) => e.name));
+  for (const e of dmmf.datamodel.enums) {
+    if (e.values.length === 0) {
+      throw new Error(`prisma-guard: Enum "${e.name}" has zero values.`);
+    }
+  }
+  const modelEntries = dmmf.datamodel.models.map((model) => {
+    const fieldEntries = model.fields.filter((field) => !SKIP_FIELD_KINDS.has(field.kind)).map((field) => {
+      const isRelation = field.kind === "object" || field.relationName != null;
+      const isEnum = enumNames.has(field.type);
+      const meta = [
+        `type: ${JSON.stringify(field.type)}`,
+        `isList: ${field.isList}`,
+        `isRequired: ${field.isRequired}`,
+        `isId: ${field.isId}`,
+        `isRelation: ${isRelation}`,
+        `hasDefault: ${field.hasDefaultValue}`,
+        `isUpdatedAt: ${field.isUpdatedAt}`
+      ];
+      if (isEnum)
+        meta.push(`isEnum: true`);
+      if (field.isUnique)
+        meta.push(`isUnique: true`);
+      return `    ${JSON.stringify(field.name)}: { ${meta.join(", ")} },`;
+    }).join("\n");
+    return `  ${JSON.stringify(model.name)}: {
+${fieldEntries}
+  },`;
+  }).join("\n");
+  const enumEntries = dmmf.datamodel.enums.map((e) => {
+    const values = e.values.map((v) => JSON.stringify(v.name)).join(", ");
+    return `  ${JSON.stringify(e.name)}: [${values}],`;
+  }).join("\n");
+  const uniqueMapEntries = dmmf.datamodel.models.map((model) => {
+    const constraints = collectUniqueConstraints(model);
+    if (constraints.length === 0)
+      return null;
+    const constraintsStr = constraints.map((c) => `[${c.map((f) => JSON.stringify(f)).join(", ")}]`).join(", ");
+    return `  ${JSON.stringify(model.name)}: [${constraintsStr}],`;
+  }).filter(Boolean).join("\n");
+  const typeMapSource = `export const TYPE_MAP = {
+${modelEntries}
+} as const
+`;
+  const enumMapSource = `export const ENUM_MAP = {
+${enumEntries}
+} as const
+`;
+  const uniqueMapSource = `export const UNIQUE_MAP = {
+${uniqueMapEntries}
+} as const
+`;
+  const typesSource = [
+    `export type ModelName = keyof typeof TYPE_MAP`,
+    `export type FieldName<M extends ModelName> = keyof (typeof TYPE_MAP)[M]`
+  ].join("\n");
+  return `${typeMapSource}
+${enumMapSource}
+${uniqueMapSource}
+${typesSource}
+`;
+}
+
+// src/generator/emit-client.ts
+function toDelegateKey(modelName) {
+  return modelName[0].toLowerCase() + modelName.slice(1);
+}
+function emitClient(dmmf) {
+  const modelEntries = dmmf.datamodel.models.map((model) => {
+    const key = toDelegateKey(model.name);
+    return `    ${key}: {
+      guard(input: GuardInput): GuardedModel<PrismaClient['${key}']>
+    }`;
+  }).join("\n");
+  return `import type { PrismaClient } from '@prisma/client'
+import type { GuardInput, GuardedModel } from 'prisma-guard'
+import { createGuard } from 'prisma-guard'
+import { SCOPE_MAP, TYPE_MAP, ENUM_MAP, ZOD_CHAINS, GUARD_CONFIG, UNIQUE_MAP } from './index.js'
+import type { ScopeRoot } from './index.js'
+
+interface GuardModelExtension {
+${modelEntries}
+}
+
+export const guard = createGuard<typeof TYPE_MAP, ScopeRoot, GuardModelExtension>({
+  scopeMap: SCOPE_MAP,
+  typeMap: TYPE_MAP,
+  enumMap: ENUM_MAP,
+  zodChains: ZOD_CHAINS,
+  guardConfig: GUARD_CONFIG,
+  uniqueMap: UNIQUE_MAP,
+})
+`;
+}
+
+// src/generator/index.ts
+var { generatorHandler } = pkg;
+var VALID_ON_INVALID_ZOD = /* @__PURE__ */ new Set(["error", "warn"]);
+var VALID_ON_AMBIGUOUS_SCOPE = /* @__PURE__ */ new Set(["error", "warn", "ignore"]);
+var VALID_ON_MISSING_SCOPE_CONTEXT = /* @__PURE__ */ new Set(["error", "warn", "ignore"]);
+var VALID_FIND_UNIQUE_MODE = /* @__PURE__ */ new Set(["verify", "reject"]);
+var VALID_ON_SCOPE_RELATION_WRITE = /* @__PURE__ */ new Set(["error", "warn", "strip"]);
+function validateConfigEnum(name, value, allowed) {
+  if (!allowed.has(value)) {
+    throw new Error(
+      `prisma-guard: Invalid generator config "${name}": "${value}". Allowed values: ${[...allowed].join(", ")}`
+    );
+  }
+  return value;
+}
+generatorHandler({
+  onManifest() {
+    return {
+      prettyName: "Prisma Guard",
+      defaultOutput: "generated/guard"
+    };
+  },
+  async onGenerate(options) {
+    const output = options.generator.output?.value;
+    if (!output)
+      throw new Error("prisma-guard: No output directory specified");
+    const config = options.generator.config ?? {};
+    const onInvalidZod = validateConfigEnum("onInvalidZod", config.onInvalidZod ?? "error", VALID_ON_INVALID_ZOD);
+    const onAmbiguousScope = validateConfigEnum("onAmbiguousScope", config.onAmbiguousScope ?? "error", VALID_ON_AMBIGUOUS_SCOPE);
+    const onMissingScopeContext = validateConfigEnum("onMissingScopeContext", config.onMissingScopeContext ?? "error", VALID_ON_MISSING_SCOPE_CONTEXT);
+    const findUniqueMode = validateConfigEnum("findUniqueMode", config.findUniqueMode ?? "reject", VALID_FIND_UNIQUE_MODE);
+    const onScopeRelationWrite = validateConfigEnum("onScopeRelationWrite", config.onScopeRelationWrite ?? "error", VALID_ON_SCOPE_RELATION_WRITE);
+    const dmmf = options.dmmf;
+    const parts = [];
+    parts.push(
+      `export const GUARD_CONFIG = {
+  onMissingScopeContext: ${JSON.stringify(onMissingScopeContext)},
+  findUniqueMode: ${JSON.stringify(findUniqueMode)},
+  onScopeRelationWrite: ${JSON.stringify(onScopeRelationWrite)},
+} as const
+`
+    );
+    const { source: scopeSource } = emitScopeMap(dmmf, onAmbiguousScope);
+    parts.push(scopeSource);
+    const typeMapSource = emitTypeMap(dmmf);
+    parts.push(typeMapSource);
+    const { source: zodChainsSource } = emitZodChains(dmmf, onInvalidZod);
+    parts.push(zodChainsSource);
+    mkdirSync(output, { recursive: true });
+    writeFileSync(join(output, "index.ts"), parts.join("\n"), "utf-8");
+    const clientSource = emitClient(dmmf);
+    writeFileSync(join(output, "client.ts"), clientSource, "utf-8");
+  }
+});
+//# sourceMappingURL=index.js.map