prisma-guard 1.1.0 → 1.2.1

package/dist/generator/index.js

@@ -35,7 +35,7 @@ function emitScopeMap(dmmf, onAmbiguousScope) {
           throw new Error(`prisma-guard: ${msg}`);
         }
         if (onAmbiguousScope === "warn") {
-          console.warn(`prisma-guard: ${msg} Excluding model from scope map.`);
+          console.warn(`prisma-guard: ${msg} Excluding relation "${field.name}" to scope root "${field.type}" from scope map for model "${model.name}".`);
         }
         continue;
       }
@@ -65,7 +65,7 @@ function emitScopeMap(dmmf, onAmbiguousScope) {
           );
         }
         if (onAmbiguousScope === "warn") {
-          console.warn(`prisma-guard: ${msg} Excluding model from scope map.`);
+          console.warn(`prisma-guard: ${msg} Excluding relations to scope root "${root}" from scope map for model "${model.name}".`);
         }
         continue;
       }
@@ -91,7 +91,7 @@ ${mapEntries}
 
 export type ScopeRoot = ${scopeRootType}
 `;
-  return { source, roots };
+  return { source };
 }
 
 // src/generator/emit-zod-chains.ts
@@ -308,7 +308,7 @@ function validateDirective(raw) {
       }
       if (ch === "/" && !inCharClass) {
         advance();
-        while (pos < input.length && /[gimsuy]/.test(peek())) {
+        while (pos < input.length && /[gimsuydv]/.test(peek())) {
           advance();
         }
         return null;
@@ -528,9 +528,15 @@ function validateDirective(raw) {
 // src/shared/scalar-base.ts
 import { z } from "zod";
 function isJsonSafe(value) {
-  const stack = [value];
+  const stack = [{ tag: "visit", value }];
+  const ancestors = /* @__PURE__ */ new Set();
   while (stack.length > 0) {
-    const current = stack.pop();
+    const entry = stack.pop();
+    if (entry.tag === "exit") {
+      ancestors.delete(entry.ref);
+      continue;
+    }
+    const current = entry.value;
     if (current === void 0)
       return false;
     if (current === null)
@@ -544,9 +550,13 @@ function isJsonSafe(value) {
           return false;
         continue;
       case "object": {
+        if (ancestors.has(current))
+          return false;
+        ancestors.add(current);
+        stack.push({ tag: "exit", ref: current });
         if (Array.isArray(current)) {
           for (let i = 0; i < current.length; i++) {
-            stack.push(current[i]);
+            stack.push({ tag: "visit", value: current[i] });
           }
           continue;
         }
@@ -555,7 +565,7 @@ function isJsonSafe(value) {
           return false;
         const values = Object.values(current);
         for (let i = 0; i < values.length; i++) {
-          stack.push(values[i]);
+          stack.push({ tag: "visit", value: values[i] });
         }
         continue;
       }
@@ -565,37 +575,48 @@ function isJsonSafe(value) {
   }
   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)
-  ])
-};
+var DECIMAL_REGEX = /^-?(\d+\.?\d*|\.\d+)([eE]-?\d+)?$/;
+var decimalStringSchema = z.string().refine(
+  (s) => DECIMAL_REGEX.test(s),
+  "Invalid decimal string"
+);
+var decimalObjectSchema = z.custom(
+  (v) => v !== null && typeof v === "object" && typeof v.toFixed === "function" && typeof v.toNumber === "function",
+  "Expected Decimal-compatible object"
+);
+function createDecimalFactory(strict) {
+  if (strict) {
+    return () => z.union([decimalStringSchema, decimalObjectSchema]);
+  }
+  return () => z.union([z.number(), decimalStringSchema, decimalObjectSchema]);
+}
+function createScalarBase(strictDecimal) {
+  return {
+    String: () => z.string(),
+    Int: () => z.number().int(),
+    Float: () => z.number(),
+    Decimal: createDecimalFactory(strictDecimal),
+    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 })
+    ]).pipe(z.coerce.date()),
+    Json: () => z.unknown().refine(isJsonSafe, "Value must be JSON-serializable (no undefined, functions, symbols, class instances, NaN, Infinity, or circular references)"),
+    Bytes: () => z.union([
+      z.string(),
+      z.custom((v) => v instanceof Uint8Array)
+    ])
+  };
+}
+var SCALAR_BASE = createScalarBase(false);
 
 // src/generator/emit-zod-chains.ts
 function buildGenerationBase(fieldType, isList, isEnum, enumValues) {
@@ -613,14 +634,52 @@ 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) {
-  const base = buildGenerationBase(fieldType, isList, isEnum, enumValues);
-  if (!base)
+  let current = buildGenerationBase(fieldType, isList, isEnum, enumValues);
+  if (!current)
     return null;
   for (const method of methods) {
-    if (typeof base[method] !== "function") {
+    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;
+  let fn;
+  try {
+    fn = new Function("base", `'use strict'; return base${chainStr}`);
+  } catch (err) {
+    return `syntax error: ${err.message}`;
+  }
+  try {
+    const result = fn(base);
+    if (result === null || result === void 0 || typeof result !== "object" || typeof result.parse !== "function") {
+      return "chain did not produce a valid Zod schema";
+    }
+  } catch (err) {
+    return err.message;
   }
   return null;
 }
@@ -637,6 +696,7 @@ function emitZodChains(dmmf, onInvalidZod) {
     enumValues[e.name] = e.values.map((v) => v.name);
   }
   const modelChains = {};
+  const defaults = {};
   for (const model of dmmf.datamodel.models) {
     for (const field of model.fields) {
       if (!field.documentation)
@@ -688,14 +748,34 @@ function emitZodChains(dmmf, onInvalidZod) {
         console.warn(msg);
         continue;
       }
+      const execError = verifyChainExecution(
+        field.type,
+        field.isList,
+        isEnum,
+        isEnum ? enumValues[field.type] : void 0,
+        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);
+        continue;
+      }
       if (!modelChains[model.name])
         modelChains[model.name] = {};
       modelChains[model.name][field.name] = chainStr;
+      if (result.methods.includes("default") || result.methods.includes("catch")) {
+        if (!defaults[model.name])
+          defaults[model.name] = [];
+        defaults[model.name].push(field.name);
+      }
     }
   }
   const hasChains = Object.keys(modelChains).length > 0;
   if (!hasChains) {
-    return { source: "export const ZOD_CHAINS = {}\n", hasChains: false };
+    return { source: "export const ZOD_CHAINS = {}\n", hasChains: false, defaults };
   }
   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");
@@ -708,7 +788,8 @@ ${fieldEntries}
 ${entries}
 }
 `,
-    hasChains: true
+    hasChains: true,
+    defaults
   };
 }
 
@@ -804,21 +885,50 @@ ${typesSource}
 `;
 }
 
-// src/generator/emit-client.ts
+// src/shared/constants.ts
+var SHAPE_CONFIG_KEYS = /* @__PURE__ */ new Set([
+  "where",
+  "include",
+  "select",
+  "orderBy",
+  "cursor",
+  "take",
+  "skip",
+  "distinct",
+  "having",
+  "_count",
+  "_avg",
+  "_sum",
+  "_min",
+  "_max",
+  "by"
+]);
+var GUARD_SHAPE_KEYS = /* @__PURE__ */ new Set([
+  "data",
+  "create",
+  "update",
+  ...SHAPE_CONFIG_KEYS
+]);
+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");
+
+// 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): GuardedModel<PrismaClient['${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 } from './index.js'
+import { SCOPE_MAP, TYPE_MAP, ENUM_MAP, ZOD_CHAINS, GUARD_CONFIG, UNIQUE_MAP, ZOD_DEFAULTS } from './index.js'
 import type { ScopeRoot } from './index.js'
 
 interface GuardModelExtension {
@@ -832,6 +942,7 @@ export const guard = createGuard<typeof TYPE_MAP, ScopeRoot, GuardModelExtension
   zodChains: ZOD_CHAINS,
   guardConfig: GUARD_CONFIG,
   uniqueMap: UNIQUE_MAP,
+  zodDefaults: ZOD_DEFAULTS,
 })
 `;
 }
@@ -843,6 +954,7 @@ 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"]);
 function validateConfigEnum(name, value, allowed) {
   if (!allowed.has(value)) {
     throw new Error(
@@ -851,6 +963,30 @@ function validateConfigEnum(name, value, allowed) {
   }
   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 emitZodDefaults(defaults) {
+  const entries = Object.entries(defaults);
+  if (entries.length === 0) {
+    return `export const ZOD_DEFAULTS: Record<string, readonly string[]> = {}
+`;
+  }
+  const mapEntries = entries.map(([model, fields]) => {
+    const fieldsStr = fields.map((f) => JSON.stringify(f)).join(", ");
+    return `  ${JSON.stringify(model)}: [${fieldsStr}],`;
+  }).join("\n");
+  return `export const ZOD_DEFAULTS: Record<string, readonly string[]> = {
+${mapEntries}
+}
+`;
+}
 generatorHandler({
   onManifest() {
     return {
@@ -868,6 +1004,8 @@ generatorHandler({
     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 dmmf = options.dmmf;
     const parts = [];
     parts.push(
@@ -875,6 +1013,8 @@ generatorHandler({
   onMissingScopeContext: ${JSON.stringify(onMissingScopeContext)},
   findUniqueMode: ${JSON.stringify(findUniqueMode)},
   onScopeRelationWrite: ${JSON.stringify(onScopeRelationWrite)},
+  strictDecimal: ${JSON.stringify(strictDecimal)},
+  enforceProjection: ${JSON.stringify(enforceProjection)},
 } as const
 `
     );
@@ -882,8 +1022,9 @@ generatorHandler({
     parts.push(scopeSource);
     const typeMapSource = emitTypeMap(dmmf);
     parts.push(typeMapSource);
-    const { source: zodChainsSource } = emitZodChains(dmmf, onInvalidZod);
+    const { source: zodChainsSource, defaults } = emitZodChains(dmmf, onInvalidZod);
     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);