prisma-guard 1.23.0 → 1.25.0

package/dist/generator/index.js

@@ -2,8 +2,34 @@
 
 // src/generator/index.ts
 import pkg from "@prisma/generator-helper";
-import { writeFileSync, mkdirSync } from "fs";
-import { join } from "path";
+import { mkdirSync, writeFileSync } from "fs";
+import { relative } from "path";
+
+// src/generator/emit-client.ts
+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'
+
+interface GuardModelExtension {
+  $allModels: {
+    guard<TDelegate>(this: TDelegate, input: GuardInput, caller?: string): GuardedModel<TDelegate>
+  }
+}
+
+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,
+  zodDefaults: ZOD_DEFAULTS,
+})
+`;
+}
 
 // src/generator/emit-scope-map.ts
 function isScopeRoot(documentation) {
@@ -94,6 +120,212 @@ export type ScopeRoot = ${scopeRootType}
   return { source };
 }
 
+// src/generator/emit-type-map.ts
+function uniqueSelector(fields, name) {
+  if (typeof name === "string" && name.trim().length > 0)
+    return name;
+  return fields.join("_");
+}
+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;
+    const normalizedSelector = fields.length === 1 ? fields[0] : uniqueSelector(fields, selector);
+    const key = fieldsKey(fields);
+    const existingFieldsForSelector = selectorToFields.get(normalizedSelector);
+    if (existingFieldsForSelector && existingFieldsForSelector !== key) {
+      throw new Error(
+        `prisma-guard: Unique selector "${normalizedSelector}" on model "${model.name}" maps to multiple field sets.`
+      );
+    }
+    if (fieldSetSeen.has(key))
+      return;
+    fieldSetSeen.add(key);
+    selectorToFields.set(normalizedSelector, key);
+    constraints.push({
+      selector: normalizedSelector,
+      fields: [...fields]
+    });
+  }
+  for (const field of model.fields) {
+    if (field.isId)
+      add([field.name], field.name);
+  }
+  if (model.primaryKey) {
+    add([...model.primaryKey.fields], model.primaryKey.name);
+  }
+  for (const field of model.fields) {
+    if (field.isUnique)
+      add([field.name], field.name);
+  }
+  const uniqueIndexes = model.uniqueIndexes ?? [];
+  for (const index of uniqueIndexes) {
+    add([...index.fields], index.name);
+  }
+  for (const fields of model.uniqueFields) {
+    add([...fields], fields.length === 1 ? fields[0] : fields.join("_"));
+  }
+  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.map((field) => {
+      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}`
+      ];
+      if (isEnum)
+        meta.push(`isEnum: true`);
+      if (isUnsupported)
+        meta.push(`isUnsupported: 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) => {
+      const fields = c.fields.map((f) => JSON.stringify(f)).join(", ");
+      return `{ selector: ${JSON.stringify(c.selector)}, fields: [${fields}] }`;
+    }).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/shared/operation-shape-keys.ts
+var OPERATION_SHAPE_KEYS = {
+  findMany: ["where", "include", "select", "orderBy", "cursor", "take", "skip", "distinct"],
+  findFirst: ["where", "include", "select", "orderBy", "cursor", "take", "skip", "distinct"],
+  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"],
+  create: ["data", "select", "include"],
+  createMany: ["data"],
+  createManyAndReturn: ["data", "select", "include"],
+  update: ["data", "where", "select", "include"],
+  updateMany: ["data", "where"],
+  updateManyAndReturn: ["data", "where", "select", "include"],
+  upsert: ["where", "create", "update", "select", "include"],
+  delete: ["where", "select", "include"],
+  deleteMany: ["where"]
+};
+var READ_METHOD_ALLOWED_ARGS = {
+  findMany: new Set(OPERATION_SHAPE_KEYS.findMany),
+  findFirst: new Set(OPERATION_SHAPE_KEYS.findFirst),
+  findFirstOrThrow: new Set(OPERATION_SHAPE_KEYS.findFirstOrThrow),
+  findUnique: new Set(OPERATION_SHAPE_KEYS.findUnique),
+  findUniqueOrThrow: new Set(OPERATION_SHAPE_KEYS.findUniqueOrThrow),
+  count: new Set(OPERATION_SHAPE_KEYS.count),
+  aggregate: new Set(OPERATION_SHAPE_KEYS.aggregate),
+  groupBy: new Set(OPERATION_SHAPE_KEYS.groupBy)
+};
+var MUTATION_SHAPE_KEYS = {
+  create: new Set(OPERATION_SHAPE_KEYS.create),
+  createMany: new Set(OPERATION_SHAPE_KEYS.createMany),
+  createManyAndReturn: new Set(OPERATION_SHAPE_KEYS.createManyAndReturn),
+  update: new Set(OPERATION_SHAPE_KEYS.update),
+  updateMany: new Set(OPERATION_SHAPE_KEYS.updateMany),
+  updateManyAndReturn: new Set(OPERATION_SHAPE_KEYS.updateManyAndReturn),
+  upsert: new Set(OPERATION_SHAPE_KEYS.upsert),
+  delete: new Set(OPERATION_SHAPE_KEYS.delete),
+  deleteMany: new Set(OPERATION_SHAPE_KEYS.deleteMany)
+};
+
+// src/generator/emit-typed-shapes.ts
+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'
+import type {
+  TypedGuardShape,
+  OperationShape,
+  ShapeInput,
+  TypedProjection,
+  TypedInclude,
+  TypedCountSelect,
+} from 'prisma-guard'
+
+type TM = typeof TYPE_MAP
+type UM = typeof UNIQUE_MAP
+
+`;
+  const blocks = dmmf.datamodel.models.map((model) => {
+    const m = model.name;
+    const projAlias = `export type ${m}Select = TypedProjection<TM, '${m}', ${depth}, UM>
+export type ${m}Projection = ${m}Select
+export type ${m}Include = TypedInclude<TM, '${m}', ${depth}, UM>
+export type ${m}CountSelect = TypedCountSelect<TM, '${m}'>
+`;
+    const guardAlias = `export type ${m}GuardShape = TypedGuardShape<TM, '${m}', ${depth}, UM>
+`;
+    const opAliases = OPERATIONS.map((op) => {
+      const c = cap(op);
+      return `export type ${m}${c}Shape = OperationShape<TM, '${m}', '${op}', ${depth}, UM>
+export type ${m}${c}ShapeInput<TCtx = unknown> = ShapeInput<${m}${c}Shape, TCtx>
+`;
+    }).join("");
+    return projAlias + guardAlias + opAliases;
+  }).join("\n");
+  return header + blocks;
+}
+
 // src/generator/emit-zod-chains.ts
 import { z as z2 } from "zod";
 
@@ -790,247 +1022,6 @@ ${entries}
   };
 }
 
-// src/generator/emit-type-map.ts
-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.map((field) => {
-      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}`
-      ];
-      if (isEnum)
-        meta.push(`isEnum: true`);
-      if (isUnsupported)
-        meta.push(`isUnsupported: 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/shared/constants.ts
-var SHAPE_CONFIG_KEY_LIST = [
-  "where",
-  "include",
-  "select",
-  "orderBy",
-  "cursor",
-  "take",
-  "skip",
-  "distinct",
-  "having",
-  "_count",
-  "_avg",
-  "_sum",
-  "_min",
-  "_max",
-  "by"
-];
-var SHAPE_CONFIG_KEYS = new Set(SHAPE_CONFIG_KEY_LIST);
-var GUARD_SHAPE_KEY_LIST = [
-  "data",
-  "create",
-  "update",
-  ...SHAPE_CONFIG_KEY_LIST
-];
-var GUARD_SHAPE_KEYS = new Set(GUARD_SHAPE_KEY_LIST);
-var TO_MANY_RELATION_OPS = /* @__PURE__ */ new Set(["some", "every", "none"]);
-var TO_ONE_RELATION_OPS = /* @__PURE__ */ new Set(["is", "isNot"]);
-var ALL_RELATION_OPS = /* @__PURE__ */ new Set([...TO_MANY_RELATION_OPS, ...TO_ONE_RELATION_OPS]);
-function toDelegateKey(modelName) {
-  return modelName[0].toLowerCase() + modelName.slice(1);
-}
-var FORCED_MARKER = Symbol.for("prisma-guard.forced");
-var UNSUPPORTED_MARKER = Symbol.for("prisma-guard.unsupported");
-
-// src/generator/emit-client.ts
-function emitClient(dmmf) {
-  const modelEntries = dmmf.datamodel.models.map((model) => {
-    const key = toDelegateKey(model.name);
-    return `    ${key}: {
-      guard(input: GuardInput, caller?: string): 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, ZOD_DEFAULTS } from './index'
-import type { ScopeRoot } from './index'
-
-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,
-  zodDefaults: ZOD_DEFAULTS,
-})
-`;
-}
-
-// src/shared/operation-shape-keys.ts
-var OPERATION_SHAPE_KEYS = {
-  findMany: ["where", "include", "select", "orderBy", "cursor", "take", "skip", "distinct"],
-  findFirst: ["where", "include", "select", "orderBy", "cursor", "take", "skip", "distinct"],
-  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"],
-  create: ["data", "select", "include"],
-  createMany: ["data"],
-  createManyAndReturn: ["data", "select", "include"],
-  update: ["data", "where", "select", "include"],
-  updateMany: ["data", "where"],
-  updateManyAndReturn: ["data", "where", "select", "include"],
-  upsert: ["where", "create", "update", "select", "include"],
-  delete: ["where", "select", "include"],
-  deleteMany: ["where"]
-};
-var READ_METHOD_ALLOWED_ARGS = {
-  findMany: new Set(OPERATION_SHAPE_KEYS.findMany),
-  findFirst: new Set(OPERATION_SHAPE_KEYS.findFirst),
-  findFirstOrThrow: new Set(OPERATION_SHAPE_KEYS.findFirstOrThrow),
-  findUnique: new Set(OPERATION_SHAPE_KEYS.findUnique),
-  findUniqueOrThrow: new Set(OPERATION_SHAPE_KEYS.findUniqueOrThrow),
-  count: new Set(OPERATION_SHAPE_KEYS.count),
-  aggregate: new Set(OPERATION_SHAPE_KEYS.aggregate),
-  groupBy: new Set(OPERATION_SHAPE_KEYS.groupBy)
-};
-var MUTATION_SHAPE_KEYS = {
-  create: new Set(OPERATION_SHAPE_KEYS.create),
-  createMany: new Set(OPERATION_SHAPE_KEYS.createMany),
-  createManyAndReturn: new Set(OPERATION_SHAPE_KEYS.createManyAndReturn),
-  update: new Set(OPERATION_SHAPE_KEYS.update),
-  updateMany: new Set(OPERATION_SHAPE_KEYS.updateMany),
-  updateManyAndReturn: new Set(OPERATION_SHAPE_KEYS.updateManyAndReturn),
-  upsert: new Set(OPERATION_SHAPE_KEYS.upsert),
-  delete: new Set(OPERATION_SHAPE_KEYS.delete),
-  deleteMany: new Set(OPERATION_SHAPE_KEYS.deleteMany)
-};
-
-// src/generator/emit-typed-shapes.ts
-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 } from './index'
-import type {
-  TypedGuardShape,
-  OperationShape,
-  ShapeInput,
-  TypedProjection,
-  TypedInclude,
-  TypedCountSelect,
-} from 'prisma-guard'
-
-type TM = typeof TYPE_MAP
-
-`;
-  const blocks = dmmf.datamodel.models.map((model) => {
-    const m = model.name;
-    const projAlias = `export type ${m}Select = TypedProjection<TM, '${m}', ${depth}>
-export type ${m}Projection = ${m}Select
-export type ${m}Include = TypedInclude<TM, '${m}', ${depth}>
-export type ${m}CountSelect = TypedCountSelect<TM, '${m}'>
-`;
-    const guardAlias = `export type ${m}GuardShape = TypedGuardShape<TM, '${m}', ${depth}>
-`;
-    const opAliases = OPERATIONS.map((op) => {
-      const c = cap(op);
-      return `export type ${m}${c}Shape = OperationShape<TM, '${m}', '${op}', ${depth}>
-export type ${m}${c}ShapeInput<TCtx = unknown> = ShapeInput<${m}${c}Shape, TCtx>
-`;
-    }).join("");
-    return projAlias + guardAlias + opAliases;
-  }).join("\n");
-  return header + blocks;
-}
-
 // src/generator/index.ts
 var { generatorHandler } = pkg;
 var VALID_ON_INVALID_ZOD = /* @__PURE__ */ new Set(["error", "warn"]);
@@ -1073,7 +1064,7 @@ function emitZodDefaults(defaults) {
 `;
   }
   const mapEntries = entries.map(([model, fields]) => {
-    const fieldsStr = fields.map((f) => JSON.stringify(f)).join(", ");
+    const fieldsStr = fields.map((field) => JSON.stringify(field)).join(", ");
     return `  ${JSON.stringify(model)}: [${fieldsStr}],`;
   }).join("\n");
   return `export const ZOD_DEFAULTS: Record<string, readonly string[]> = {
@@ -1081,6 +1072,35 @@ ${mapEntries}
 }
 `;
 }
+function getProviderValue(provider) {
+  if (typeof provider === "string")
+    return provider;
+  if (provider && typeof provider === "object" && "value" in provider) {
+    const value = provider.value;
+    if (typeof value === "string")
+      return value;
+  }
+  return "";
+}
+function isPrismaClientProvider(provider) {
+  const value = getProviderValue(provider);
+  return value === "prisma-client-js" || value.endsWith("/prisma-client-js");
+}
+function normalizeImportPath(path) {
+  const normalized = path.replace(/\\/g, "/");
+  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));
+}
 generatorHandler({
   onManifest() {
     return {
@@ -1093,15 +1113,49 @@ generatorHandler({
     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 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 dmmf = options.dmmf;
     const parts = [];
     parts.push(
@@ -1122,12 +1176,13 @@ generatorHandler({
     parts.push(zodChainsSource);
     parts.push(emitZodDefaults(defaults));
     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");
+    writeFileSync(`${output}/index.ts`, parts.join("\n"), "utf-8");
+    const prismaClientImport = resolvePrismaClientImport(options, output);
+    const clientSource = emitClient(dmmf, prismaClientImport);
+    writeFileSync(`${output}/client.ts`, clientSource, "utf-8");
     if (typedGuardShapes) {
       writeFileSync(
-        join(output, "shapes.ts"),
+        `${output}/shapes.ts`,
         emitTypedShapes(dmmf, typedGuardRelationDepth),
         "utf-8"
       );