prisma-guard 1.27.0 → 1.28.0

package/dist/generator/index.js

@@ -2,8 +2,91 @@
 
 // src/generator/index.ts
 import pkg from "@prisma/generator-helper";
-import { mkdirSync, writeFileSync } from "fs";
+import { existsSync as existsSync2, mkdirSync, rmSync, writeFileSync } from "fs";
 import { relative } from "path";
+import { z as z3 } from "zod";
+
+// src/generator/import-style.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, join, resolve } from "path";
+import { getTsconfig } from "get-tsconfig";
+var NODE_ESM_MODES = /* @__PURE__ */ new Set(["node16", "node18", "nodenext"]);
+var NO_EXTENSION_RESOLUTIONS = /* @__PURE__ */ new Set(["bundler", "classic", "node", "node10"]);
+function findUpwards(startDir, filename) {
+  let dir = resolve(startDir);
+  while (true) {
+    const candidate = join(dir, filename);
+    if (existsSync(candidate))
+      return candidate;
+    const parent = dirname(dir);
+    if (parent === dir)
+      return null;
+    dir = parent;
+  }
+}
+function readCompilerOptions(startDir) {
+  try {
+    const result = getTsconfig(startDir);
+    if (!result)
+      return {};
+    const co = result.config.compilerOptions;
+    if (!co || typeof co !== "object")
+      return {};
+    return co;
+  } catch {
+    return {};
+  }
+}
+function readPackageType(startDir) {
+  const pkgPath = findUpwards(startDir, "package.json");
+  if (!pkgPath)
+    return null;
+  try {
+    const raw = readFileSync(pkgPath, "utf-8");
+    const pkg2 = JSON.parse(raw);
+    return typeof pkg2.type === "string" ? pkg2.type : null;
+  } catch {
+    return null;
+  }
+}
+function resolveImportStyle(startDir, override) {
+  if (override !== "auto")
+    return override;
+  const co = readCompilerOptions(startDir);
+  if (co.allowImportingTsExtensions === true)
+    return "ts";
+  const moduleValue = typeof co.module === "string" ? co.module.toLowerCase() : "";
+  const resolutionValue = typeof co.moduleResolution === "string" ? co.moduleResolution.toLowerCase() : "";
+  if (NODE_ESM_MODES.has(moduleValue) || NODE_ESM_MODES.has(resolutionValue)) {
+    return "js";
+  }
+  if (NO_EXTENSION_RESOLUTIONS.has(resolutionValue)) {
+    return "none";
+  }
+  if (readPackageType(startDir) === "module")
+    return "js";
+  return "none";
+}
+function withImportStyle(path, style) {
+  if (style === "js")
+    return `${path}.js`;
+  if (style === "ts")
+    return `${path}.ts`;
+  return path;
+}
+function withClientImportStyle(path, style, kind) {
+  if (kind === "package")
+    return path;
+  if (!path.startsWith("."))
+    return path;
+  if (kind === "prisma-client") {
+    const entry = `${path}/client`;
+    return withImportStyle(entry, style);
+  }
+  if (style === "js")
+    return `${path}/index.js`;
+  return path;
+}
 
 // src/generator/emit-client.ts
 function delegateKey(modelName) {
@@ -21,12 +104,18 @@ ${entries}
 }
 `;
 }
-function emitClient(dmmf, prismaClientImport) {
-  return `import type { PrismaClient } from '${prismaClientImport}'
-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, ZOD_DEFAULTS } from './index'
-import type { ScopeRoot } from './index'
+function emitClient(dmmf, prismaClientImport, prismaClientKind, importStyle, runtimeImportPath) {
+  const indexImport = withImportStyle("./index", importStyle);
+  const clientImport = withClientImportStyle(
+    prismaClientImport,
+    importStyle,
+    prismaClientKind
+  );
+  return `import type { PrismaClient } from '${clientImport}'
+import type { GuardInput, GuardedModel } from '${runtimeImportPath}'
+import { createGuard } from '${runtimeImportPath}'
+import { SCOPE_MAP, TYPE_MAP, ENUM_MAP, ZOD_CHAINS, GUARD_CONFIG, UNIQUE_MAP, ZOD_DEFAULTS } from '${indexImport}'
+import type { ScopeRoot } from '${indexImport}'
 
 ` + emitGuardModelExtension(dmmf) + `
 export const guard = createGuard<typeof TYPE_MAP, ScopeRoot, GuardModelExtension>({
@@ -48,6 +137,15 @@ function isScopeRoot(documentation) {
   const tokens = documentation.split(/[\s\n\r]+/);
   return tokens.some((t) => t === "@scope-root");
 }
+function reportScopeIssue(mode, errorMsg, warnMsg) {
+  if (mode === "error")
+    throw new Error(`prisma-guard: ${errorMsg}`);
+  if (mode === "warn")
+    console.warn(`prisma-guard: ${warnMsg}`);
+}
+function serializeScopeEntry(e) {
+  return `{ fk: ${JSON.stringify(e.fk)}, root: ${JSON.stringify(e.root)}, relationName: ${JSON.stringify(e.relationName)} }`;
+}
 function emitScopeMap(dmmf, onAmbiguousScope) {
   const rootModels = /* @__PURE__ */ new Set();
   for (const model of dmmf.datamodel.models) {
@@ -66,13 +164,9 @@ function emitScopeMap(dmmf, onAmbiguousScope) {
       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 relation "${field.name}" to scope root "${field.type}" from scope map for model "${model.name}".`);
-        }
+        const compositeMsg = `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.`;
+        const excludeMsg = `${compositeMsg} Excluding relation "${field.name}" to scope root "${field.type}" from scope map for model "${model.name}".`;
+        reportScopeIssue(onAmbiguousScope, compositeMsg, excludeMsg);
         continue;
       }
       relations.push({
@@ -93,16 +187,11 @@ function emitScopeMap(dmmf, onAmbiguousScope) {
     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 relations to scope root "${root}" from scope map for model "${model.name}".`);
-        }
+        const ambiguousMsg = `Model "${model.name}" has multiple relations to scope root "${root}" (${relNames.join(", ")}).`;
+        const errorMsg = `Ambiguous scope detected. Resolve these or set onAmbiguousScope to "warn" or "ignore":
+  - ${ambiguousMsg}`;
+        const warnMsg = `${ambiguousMsg} Excluding relations to scope root "${root}" from scope map for model "${model.name}".`;
+        reportScopeIssue(onAmbiguousScope, errorMsg, warnMsg);
         continue;
       }
       entries.push({
@@ -117,7 +206,7 @@ function emitScopeMap(dmmf, onAmbiguousScope) {
   }
   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(", ");
+    const entriesStr = entries.map(serializeScopeEntry).join(", ");
     return `  ${model}: [${entriesStr}],`;
   }).join("\n");
   const scopeRootType = roots.length > 0 ? roots.map((r) => `'${r}'`).join(" | ") : "never";
@@ -130,19 +219,19 @@ export type ScopeRoot = ${scopeRootType}
   return { source };
 }
 
-// src/generator/emit-type-map.ts
+// src/shared/unique-constraints.ts
 function uniqueSelector(fields, name) {
   if (typeof name === "string" && name.trim().length > 0)
     return name;
   return fields.join("_");
 }
+function fieldsKey(fields) {
+  return fields.join("\0");
+}
 function collectUniqueConstraints(model) {
   const fieldSetSeen = /* @__PURE__ */ new Set();
   const selectorToFields = /* @__PURE__ */ new Map();
   const constraints = [];
-  function fieldsKey(fields) {
-    return fields.join("\0");
-  }
   function add(fields, selector) {
     if (fields.length === 0)
       return;
@@ -183,6 +272,11 @@ function collectUniqueConstraints(model) {
   }
   return constraints;
 }
+
+// src/generator/emit-type-map.ts
+function serializeMeta(entries) {
+  return entries.map(([key, value]) => `${key}: ${JSON.stringify(value)}`).join(", ");
+}
 function emitTypeMap(dmmf) {
   const enumNames = new Set(dmmf.datamodel.enums.map((e) => e.name));
   for (const e of dmmf.datamodel.enums) {
@@ -195,22 +289,22 @@ function emitTypeMap(dmmf) {
       const isRelation = field.kind === "object" || field.relationName != null;
       const isEnum = enumNames.has(field.type);
       const isUnsupported = field.kind === "unsupported";
-      const meta = [
-        `type: ${JSON.stringify(field.type)}`,
-        `isList: ${field.isList}`,
-        `isRequired: ${field.isRequired}`,
-        `isId: ${field.isId}`,
-        `isRelation: ${isRelation}`,
-        `hasDefault: ${field.hasDefaultValue}`,
-        `isUpdatedAt: ${field.isUpdatedAt}`
+      const metaPairs = [
+        ["type", 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`);
+        metaPairs.push(["isEnum", true]);
       if (isUnsupported)
-        meta.push(`isUnsupported: true`);
+        metaPairs.push(["isUnsupported", true]);
       if (field.isUnique)
-        meta.push(`isUnique: true`);
-      return `    ${JSON.stringify(field.name)}: { ${meta.join(", ")} },`;
+        metaPairs.push(["isUnique", true]);
+      return `    ${JSON.stringify(field.name)}: { ${serializeMeta(metaPairs)} },`;
     }).join("\n");
     return `  ${JSON.stringify(model.name)}: {
 ${fieldEntries}
@@ -260,7 +354,6 @@ var OPERATION_SHAPE_KEYS = {
   findFirstOrThrow: ["where", "include", "select", "orderBy", "cursor", "take", "skip", "distinct"],
   findUnique: ["where", "include", "select"],
   findUniqueOrThrow: ["where", "include", "select"],
-  findManyPaginated: ["where", "include", "select", "orderBy", "cursor", "take", "skip", "distinct"],
   count: ["where", "select", "cursor", "orderBy", "skip", "take"],
   aggregate: ["where", "orderBy", "cursor", "take", "skip", "_count", "_avg", "_sum", "_min", "_max"],
   groupBy: ["where", "by", "having", "_count", "_avg", "_sum", "_min", "_max", "orderBy", "take", "skip"],
@@ -301,8 +394,9 @@ var OPERATIONS = Object.keys(OPERATION_SHAPE_KEYS);
 function cap(s) {
   return s.charAt(0).toUpperCase() + s.slice(1);
 }
-function emitTypedShapes(dmmf, depth) {
-  const header = `import type { TYPE_MAP, UNIQUE_MAP } from './index'
+function emitTypedShapes(dmmf, depth, importStyle, runtimeImportPath) {
+  const indexImport = withImportStyle("./index", importStyle);
+  const header = `import type { TYPE_MAP, UNIQUE_MAP } from '${indexImport}'
 import type {
   TypedGuardShape,
   OperationShape,
@@ -310,7 +404,7 @@ import type {
   TypedProjection,
   TypedInclude,
   TypedCountSelect,
-} from 'prisma-guard'
+} from '${runtimeImportPath}'
 
 type TM = typeof TYPE_MAP
 type UM = typeof UNIQUE_MAP
@@ -766,6 +860,18 @@ function validateDirective(raw) {
 
 // src/shared/scalar-base.ts
 import { z } from "zod";
+function isPrismaNullSentinel(value) {
+  if (value === null || typeof value !== "object")
+    return false;
+  const tag = value._tag;
+  if (tag === "DbNull" || tag === "JsonNull" || tag === "AnyNull")
+    return true;
+  const constructorName = value.constructor?.name;
+  if (constructorName === "DbNull" || constructorName === "JsonNull" || constructorName === "AnyNull") {
+    return true;
+  }
+  return false;
+}
 function isJsonSafe(value) {
   const stack = [{ tag: "visit", value }];
   const ancestors = /* @__PURE__ */ new Set();
@@ -780,6 +886,8 @@ function isJsonSafe(value) {
       return false;
     if (current === null)
       continue;
+    if (isPrismaNullSentinel(current))
+      continue;
     switch (typeof current) {
       case "string":
       case "boolean":
@@ -873,39 +981,11 @@ function buildGenerationBase(fieldType, isList, isEnum, enumValues) {
     base = z2.array(base);
   return base;
 }
-var TYPE_CHANGING_METHODS = /* @__PURE__ */ new Set([
-  "optional",
-  "nullable",
-  "nullish",
-  "readonly",
-  "default",
-  "catch"
-]);
-function checkChainCompatibility(fieldType, isList, isEnum, enumValues, methods) {
-  let current = buildGenerationBase(fieldType, isList, isEnum, enumValues);
-  if (!current)
-    return null;
-  for (const method of methods) {
-    if (typeof current[method] !== "function") {
-      return method;
-    }
-    if (TYPE_CHANGING_METHODS.has(method)) {
-      try {
-        if (method === "default" || method === "catch") {
-          current = current[method](void 0);
-        } else {
-          current = current[method]();
-        }
-      } catch {
-      }
-    }
-  }
-  return null;
-}
 function verifyChainExecution(fieldType, isList, isEnum, enumValues, chainStr) {
   const base = buildGenerationBase(fieldType, isList, isEnum, enumValues);
-  if (!base)
-    return null;
+  if (!base) {
+    return `Unsupported field type "${fieldType}" for @zod directive`;
+  }
   let fn;
   try {
     fn = new Function("base", `'use strict'; return base${chainStr}`);
@@ -936,6 +1016,11 @@ function emitZodChains(dmmf, onInvalidZod) {
   }
   const modelChains = {};
   const defaults = {};
+  function fail(msg) {
+    if (onInvalidZod === "error")
+      throw new Error(msg);
+    console.warn(msg);
+  }
   for (const model of dmmf.datamodel.models) {
     for (const field of model.fields) {
       if (!field.documentation)
@@ -944,49 +1029,22 @@ function emitZodChains(dmmf, onInvalidZod) {
       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);
+        fail(`prisma-guard: Multiple @zod directives on ${model.name}.${field.name}. Only one @zod per field allowed.`);
         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);
+        fail(`prisma-guard: Empty @zod directive on ${model.name}.${field.name}. Add a method chain (e.g. @zod .min(1)) or remove the directive.`);
         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);
+      if (result.valid === false) {
+        fail(`prisma-guard: Invalid @zod directive on ${model.name}.${field.name}: ${result.reason}`);
         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;
-      }
       const execError = verifyChainExecution(
         field.type,
         field.isList,
@@ -995,11 +1053,7 @@ function emitZodChains(dmmf, onInvalidZod) {
         chainStr
       );
       if (execError) {
-        const msg = `prisma-guard: @zod directive on ${model.name}.${field.name} fails at schema construction: ${execError}`;
-        if (onInvalidZod === "error") {
-          throw new Error(msg);
-        }
-        console.warn(msg);
+        fail(`prisma-guard: @zod directive on ${model.name}.${field.name} fails at schema construction: ${execError}`);
         continue;
       }
       if (!modelChains[model.name])
@@ -1034,38 +1088,29 @@ ${entries}
 
 // 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"]);
-var VALID_BOOLEAN_CONFIG = /* @__PURE__ */ new Set(["true", "false"]);
-var VALID_TYPED_GUARD_DEPTH = /* @__PURE__ */ new Set(["0", "1", "2", "3"]);
-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;
-}
-function validateBooleanConfig(name, raw, fallback) {
-  const value = raw ?? (fallback ? "true" : "false");
-  if (!VALID_BOOLEAN_CONFIG.has(value)) {
-    throw new Error(
-      `prisma-guard: Invalid generator config "${name}": "${value}". Allowed values: true, false`
-    );
-  }
-  return value === "true";
-}
-function validateDepthConfig(raw) {
-  const value = raw ?? "1";
-  if (!VALID_TYPED_GUARD_DEPTH.has(value)) {
-    throw new Error(
-      `prisma-guard: Invalid generator config "typedGuardRelationDepth": "${value}". Allowed values: 0, 1, 2, 3`
-    );
-  }
-  return Number(value);
+var booleanConfig = z3.enum(["true", "false"]).transform((v) => v === "true");
+var configSchema = z3.object({
+  onInvalidZod: z3.enum(["error", "warn"]).default("error"),
+  onAmbiguousScope: z3.enum(["error", "warn", "ignore"]).default("error"),
+  onMissingScopeContext: z3.enum(["error", "warn", "ignore"]).default("error"),
+  findUniqueMode: z3.enum(["verify", "reject"]).default("reject"),
+  onScopeRelationWrite: z3.enum(["error", "warn", "strip"]).default("error"),
+  strictDecimal: booleanConfig.default(false),
+  enforceProjection: booleanConfig.default(false),
+  typedGuardShapes: booleanConfig.default(true),
+  typedGuardRelationDepth: z3.enum(["0", "1", "2", "3"]).default("1").transform((v) => Number(v)),
+  importStyle: z3.enum(["auto", "none", "js", "ts"]).default("auto"),
+  runtimeImportPath: z3.string().trim().min(1, "runtimeImportPath must be a non-empty string").default("prisma-guard")
+});
+function parseGeneratorConfig(raw) {
+  const result = configSchema.safeParse(raw);
+  if (result.success)
+    return result.data;
+  const issues = result.error.issues.map((issue) => {
+    const path = issue.path.length > 0 ? issue.path.join(".") : "(root)";
+    return `"${path}": ${issue.message}`;
+  }).join("; ");
+  throw new Error(`prisma-guard: Invalid generator config: ${issues}`);
 }
 function emitZodDefaults(defaults) {
   const entries = Object.entries(defaults);
@@ -1092,24 +1137,46 @@ function getProviderValue(provider) {
   }
   return "";
 }
-function isPrismaClientProvider(provider) {
+function classifyPrismaProvider(provider) {
   const value = getProviderValue(provider);
-  return value === "prisma-client-js" || value.endsWith("/prisma-client-js");
+  if (value === "prisma-client-js" || value.endsWith("/prisma-client-js")) {
+    return "prisma-client-js";
+  }
+  if (value === "prisma-client" || value.endsWith("/prisma-client")) {
+    return "prisma-client";
+  }
+  return null;
 }
 function normalizeImportPath(path) {
   const normalized = path.replace(/\\/g, "/");
+  if (normalized.startsWith("/") || /^[A-Za-z]:/.test(normalized)) {
+    return "@prisma/client";
+  }
   if (normalized.startsWith("."))
     return normalized;
   return `./${normalized}`;
 }
 function resolvePrismaClientImport(options, guardOutput) {
-  const prismaClientGenerator = options.otherGenerators.find(
-    (generator) => isPrismaClientProvider(generator.provider)
-  );
-  const clientOutput = prismaClientGenerator?.output?.value;
-  if (!clientOutput)
-    return "@prisma/client";
-  return normalizeImportPath(relative(guardOutput, clientOutput));
+  let matched = null;
+  for (const generator of options.otherGenerators) {
+    const providerKind = classifyPrismaProvider(generator.provider);
+    if (!providerKind)
+      continue;
+    const output = generator.output?.value;
+    if (!output)
+      continue;
+    matched = { provider: providerKind, output };
+    break;
+  }
+  if (!matched)
+    return { path: "@prisma/client", kind: "package" };
+  const rel = relative(guardOutput, matched.output);
+  if (rel.length === 0)
+    return { path: "@prisma/client", kind: "package" };
+  return {
+    path: normalizeImportPath(rel),
+    kind: matched.provider
+  };
 }
 generatorHandler({
   onManifest() {
@@ -1122,80 +1189,48 @@ generatorHandler({
     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 strictDecimal = validateBooleanConfig(
-      "strictDecimal",
-      config.strictDecimal,
-      false
-    );
-    const enforceProjection = validateBooleanConfig(
-      "enforceProjection",
-      config.enforceProjection,
-      false
-    );
-    const typedGuardShapes = validateBooleanConfig(
-      "typedGuardShapes",
-      config.typedGuardShapes,
-      true
-    );
-    const typedGuardRelationDepth = validateDepthConfig(
-      config.typedGuardRelationDepth
-    );
+    const rawConfig = options.generator.config ?? {};
+    const cfg = parseGeneratorConfig(rawConfig);
+    const importStyle = resolveImportStyle(output, cfg.importStyle);
     const dmmf = options.dmmf;
     const parts = [];
     parts.push(
       `export const GUARD_CONFIG = {
-  onMissingScopeContext: ${JSON.stringify(onMissingScopeContext)},
-  findUniqueMode: ${JSON.stringify(findUniqueMode)},
-  onScopeRelationWrite: ${JSON.stringify(onScopeRelationWrite)},
-  strictDecimal: ${JSON.stringify(strictDecimal)},
-  enforceProjection: ${JSON.stringify(enforceProjection)},
+  onMissingScopeContext: ${JSON.stringify(cfg.onMissingScopeContext)},
+  findUniqueMode: ${JSON.stringify(cfg.findUniqueMode)},
+  onScopeRelationWrite: ${JSON.stringify(cfg.onScopeRelationWrite)},
+  strictDecimal: ${JSON.stringify(cfg.strictDecimal)},
+  enforceProjection: ${JSON.stringify(cfg.enforceProjection)},
 } as const
 `
     );
-    const { source: scopeSource } = emitScopeMap(dmmf, onAmbiguousScope);
+    const { source: scopeSource } = emitScopeMap(dmmf, cfg.onAmbiguousScope);
     parts.push(scopeSource);
     const typeMapSource = emitTypeMap(dmmf);
     parts.push(typeMapSource);
-    const { source: zodChainsSource, defaults } = emitZodChains(dmmf, onInvalidZod);
+    const { source: zodChainsSource, defaults } = emitZodChains(dmmf, cfg.onInvalidZod);
     parts.push(zodChainsSource);
     parts.push(emitZodDefaults(defaults));
     mkdirSync(output, { recursive: true });
     writeFileSync(`${output}/index.ts`, parts.join("\n"), "utf-8");
-    const prismaClientImport = resolvePrismaClientImport(options, output);
-    const clientSource = emitClient(dmmf, prismaClientImport);
+    const { path: prismaClientImport, kind: prismaClientKind } = resolvePrismaClientImport(options, output);
+    const clientSource = emitClient(
+      dmmf,
+      prismaClientImport,
+      prismaClientKind,
+      importStyle,
+      cfg.runtimeImportPath
+    );
     writeFileSync(`${output}/client.ts`, clientSource, "utf-8");
-    if (typedGuardShapes) {
+    const shapesPath = `${output}/shapes.ts`;
+    if (cfg.typedGuardShapes) {
       writeFileSync(
-        `${output}/shapes.ts`,
-        emitTypedShapes(dmmf, typedGuardRelationDepth),
+        shapesPath,
+        emitTypedShapes(dmmf, cfg.typedGuardRelationDepth, importStyle, cfg.runtimeImportPath),
         "utf-8"
       );
+    } else if (existsSync2(shapesPath)) {
+      rmSync(shapesPath, { force: true });
     }
   }
 });