prisma-guard 1.28.0 → 1.29.0

package/dist/runtime/index.cjs

@@ -243,7 +243,7 @@ function createScalarBase(strictDecimal) {
   return {
     String: () => import_zod.z.string(),
     Int: () => import_zod.z.number().int(),
-    Float: () => import_zod.z.number(),
+    Float: () => import_zod.z.number().finite(),
     Decimal: createDecimalFactory(strictDecimal),
     BigInt: () => import_zod.z.union([
       import_zod.z.bigint(),
@@ -384,6 +384,19 @@ function requireConfigTrue(config, context) {
     }
   }
 }
+function requirePlainObjectConfig(value, message) {
+  if (!isPlainObject(value)) {
+    throw new ShapeError(message);
+  }
+  return value;
+}
+function assertAllowedKeys(value, allowed, makeError) {
+  for (const key of Object.keys(value)) {
+    if (!allowed.has(key)) {
+      throw new ShapeError(makeError(key));
+    }
+  }
+}
 
 // src/runtime/zod-type-map.ts
 var SCALAR_OPERATORS = {
@@ -447,24 +460,12 @@ var JSON_ARRAY_OPERATORS = /* @__PURE__ */ new Set([
   "array_starts_with",
   "array_ends_with"
 ]);
-function getSupportedOperators(input, isList = false, isEnum = false) {
-  let fieldType;
-  let list;
-  let enumField;
-  if (typeof input === "string") {
-    fieldType = input;
-    list = isList;
-    enumField = isEnum;
-  } else {
-    fieldType = input.type;
-    list = input.isList;
-    enumField = input.isEnum === true;
-  }
-  if (list)
+function getSupportedOperators(fieldMeta) {
+  if (fieldMeta.isList)
     return [...SCALAR_LIST_OPERATORS];
-  if (enumField)
+  if (fieldMeta.isEnum === true)
     return [...ENUM_OPERATORS];
-  const ops = SCALAR_OPERATORS[fieldType];
+  const ops = SCALAR_OPERATORS[fieldMeta.type];
   if (!ops)
     return [];
   return [...ops];
@@ -1029,6 +1030,7 @@ function validateContext(ctx) {
 
 // src/runtime/query-builder-where.ts
 var import_zod5 = require("zod");
+var import_node_util = require("util");
 
 // src/shared/deep-clone.ts
 function deepClone(value) {
@@ -1309,15 +1311,10 @@ function applyBuiltShape(built, body, isUniqueMethod, modelName) {
   try {
     validated = built.zodSchema.parse(parseable);
   } catch (err) {
-    if (err instanceof ShapeError)
-      throw err;
-    if (err && typeof err === "object" && "issues" in err) {
-      const context = modelName ? `Invalid query on model "${modelName}"` : "Invalid query";
-      throw new ShapeError(`${context}: ${formatZodError(err)}`, {
-        cause: err
-      });
-    }
-    throw err;
+    wrapParseError(
+      err,
+      modelName ? `Invalid query on model "${modelName}"` : "Invalid query"
+    );
   }
   if (hasWhereForced(built.forcedWhere)) {
     validated.where = isUniqueMethod ? mergeUniqueWhereForced(
@@ -1634,37 +1631,8 @@ var JSON_STRING_MODE_OPS = /* @__PURE__ */ new Set([
 ]);
 var NEGATIVE_RELATION_OPS = /* @__PURE__ */ new Set(["none", "isNot"]);
 var MAX_WHERE_DEPTH = 10;
-function safeStringify(value) {
-  if (typeof value === "bigint")
-    return `${value}n`;
-  if (typeof value === "undefined")
-    return "undefined";
-  if (typeof value === "function")
-    return "[function]";
-  if (typeof value === "symbol")
-    return value.toString();
-  const seen = /* @__PURE__ */ new WeakSet();
-  try {
-    const json = JSON.stringify(value, (_key, current) => {
-      if (typeof current === "bigint")
-        return `${current}n`;
-      if (typeof current === "undefined")
-        return "[undefined]";
-      if (typeof current === "function")
-        return "[function]";
-      if (typeof current === "symbol")
-        return current.toString();
-      if (current && typeof current === "object") {
-        if (seen.has(current))
-          return "[Circular]";
-        seen.add(current);
-      }
-      return current;
-    });
-    return json === void 0 ? String(value) : json;
-  } catch {
-    return String(value);
-  }
+function formatValue(value) {
+  return (0, import_node_util.inspect)(value, { depth: 3, breakLength: Infinity });
 }
 function mergeScalarConditions(target, source) {
   for (const [field, ops] of Object.entries(source)) {
@@ -1685,7 +1653,7 @@ function mergeScalarConditions(target, source) {
           const existingVal = existing[op];
           if (!deepEqual(existingVal, val)) {
             throw new ShapeError(
-              `Conflicting forced where values for "${field}.${op}": shape defines both ${safeStringify(existingVal)} and ${safeStringify(val)}`
+              `Conflicting forced where values for "${field}.${op}": shape defines both ${formatValue(existingVal)} and ${formatValue(val)}`
             );
           }
         }
@@ -2523,10 +2491,7 @@ function createArgsBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
           `${fieldMeta.type} field "${fieldName}" cannot be used in having`
         );
       }
-      const allowedOps = getSupportedOperators(
-        fieldMeta.type,
-        fieldMeta.isList
-      );
+      const allowedOps = getSupportedOperators(fieldMeta);
       const opSchemas = {};
       for (const op of allowedOps) {
         opSchemas[op] = createOperatorSchema(
@@ -2703,20 +2668,27 @@ function buildDefaultProjectionBody(shape) {
 
 // src/runtime/query-builder-projection.ts
 var KNOWN_NESTED_KEYS = {
-  include: /* @__PURE__ */ new Set(["where", "include", "select", "orderBy", "cursor", "take", "skip"]),
-  select: /* @__PURE__ */ new Set(["select", "include", "where", "orderBy", "cursor", "take", "skip"])
+  include: /* @__PURE__ */ new Set([
+    "where",
+    "include",
+    "select",
+    "orderBy",
+    "cursor",
+    "take",
+    "skip"
+  ]),
+  select: /* @__PURE__ */ new Set([
+    "select",
+    "include",
+    "where",
+    "orderBy",
+    "cursor",
+    "take",
+    "skip"
+  ])
 };
 var KNOWN_COUNT_SELECT_ENTRY_KEYS = /* @__PURE__ */ new Set(["where"]);
 var MAX_PROJECTION_DEPTH = 10;
-function validateNestedKeys(keys, allowed, context) {
-  for (const key of keys) {
-    if (!allowed.has(key)) {
-      throw new ShapeError(
-        `Unknown key "${key}" in ${context}. Allowed: ${[...allowed].join(", ")}`
-      );
-    }
-  }
-}
 function hasDefinedKeys(v) {
   return Object.values(v).some((value) => value !== void 0);
 }
@@ -2729,6 +2701,20 @@ function wrapRelationSchema(nestedObj, skeleton) {
     collapsed
   );
 }
+function buildRelationWhere(relatedType, whereConfig, context, buildWhereSchema) {
+  if (Object.keys(whereConfig).length === 0) {
+    throw new ShapeError(
+      `Empty "where" in ${context}. Define at least one field.`
+    );
+  }
+  const { schema, forced } = buildWhereSchema(relatedType, whereConfig);
+  if (!schema && !hasWhereForced(forced)) {
+    throw new ShapeError(
+      `"where" in ${context} produced no schema and no forced conditions. Define at least one field.`
+    );
+  }
+  return { schema, forced };
+}
 function createProjectionBuilder(typeMap, _enumMap, deps) {
   function buildIncludeCountSchema(model, config) {
     const modelFields = typeMap[model];
@@ -2742,13 +2728,11 @@ function createProjectionBuilder(typeMap, _enumMap, deps) {
         `Invalid _count config on model "${model}". Expected true or { select: { ... } }`
       );
     }
-    for (const key of Object.keys(config)) {
-      if (key !== "select") {
-        throw new ShapeError(
-          `Unknown key "${key}" in _count config on model "${model}". Only "select" is allowed.`
-        );
-      }
-    }
+    assertAllowedKeys(
+      config,
+      /* @__PURE__ */ new Set(["select"]),
+      (key) => `Unknown key "${key}" in _count config on model "${model}". Only "select" is allowed.`
+    );
     if (!isPlainObject(config.select)) {
       throw new ShapeError(
         `Invalid _count.select on model "${model}". Expected a plain object with relation field keys.`
@@ -2765,11 +2749,17 @@ function createProjectionBuilder(typeMap, _enumMap, deps) {
     for (const [fieldName, fieldConfig] of Object.entries(selectObj)) {
       const fieldMeta = modelFields[fieldName];
       if (!fieldMeta)
-        throw new ShapeError(`Unknown field "${fieldName}" on model "${model}" in _count.select`);
+        throw new ShapeError(
+          `Unknown field "${fieldName}" on model "${model}" in _count.select`
+        );
       if (!fieldMeta.isRelation)
-        throw new ShapeError(`Field "${fieldName}" is not a relation on model "${model}" in _count.select`);
+        throw new ShapeError(
+          `Field "${fieldName}" is not a relation on model "${model}" in _count.select`
+        );
       if (!fieldMeta.isList)
-        throw new ShapeError(`Field "${fieldName}" is a to-one relation on model "${model}" in _count.select. Only to-many relations support _count.`);
+        throw new ShapeError(
+          `Field "${fieldName}" is a to-one relation on model "${model}" in _count.select. Only to-many relations support _count.`
+        );
       if (fieldConfig === true) {
         countSelectFields[fieldName] = import_zod7.z.literal(true).optional();
         continue;
@@ -2784,16 +2774,18 @@ function createProjectionBuilder(typeMap, _enumMap, deps) {
           `Empty config for _count.select.${fieldName} on model "${model}". Use true or { where: { ... } }.`
         );
       }
-      validateNestedKeys(
-        Object.keys(fieldConfig),
+      assertAllowedKeys(
+        fieldConfig,
         KNOWN_COUNT_SELECT_ENTRY_KEYS,
-        `_count.select.${fieldName} on model "${model}"`
+        (key) => `Unknown key "${key}" in _count.select.${fieldName} on model "${model}". Allowed: ${[...KNOWN_COUNT_SELECT_ENTRY_KEYS].join(", ")}`
       );
       if (fieldConfig.where) {
         const relatedType = fieldMeta.type;
-        const { schema: whereSchema, forced } = deps.buildWhereSchema(
+        const { schema: whereSchema, forced } = buildRelationWhere(
           relatedType,
-          fieldConfig.where
+          fieldConfig.where,
+          `_count.select.${fieldName} on model "${model}"`,
+          deps.buildWhereSchema
         );
         const nestedSchemas = {};
         if (whereSchema)
@@ -2816,13 +2808,15 @@ function createProjectionBuilder(typeMap, _enumMap, deps) {
       forcedCountWhere
     };
   }
-  function buildNestedRelSchemas(relatedType, config, depth) {
+  function buildNestedRelSchemas(relatedType, config, depth, context) {
     const nestedSchemas = {};
     const relForced = {};
     if (config.where) {
-      const { schema: whereSchema, forced } = deps.buildWhereSchema(
+      const { schema: whereSchema, forced } = buildRelationWhere(
         relatedType,
-        config.where
+        config.where,
+        context,
+        deps.buildWhereSchema
       );
       if (whereSchema)
         nestedSchemas["where"] = whereSchema;
@@ -2830,7 +2824,12 @@ function createProjectionBuilder(typeMap, _enumMap, deps) {
         relForced.where = forced;
     }
     if (config.include) {
-      const nested = buildProjectionSchema("include", relatedType, config.include, depth + 1);
+      const nested = buildProjectionSchema(
+        "include",
+        relatedType,
+        config.include,
+        depth + 1
+      );
       nestedSchemas["include"] = nested.schema;
       if (Object.keys(nested.forcedTree).length > 0)
         relForced.include = nested.forcedTree;
@@ -2840,7 +2839,12 @@ function createProjectionBuilder(typeMap, _enumMap, deps) {
       }
     }
     if (config.select) {
-      const nested = buildProjectionSchema("select", relatedType, config.select, depth + 1);
+      const nested = buildProjectionSchema(
+        "select",
+        relatedType,
+        config.select,
+        depth + 1
+      );
       nestedSchemas["select"] = nested.schema;
       if (Object.keys(nested.forcedTree).length > 0)
         relForced.select = nested.forcedTree;
@@ -2850,15 +2854,26 @@ function createProjectionBuilder(typeMap, _enumMap, deps) {
       }
     }
     if (config.orderBy) {
-      nestedSchemas["orderBy"] = deps.buildOrderBySchema(relatedType, config.orderBy);
+      nestedSchemas["orderBy"] = deps.buildOrderBySchema(
+        relatedType,
+        config.orderBy
+      );
     }
     if (config.cursor) {
-      nestedSchemas["cursor"] = deps.buildCursorSchema(relatedType, config.cursor);
+      nestedSchemas["cursor"] = deps.buildCursorSchema(
+        relatedType,
+        config.cursor
+      );
     }
-    if (config.take) {
+    if ("take" in config && config.take !== void 0) {
       nestedSchemas["take"] = deps.buildTakeSchema(config.take);
     }
-    if (config.skip) {
+    if ("skip" in config && config.skip !== void 0) {
+      if (config.skip !== true) {
+        throw new ShapeError(
+          `Nested "skip" in ${context} must be true`
+        );
+      }
       nestedSchemas["skip"] = import_zod7.z.number().int().min(0).optional();
     }
     return { nestedSchemas, relForced };
@@ -2884,28 +2899,43 @@ function createProjectionBuilder(typeMap, _enumMap, deps) {
     let topLevelForcedCountWhere = {};
     for (const [fieldName, config] of Object.entries(projectionConfig)) {
       if (fieldName === "_count") {
-        const countResult = buildIncludeCountSchema(model, config);
+        const countResult = buildIncludeCountSchema(
+          model,
+          config
+        );
         fieldSchemas["_count"] = countResult.schema;
         topLevelForcedCountWhere = countResult.forcedCountWhere;
         continue;
       }
       const fieldMeta = modelFields[fieldName];
       if (!fieldMeta)
-        throw new ShapeError(`Unknown field "${fieldName}" on model "${model}"`);
+        throw new ShapeError(
+          `Unknown field "${fieldName}" on model "${model}"`
+        );
       if (mode === "include" && !fieldMeta.isRelation) {
-        throw new ShapeError(`Field "${fieldName}" is not a relation on model "${model}"`);
+        throw new ShapeError(
+          `Field "${fieldName}" is not a relation on model "${model}"`
+        );
       }
       if (config === true) {
         fieldSchemas[fieldName] = import_zod7.z.literal(true).optional();
         continue;
       }
       if (mode === "select" && !fieldMeta.isRelation) {
-        throw new ShapeError(`Nested select args only valid for relations, not scalar "${fieldName}" on model "${model}"`);
+        throw new ShapeError(
+          `Nested select args only valid for relations, not scalar "${fieldName}" on model "${model}"`
+        );
       }
       const contextLabel = `nested ${mode} for "${fieldName}" on model "${model}"`;
-      validateNestedKeys(Object.keys(config), allowedNestedKeys, contextLabel);
+      assertAllowedKeys(
+        config,
+        allowedNestedKeys,
+        (key) => `Unknown key "${key}" in ${contextLabel}. Allowed: ${[...allowedNestedKeys].join(", ")}`
+      );
       if (config.select && config.include) {
-        throw new ShapeError(`Nested ${mode} for "${fieldName}" cannot define both "select" and "include".`);
+        throw new ShapeError(
+          `Nested ${mode} for "${fieldName}" cannot define both "select" and "include".`
+        );
       }
       if (!fieldMeta.isList) {
         if (config.where || config.orderBy || config.cursor || config.take || config.skip) {
@@ -2914,7 +2944,12 @@ function createProjectionBuilder(typeMap, _enumMap, deps) {
           );
         }
       }
-      const { nestedSchemas, relForced } = buildNestedRelSchemas(fieldMeta.type, config, currentDepth);
+      const { nestedSchemas, relForced } = buildNestedRelSchemas(
+        fieldMeta.type,
+        config,
+        currentDepth,
+        contextLabel
+      );
       const nestedObj = import_zod7.z.object(nestedSchemas).strict();
       fieldSchemas[fieldName] = wrapRelationSchema(
         nestedObj,
@@ -2939,27 +2974,33 @@ function createProjectionBuilder(typeMap, _enumMap, deps) {
   function buildSelectSchema(model, selectConfig, depth) {
     return buildProjectionSchema("select", model, selectConfig, depth);
   }
-  return { buildIncludeSchema, buildSelectSchema, buildIncludeCountSchema, buildProjectionSchema };
+  return {
+    buildIncludeSchema,
+    buildSelectSchema,
+    buildIncludeCountSchema,
+    buildProjectionSchema
+  };
 }
 
 // src/shared/operation-shape-keys.ts
 var OPERATION_SHAPE_KEYS = {
   findMany: ["where", "include", "select", "orderBy", "cursor", "take", "skip", "distinct"],
+  findManyPaginated: ["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"],
   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"],
+  groupBy: ["where", "orderBy", "by", "having", "take", "skip", "_count", "_avg", "_sum", "_min", "_max"],
+  create: ["data", "include", "select"],
+  createMany: ["data", "skipDuplicates"],
+  createManyAndReturn: ["data", "select", "include", "skipDuplicates"],
+  update: ["where", "data", "include", "select"],
+  updateMany: ["where", "data"],
+  updateManyAndReturn: ["where", "data", "select", "include"],
+  upsert: ["where", "create", "update", "include", "select"],
+  delete: ["where", "include", "select"],
   deleteMany: ["where"]
 };
 var READ_METHOD_ALLOWED_ARGS = {
@@ -3271,7 +3312,17 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
     let forcedIncludeCountWhere = {};
     let forcedSelectCountWhere = {};
     if (shape.where) {
+      if (Object.keys(shape.where).length === 0) {
+        throw new ShapeError(
+          `Empty "where" in shape for model "${model}" method "${method}". Define at least one field.`
+        );
+      }
       const builtWhere = UNIQUE_WHERE_METHODS.has(method) ? whereBuilder.buildUniqueWhereSchema(model, shape.where) : whereBuilder.buildWhereSchema(model, shape.where);
+      if (!builtWhere.schema && !hasWhereForced(builtWhere.forced)) {
+        throw new ShapeError(
+          `"where" in shape for model "${model}" method "${method}" produced no schema and no forced conditions.`
+        );
+      }
       if (builtWhere.schema) {
         schemaFields.where = builtWhere.schema;
       }
@@ -4073,27 +4124,19 @@ function validateRelationOpKeys(actual, opKey, model, field, opLabel) {
   const allowed = RELATION_OP_ALLOWED_KEYS[opKey];
   if (!allowed)
     return;
-  for (const key of Object.keys(actual)) {
-    if (!allowed.has(key)) {
-      throw new ShapeError(
-        `Unknown key "${key}" in ${opLabel} config on "${model}.${field}". Allowed: ${[...allowed].join(", ")}`
-      );
-    }
-  }
+  assertAllowedKeys(
+    actual,
+    allowed,
+    (key) => `Unknown key "${key}" in ${opLabel} config on "${model}.${field}". Allowed: ${[...allowed].join(", ")}`
+  );
 }
 function validateAllowedKeys(value, allowed, method, kind) {
-  for (const key of Object.keys(value)) {
-    if (!allowed.has(key)) {
-      if (kind === "body") {
-        throw new ShapeError(
-          `Unexpected key "${key}" in ${method} body. Allowed keys: ${[...allowed].join(", ")}`
-        );
-      }
-      throw new ShapeError(
-        `Shape key "${key}" not valid for ${method}. Allowed: ${[...allowed].join(", ")}`
-      );
+  assertAllowedKeys(value, allowed, (key) => {
+    if (kind === "body") {
+      return `Unexpected key "${key}" in ${method} body. Allowed keys: ${[...allowed].join(", ")}`;
     }
-  }
+    return `Shape key "${key}" not valid for ${method}. Allowed: ${[...allowed].join(", ")}`;
+  });
 }
 function validateCreateCompleteness(modelName, dataConfig, typeMap, scopeFks, zodDefaults) {
   const modelFields = typeMap[modelName];
@@ -4180,18 +4223,10 @@ function buildNestedDataSchema(model, config, mode, typeMap, schemaBuilder) {
   }
   return import_zod10.z.object(fieldSchemas).strict();
 }
-function requirePlainObjectConfig(value, message) {
-  if (!isPlainObject(value))
-    throw new ShapeError(message);
-  return value;
-}
 function requireNestedObject(cfg, key, message) {
-  const v = cfg[key];
-  if (!v || !isPlainObject(v))
-    throw new ShapeError(message);
-  return v;
+  return requirePlainObjectConfig(cfg[key], message);
 }
-function buildUniqueSelector(ctx, cfg, context) {
+function buildRelatedUniqueSelector(ctx, cfg, context) {
   return buildUniqueSelectorSchema(
     ctx.model,
     ctx.fieldName,
@@ -4204,7 +4239,7 @@ function buildUniqueSelector(ctx, cfg, context) {
     context
   );
 }
-function buildNestedData(ctx, cfg, mode) {
+function buildRelatedNestedData(ctx, cfg, mode) {
   return buildNestedDataSchema(
     ctx.relatedModelName,
     cfg,
@@ -4218,7 +4253,7 @@ var handleConnect = (ctx) => {
     ctx.config,
     `connect config on "${ctx.model}.${ctx.fieldName}" must be an object of unique selectors`
   );
-  const schema = buildUniqueSelector(ctx, cfg, "connect");
+  const schema = buildRelatedUniqueSelector(ctx, cfg, "connect");
   return wrapRelationOp(ctx.isList, schema);
 };
 var handleConnectOrCreate = (ctx) => {
@@ -4237,8 +4272,8 @@ var handleConnectOrCreate = (ctx) => {
     "create",
     `connectOrCreate on "${ctx.model}.${ctx.fieldName}" requires "create" object`
   );
-  const whereSchema = buildUniqueSelector(ctx, where, "connectOrCreate.where");
-  const createSchema = buildNestedData(ctx, create, "create");
+  const whereSchema = buildRelatedUniqueSelector(ctx, where, "connectOrCreate.where");
+  const createSchema = buildRelatedNestedData(ctx, create, "create");
   const cocSchema = import_zod10.z.object({ where: whereSchema, create: createSchema }).strict();
   return wrapRelationOp(ctx.isList, cocSchema);
 };
@@ -4247,7 +4282,7 @@ var handleCreate = (ctx) => {
     ctx.config,
     `create config on "${ctx.model}.${ctx.fieldName}" must be an object of field names`
   );
-  const createSchema = buildNestedData(ctx, cfg, "create");
+  const createSchema = buildRelatedNestedData(ctx, cfg, "create");
   return wrapRelationOp(ctx.isList, createSchema);
 };
 var handleCreateMany = (ctx) => {
@@ -4266,7 +4301,7 @@ var handleCreateMany = (ctx) => {
     "data",
     `createMany on "${ctx.model}.${ctx.fieldName}" requires "data" object`
   );
-  const dataSchema = buildNestedData(ctx, data, "create");
+  const dataSchema = buildRelatedNestedData(ctx, data, "create");
   const cmSchemaFields = {
     data: import_zod10.z.preprocess(coerceToArray, import_zod10.z.array(dataSchema))
   };
@@ -4289,7 +4324,7 @@ var handleDisconnect = (ctx) => {
       `disconnect config on "${ctx.model}.${ctx.fieldName}" must be true (to-one) or an object of unique selectors`
     );
   }
-  const schema = buildUniqueSelector(ctx, ctx.config, "disconnect");
+  const schema = buildRelatedUniqueSelector(ctx, ctx.config, "disconnect");
   if (ctx.isList)
     return wrapRelationOp(true, schema);
   return import_zod10.z.union([import_zod10.z.literal(true), schema]).optional();
@@ -4308,7 +4343,7 @@ var handleDelete = (ctx) => {
       `delete config on "${ctx.model}.${ctx.fieldName}" must be true (to-one) or an object of unique selectors`
     );
   }
-  const schema = buildUniqueSelector(ctx, ctx.config, "delete");
+  const schema = buildRelatedUniqueSelector(ctx, ctx.config, "delete");
   if (ctx.isList)
     return wrapRelationOp(true, schema);
   return import_zod10.z.union([import_zod10.z.literal(true), schema]).optional();
@@ -4323,7 +4358,7 @@ var handleSet = (ctx) => {
     ctx.config,
     `set config on "${ctx.model}.${ctx.fieldName}" must be an object of unique selectors`
   );
-  const schema = buildUniqueSelector(ctx, cfg, "set");
+  const schema = buildRelatedUniqueSelector(ctx, cfg, "set");
   return wrapRelationOp(true, schema);
 };
 var handleUpdate = (ctx) => {
@@ -4343,12 +4378,12 @@ var handleUpdate = (ctx) => {
       "data",
       `update on to-many "${ctx.model}.${ctx.fieldName}" requires "data" object`
     );
-    const whereSchema = buildUniqueSelector(ctx, where, "update.where");
-    const dataSchema2 = buildNestedData(ctx, data, "update");
+    const whereSchema = buildRelatedUniqueSelector(ctx, where, "update.where");
+    const dataSchema2 = buildRelatedNestedData(ctx, data, "update");
     const updateSchema = import_zod10.z.object({ where: whereSchema, data: dataSchema2 }).strict();
     return wrapRelationOp(true, updateSchema);
   }
-  const dataSchema = buildNestedData(ctx, cfg, "update");
+  const dataSchema = buildRelatedNestedData(ctx, cfg, "update");
   return dataSchema.optional();
 };
 var handleUpsert = (ctx) => {
@@ -4373,15 +4408,15 @@ var handleUpsert = (ctx) => {
     "update",
     `upsert on "${ctx.model}.${ctx.fieldName}" requires "update" object`
   );
-  const createSchema = buildNestedData(ctx, create, "create");
-  const updateSchema = buildNestedData(ctx, update, "update");
+  const createSchema = buildRelatedNestedData(ctx, create, "create");
+  const updateSchema = buildRelatedNestedData(ctx, update, "update");
   if (ctx.isList) {
     const where = requireNestedObject(
       cfg,
       "where",
       `upsert on to-many "${ctx.model}.${ctx.fieldName}" requires "where" object`
     );
-    const whereSchema = buildUniqueSelector(ctx, where, "upsert.where");
+    const whereSchema = buildRelatedUniqueSelector(ctx, where, "upsert.where");
     const upsertSchema2 = import_zod10.z.object({ where: whereSchema, create: createSchema, update: updateSchema }).strict();
     return wrapRelationOp(true, upsertSchema2);
   }
@@ -4392,7 +4427,7 @@ var handleUpsert = (ctx) => {
         `upsert on to-one "${ctx.model}.${ctx.fieldName}" has invalid "where": must be a plain object of unique selectors`
       );
     }
-    const whereSchema = buildUniqueSelector(ctx, cfg.where, "upsert.where");
+    const whereSchema = buildRelatedUniqueSelector(ctx, cfg.where, "upsert.where");
     const upsertSchema2 = import_zod10.z.object({ where: whereSchema, create: createSchema, update: updateSchema }).strict();
     return upsertSchema2.optional();
   }
@@ -4436,7 +4471,7 @@ var handleUpdateMany = (ctx) => {
     ctx.typeMap,
     ctx.schemaBuilder
   );
-  const dataSchema = buildNestedData(ctx, data, "update");
+  const dataSchema = buildRelatedNestedData(ctx, data, "update");
   const umSchema = import_zod10.z.object({ where: whereSchema, data: dataSchema }).strict();
   return wrapRelationOp(true, umSchema);
 };
@@ -4483,17 +4518,21 @@ function buildRelationWriteSchema(model, fieldName, relatedModelName, isList, co
     throw new ShapeError(
       `Unknown related model "${relatedModelName}" for field "${model}.${fieldName}"`
     );
-  for (const key of Object.keys(config)) {
-    if (!KNOWN_RELATION_WRITE_OPS.has(key)) {
-      throw new ShapeError(
-        `Unknown relation write operation "${key}" on "${model}.${fieldName}". Allowed: ${[...KNOWN_RELATION_WRITE_OPS].join(", ")}`
-      );
-    }
+  assertAllowedKeys(
+    config,
+    KNOWN_RELATION_WRITE_OPS,
+    (key) => `Unknown relation write operation "${key}" on "${model}.${fieldName}". Allowed: ${[...KNOWN_RELATION_WRITE_OPS].join(", ")}`
+  );
+  const definedEntries = Object.entries(config).filter(
+    ([, opConfig]) => opConfig !== void 0
+  );
+  if (definedEntries.length === 0) {
+    throw new ShapeError(
+      `Empty relation write config on "${model}.${fieldName}". Define at least one operation: ${[...KNOWN_RELATION_WRITE_OPS].join(", ")}`
+    );
   }
   const opSchemas = {};
-  for (const [op, opConfig] of Object.entries(config)) {
-    if (opConfig === void 0)
-      continue;
+  for (const [op, opConfig] of definedEntries) {
     const handler = RELATION_OP_HANDLERS[op];
     opSchemas[op] = handler({
       model,
@@ -4510,7 +4549,7 @@ function buildRelationWriteSchema(model, fieldName, relatedModelName, isList, co
   }
   return import_zod10.z.object(opSchemas).strict();
 }
-function buildDataSchema(model, dataConfig, mode, typeMap, uniqueMap, enumMap, scalarBase, schemaBuilder, zodDefaults) {
+function buildDataSchema(model, dataConfig, mode, typeMap, uniqueMap, enumMap, scalarBase, schemaBuilder, zodDefaults, allowRelationWrites) {
   const modelFields = typeMap[model];
   if (!modelFields)
     throw new ShapeError(`Unknown model: ${model}`);
@@ -4540,6 +4579,11 @@ function buildDataSchema(model, dataConfig, mode, typeMap, uniqueMap, enumMap, s
       continue;
     }
     if (fieldMeta.isRelation) {
+      if (!allowRelationWrites) {
+        throw new ShapeError(
+          `Field "${fieldName}" on model "${model}" is a relation. Relation writes are not supported for this method.`
+        );
+      }
       if (!isPlainObject(value)) {
         throw new ShapeError(
           `Relation field "${fieldName}" on model "${model}" requires a relation write config object`
@@ -4653,13 +4697,8 @@ function validateAndMergeData(bodyData, cached, method, modelName) {
   try {
     validated = cached.schema.parse(bodyData);
   } catch (err) {
-    if (err instanceof ShapeError)
-      throw err;
-    if (err && typeof err === "object" && "issues" in err) {
-      const context = modelName ? `Invalid data for ${method} on model "${modelName}"` : `Invalid data for ${method}`;
-      throw new ShapeError(`${context}: ${formatZodError(err)}`, { cause: err });
-    }
-    throw err;
+    const context = modelName ? `Invalid data for ${method} on model "${modelName}"` : `Invalid data for ${method}`;
+    wrapParseError(err, context);
   }
   return { ...validated, ...deepClone(cached.forced) };
 }
@@ -4814,6 +4853,8 @@ var PROJECTION_MUTATION_METHODS = /* @__PURE__ */ new Set([
   "updateManyAndReturn"
 ]);
 var BATCH_CREATE_METHODS = /* @__PURE__ */ new Set(["createMany", "createManyAndReturn"]);
+var RELATION_WRITE_CREATE_METHODS = /* @__PURE__ */ new Set(["create"]);
+var RELATION_WRITE_UPDATE_METHODS = /* @__PURE__ */ new Set(["update"]);
 var MAX_PROJECTION_WALK_DEPTH = 10;
 function walkForClientContent(obj, predicate, depth) {
   if (depth > MAX_PROJECTION_WALK_DEPTH)
@@ -4964,11 +5005,11 @@ function createModelGuardExtension(config) {
         )
       );
     }
-    function getDataSchema(mode, dataConfig, matchedKey, wasDynamic) {
+    function getDataSchema(mode, dataConfig, matchedKey, wasDynamic, allowRelationWrites) {
       const skipCache = wasDynamic || hasDataRefines(dataConfig);
       return memoize(
         dataSchemaCache,
-        `${mode}\0${matchedKey}`,
+        `${mode}\0${matchedKey}\0${allowRelationWrites ? "r" : "n"}`,
         skipCache,
         () => buildDataSchema(
           modelName,
@@ -4979,7 +5020,8 @@ function createModelGuardExtension(config) {
           enumMap,
           scalarBase,
           schemaBuilder,
-          zodDefaults
+          zodDefaults,
+          allowRelationWrites
         )
       );
     }
@@ -5237,6 +5279,39 @@ function createModelGuardExtension(config) {
       const defaultProjection = buildDefaultProjectionBody(resolved.shape);
       return { ...resolved.body, ...defaultProjection };
     }
+    function makeResolveMethod() {
+      const WRITE_KEYS = ["data", "create", "update"];
+      const hasOwn = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
+      return (body) => {
+        const caller = resolveCaller();
+        const resolved = resolveShape(input, body, contextFn, caller);
+        for (const key of WRITE_KEYS) {
+          if (hasOwn(resolved.shape, key)) {
+            throw new ShapeError(
+              `.resolve() is a read-only planning helper. Guard shape contains write key "${key}". Use the corresponding write method instead.`
+            );
+          }
+        }
+        for (const key of WRITE_KEYS) {
+          if (hasOwn(resolved.body, key)) {
+            throw new ShapeError(
+              `.resolve() is a read-only planning helper. Request body contains write key "${key}".`
+            );
+          }
+        }
+        const effectiveReadBody = buildEffectiveReadBody({
+          shape: resolved.shape,
+          body: resolved.body
+        });
+        return {
+          shape: resolved.shape,
+          body: resolved.body,
+          effectiveReadBody,
+          matchedKey: resolved.matchedKey,
+          wasDynamic: resolved.wasDynamic
+        };
+      };
+    }
     function makeReadMethod(method) {
       return (body) => {
         const caller = resolveCaller();
@@ -5270,6 +5345,7 @@ function createModelGuardExtension(config) {
       const supportsProjection = PROJECTION_MUTATION_METHODS.has(method);
       const allowedBodyKeys = getAllowedBodyKeys(method, supportsProjection);
       const allowedShapeKeys = getAllowedShapeKeys(method, supportsProjection);
+      const allowRelationWrites = RELATION_WRITE_CREATE_METHODS.has(method);
       return (body) => {
         const caller = resolveCaller();
         const resolved = resolveShape(input, body, contextFn, caller);
@@ -5295,7 +5371,8 @@ function createModelGuardExtension(config) {
           "create",
           resolved.shape.data,
           resolved.matchedKey,
-          resolved.wasDynamic
+          resolved.wasDynamic,
+          allowRelationWrites
         );
         let args;
         if (method === "create") {
@@ -5343,6 +5420,7 @@ function createModelGuardExtension(config) {
       const supportsProjection = PROJECTION_MUTATION_METHODS.has(method);
       const allowedBodyKeys = getAllowedBodyKeys(method, supportsProjection);
       const allowedShapeKeys = getAllowedShapeKeys(method, supportsProjection);
+      const allowRelationWrites = RELATION_WRITE_UPDATE_METHODS.has(method);
       return (body) => {
         const caller = resolveCaller();
         const resolved = resolveShape(input, body, contextFn, caller);
@@ -5365,7 +5443,8 @@ function createModelGuardExtension(config) {
           "update",
           resolved.shape.data,
           resolved.matchedKey,
-          resolved.wasDynamic
+          resolved.wasDynamic,
+          allowRelationWrites
         );
         const data = validateAndMergeData(
           resolved.body.data,
@@ -5538,7 +5617,8 @@ function createModelGuardExtension(config) {
           "create",
           resolved.shape.create,
           `upsert:create\0${resolved.matchedKey}`,
-          resolved.wasDynamic
+          resolved.wasDynamic,
+          true
         );
         const createData = validateAndMergeData(
           resolved.body.create,
@@ -5550,7 +5630,8 @@ function createModelGuardExtension(config) {
           "update",
           resolved.shape.update,
           `upsert:update\0${resolved.matchedKey}`,
-          resolved.wasDynamic
+          resolved.wasDynamic,
+          true
         );
         const updateData = validateAndMergeData(
           resolved.body.update,
@@ -5583,6 +5664,7 @@ function createModelGuardExtension(config) {
       };
     }
     return {
+      resolve: makeResolveMethod(),
       findMany: makeReadMethod("findMany"),
       findFirst: makeReadMethod("findFirst"),
       findFirstOrThrow: makeReadMethod("findFirstOrThrow"),