prisma-guard 1.12.0 → 1.13.0

package/dist/runtime/index.cjs

@@ -2843,21 +2843,67 @@ var import_zod9 = require("zod");
 // src/runtime/model-guard-data.ts
 var import_zod8 = require("zod");
 var ALLOWED_BODY_KEYS_CREATE = /* @__PURE__ */ new Set(["data"]);
-var ALLOWED_BODY_KEYS_CREATE_PROJECTION = /* @__PURE__ */ new Set(["data", "select", "include"]);
-var ALLOWED_BODY_KEYS_CREATE_MANY = /* @__PURE__ */ new Set(["data", "skipDuplicates"]);
-var ALLOWED_BODY_KEYS_CREATE_MANY_PROJECTION = /* @__PURE__ */ new Set(["data", "select", "include", "skipDuplicates"]);
+var ALLOWED_BODY_KEYS_CREATE_PROJECTION = /* @__PURE__ */ new Set([
+  "data",
+  "select",
+  "include"
+]);
+var ALLOWED_BODY_KEYS_CREATE_MANY = /* @__PURE__ */ new Set([
+  "data",
+  "skipDuplicates"
+]);
+var ALLOWED_BODY_KEYS_CREATE_MANY_PROJECTION = /* @__PURE__ */ new Set([
+  "data",
+  "select",
+  "include",
+  "skipDuplicates"
+]);
 var ALLOWED_BODY_KEYS_UPDATE = /* @__PURE__ */ new Set(["data", "where"]);
-var ALLOWED_BODY_KEYS_UPDATE_PROJECTION = /* @__PURE__ */ new Set(["data", "where", "select", "include"]);
+var ALLOWED_BODY_KEYS_UPDATE_PROJECTION = /* @__PURE__ */ new Set([
+  "data",
+  "where",
+  "select",
+  "include"
+]);
 var ALLOWED_BODY_KEYS_DELETE = /* @__PURE__ */ new Set(["where"]);
-var ALLOWED_BODY_KEYS_DELETE_PROJECTION = /* @__PURE__ */ new Set(["where", "select", "include"]);
-var ALLOWED_BODY_KEYS_UPSERT = /* @__PURE__ */ new Set(["where", "create", "update", "select", "include"]);
+var ALLOWED_BODY_KEYS_DELETE_PROJECTION = /* @__PURE__ */ new Set([
+  "where",
+  "select",
+  "include"
+]);
+var ALLOWED_BODY_KEYS_UPSERT = /* @__PURE__ */ new Set([
+  "where",
+  "create",
+  "update",
+  "select",
+  "include"
+]);
 var VALID_SHAPE_KEYS_CREATE = /* @__PURE__ */ new Set(["data"]);
-var VALID_SHAPE_KEYS_CREATE_PROJECTION = /* @__PURE__ */ new Set(["data", "select", "include"]);
+var VALID_SHAPE_KEYS_CREATE_PROJECTION = /* @__PURE__ */ new Set([
+  "data",
+  "select",
+  "include"
+]);
 var VALID_SHAPE_KEYS_UPDATE = /* @__PURE__ */ new Set(["data", "where"]);
-var VALID_SHAPE_KEYS_UPDATE_PROJECTION = /* @__PURE__ */ new Set(["data", "where", "select", "include"]);
+var VALID_SHAPE_KEYS_UPDATE_PROJECTION = /* @__PURE__ */ new Set([
+  "data",
+  "where",
+  "select",
+  "include"
+]);
 var VALID_SHAPE_KEYS_DELETE = /* @__PURE__ */ new Set(["where"]);
-var VALID_SHAPE_KEYS_DELETE_PROJECTION = /* @__PURE__ */ new Set(["where", "select", "include"]);
-var VALID_SHAPE_KEYS_UPSERT = /* @__PURE__ */ new Set(["where", "create", "update", "select", "include"]);
+var VALID_SHAPE_KEYS_DELETE_PROJECTION = /* @__PURE__ */ new Set([
+  "where",
+  "select",
+  "include"
+]);
+var VALID_SHAPE_KEYS_UPSERT = /* @__PURE__ */ new Set([
+  "where",
+  "create",
+  "update",
+  "select",
+  "include"
+]);
 var KNOWN_RELATION_WRITE_OPS = /* @__PURE__ */ new Set([
   "connect",
   "connectOrCreate",
@@ -2895,26 +2941,6 @@ function validateCreateCompleteness(modelName, dataConfig, typeMap, scopeFks, zo
     return;
   const zodDefaultFields = zodDefaults[modelName];
   const zodDefaultSet = zodDefaultFields ? new Set(zodDefaultFields) : void 0;
-  const relationFksCoveredByShape = /* @__PURE__ */ new Set();
-  for (const [fieldName, value] of Object.entries(dataConfig)) {
-    const meta = modelFields[fieldName];
-    if (!meta)
-      continue;
-    if (meta.isRelation && isPlainObject(value)) {
-      const relConfig = value;
-      if (relConfig.connect || relConfig.connectOrCreate || relConfig.create) {
-        const fkFields = Object.keys(modelFields).filter((f) => {
-          const fm = modelFields[f];
-          return !fm.isRelation && fieldName !== f;
-        });
-        for (const fk of Object.keys(modelFields)) {
-          const fm = modelFields[fk];
-          if (fm.isRelation)
-            continue;
-        }
-      }
-    }
-  }
   for (const [fieldName, meta] of Object.entries(modelFields)) {
     if (meta.isRelation)
       continue;
@@ -2930,17 +2956,6 @@ function validateCreateCompleteness(modelName, dataConfig, typeMap, scopeFks, zo
       continue;
     if (zodDefaultSet && zodDefaultSet.has(fieldName))
       continue;
-    const coveredByRelation = Object.entries(dataConfig).some(([shapeName, shapeVal]) => {
-      const shapeMeta = modelFields[shapeName];
-      if (!shapeMeta || !shapeMeta.isRelation)
-        return false;
-      if (!isPlainObject(shapeVal))
-        return false;
-      const relConfig = shapeVal;
-      return !!(relConfig.connect || relConfig.connectOrCreate || relConfig.create);
-    });
-    if (coveredByRelation)
-      continue;
     throw new ShapeError(
       `Required field "${fieldName}" on model "${modelName}" is missing from create data shape, has no default, and is not a scope FK`
     );
@@ -2951,17 +2966,26 @@ function buildWhereFieldsSchema(model, config, typeMap, schemaBuilder) {
   if (!modelFields)
     throw new ShapeError(`Unknown model: ${model}`);
   const fieldSchemas = {};
+  const fieldKeys = [];
   for (const [fieldName, value] of Object.entries(config)) {
     if (value !== true)
-      throw new ShapeError(`Field "${fieldName}" in connect/where config must be true`);
+      throw new ShapeError(
+        `Field "${fieldName}" in connect/where config must be true`
+      );
     const meta = modelFields[fieldName];
     if (!meta)
       throw new ShapeError(`Unknown field "${fieldName}" on model "${model}"`);
     if (meta.isRelation)
-      throw new ShapeError(`Relation field "${fieldName}" cannot be used in connect/where`);
+      throw new ShapeError(
+        `Relation field "${fieldName}" cannot be used in connect/where`
+      );
     fieldSchemas[fieldName] = schemaBuilder.buildFieldSchema(model, fieldName).optional();
+    fieldKeys.push(fieldName);
   }
-  return import_zod8.z.object(fieldSchemas).strict();
+  return import_zod8.z.object(fieldSchemas).strict().refine(
+    (v) => fieldKeys.some((k) => v[k] !== void 0),
+    { message: `At least one field required in connect/where` }
+  );
 }
 function buildNestedDataSchema(model, config, typeMap, schemaBuilder) {
   const modelFields = typeMap[model];
@@ -2970,14 +2994,20 @@ function buildNestedDataSchema(model, config, typeMap, schemaBuilder) {
   const fieldSchemas = {};
   for (const [fieldName, value] of Object.entries(config)) {
     if (value !== true)
-      throw new ShapeError(`Field "${fieldName}" in nested data config must be true`);
+      throw new ShapeError(
+        `Field "${fieldName}" in nested data config must be true`
+      );
     const meta = modelFields[fieldName];
     if (!meta)
       throw new ShapeError(`Unknown field "${fieldName}" on model "${model}"`);
     if (meta.isRelation)
-      throw new ShapeError(`Nested relation writes inside nested data are not supported ("${model}.${fieldName}")`);
+      throw new ShapeError(
+        `Nested relation writes inside nested data are not supported ("${model}.${fieldName}")`
+      );
     if (meta.isUpdatedAt)
-      throw new ShapeError(`updatedAt field "${fieldName}" cannot be used in nested data`);
+      throw new ShapeError(
+        `updatedAt field "${fieldName}" cannot be used in nested data`
+      );
     let fieldSchema = schemaBuilder.buildFieldSchema(model, fieldName);
     if (!meta.isRequired) {
       fieldSchema = fieldSchema.nullable().optional();
@@ -2991,55 +3021,106 @@ function buildNestedDataSchema(model, config, typeMap, schemaBuilder) {
 function buildRelationWriteSchema(model, fieldName, relatedModelName, isList, config, typeMap, schemaBuilder) {
   const relatedFields = typeMap[relatedModelName];
   if (!relatedFields)
-    throw new ShapeError(`Unknown related model "${relatedModelName}" for field "${model}.${fieldName}"`);
+    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(", ")}`);
+      throw new ShapeError(
+        `Unknown relation write operation "${key}" on "${model}.${fieldName}". Allowed: ${[...KNOWN_RELATION_WRITE_OPS].join(", ")}`
+      );
     }
   }
   const opSchemas = {};
   if (config.connect !== void 0) {
     if (!isPlainObject(config.connect)) {
-      throw new ShapeError(`connect config on "${model}.${fieldName}" must be an object of field names`);
+      throw new ShapeError(
+        `connect config on "${model}.${fieldName}" must be an object of field names`
+      );
     }
-    const connectSchema = buildWhereFieldsSchema(relatedModelName, config.connect, typeMap, schemaBuilder);
-    opSchemas["connect"] = isList ? import_zod8.z.union([connectSchema, import_zod8.z.preprocess(coerceToArray, import_zod8.z.array(connectSchema))]).optional() : connectSchema.optional();
+    const connectSchema = buildWhereFieldsSchema(
+      relatedModelName,
+      config.connect,
+      typeMap,
+      schemaBuilder
+    );
+    opSchemas["connect"] = isList ? import_zod8.z.union([
+      connectSchema,
+      import_zod8.z.preprocess(coerceToArray, import_zod8.z.array(connectSchema))
+    ]).optional() : connectSchema.optional();
   }
   if (config.connectOrCreate !== void 0) {
     if (!isPlainObject(config.connectOrCreate)) {
-      throw new ShapeError(`connectOrCreate config on "${model}.${fieldName}" must be an object with "where" and "create"`);
+      throw new ShapeError(
+        `connectOrCreate config on "${model}.${fieldName}" must be an object with "where" and "create"`
+      );
     }
     const coc = config.connectOrCreate;
     if (!coc.where || !isPlainObject(coc.where)) {
-      throw new ShapeError(`connectOrCreate on "${model}.${fieldName}" requires "where" object`);
+      throw new ShapeError(
+        `connectOrCreate on "${model}.${fieldName}" requires "where" object`
+      );
     }
     if (!coc.create || !isPlainObject(coc.create)) {
-      throw new ShapeError(`connectOrCreate on "${model}.${fieldName}" requires "create" object`);
+      throw new ShapeError(
+        `connectOrCreate on "${model}.${fieldName}" requires "create" object`
+      );
     }
-    const whereSchema = buildWhereFieldsSchema(relatedModelName, coc.where, typeMap, schemaBuilder);
-    const createSchema = buildNestedDataSchema(relatedModelName, coc.create, typeMap, schemaBuilder);
+    const whereSchema = buildWhereFieldsSchema(
+      relatedModelName,
+      coc.where,
+      typeMap,
+      schemaBuilder
+    );
+    const createSchema = buildNestedDataSchema(
+      relatedModelName,
+      coc.create,
+      typeMap,
+      schemaBuilder
+    );
     const cocSchema = import_zod8.z.object({ where: whereSchema, create: createSchema }).strict();
     opSchemas["connectOrCreate"] = isList ? import_zod8.z.union([cocSchema, import_zod8.z.preprocess(coerceToArray, import_zod8.z.array(cocSchema))]).optional() : cocSchema.optional();
   }
   if (config.create !== void 0) {
     if (!isPlainObject(config.create)) {
-      throw new ShapeError(`create config on "${model}.${fieldName}" must be an object of field names`);
+      throw new ShapeError(
+        `create config on "${model}.${fieldName}" must be an object of field names`
+      );
     }
-    const createSchema = buildNestedDataSchema(relatedModelName, config.create, typeMap, schemaBuilder);
-    opSchemas["create"] = isList ? import_zod8.z.union([createSchema, import_zod8.z.preprocess(coerceToArray, import_zod8.z.array(createSchema))]).optional() : createSchema.optional();
+    const createSchema = buildNestedDataSchema(
+      relatedModelName,
+      config.create,
+      typeMap,
+      schemaBuilder
+    );
+    opSchemas["create"] = isList ? import_zod8.z.union([
+      createSchema,
+      import_zod8.z.preprocess(coerceToArray, import_zod8.z.array(createSchema))
+    ]).optional() : createSchema.optional();
   }
   if (config.createMany !== void 0) {
     if (!isList) {
-      throw new ShapeError(`createMany is only valid on to-many relations ("${model}.${fieldName}")`);
+      throw new ShapeError(
+        `createMany is only valid on to-many relations ("${model}.${fieldName}")`
+      );
     }
     if (!isPlainObject(config.createMany)) {
-      throw new ShapeError(`createMany config on "${model}.${fieldName}" must be an object`);
+      throw new ShapeError(
+        `createMany config on "${model}.${fieldName}" must be an object`
+      );
     }
     const cmConfig = config.createMany;
     if (!cmConfig.data || !isPlainObject(cmConfig.data)) {
-      throw new ShapeError(`createMany on "${model}.${fieldName}" requires "data" object`);
+      throw new ShapeError(
+        `createMany on "${model}.${fieldName}" requires "data" object`
+      );
     }
-    const dataSchema = buildNestedDataSchema(relatedModelName, cmConfig.data, typeMap, schemaBuilder);
+    const dataSchema = buildNestedDataSchema(
+      relatedModelName,
+      cmConfig.data,
+      typeMap,
+      schemaBuilder
+    );
     const cmSchemaFields = {
       data: import_zod8.z.preprocess(coerceToArray, import_zod8.z.array(dataSchema))
     };
@@ -3051,111 +3132,280 @@ function buildRelationWriteSchema(model, fieldName, relatedModelName, isList, co
   if (config.disconnect !== void 0) {
     if (config.disconnect === true) {
       if (isList) {
-        throw new ShapeError(`disconnect on to-many relation "${model}.${fieldName}" requires field config, not true`);
+        throw new ShapeError(
+          `disconnect on to-many relation "${model}.${fieldName}" requires field config, not true`
+        );
       }
       opSchemas["disconnect"] = import_zod8.z.literal(true).optional();
     } else if (isPlainObject(config.disconnect)) {
-      const disconnectSchema = buildWhereFieldsSchema(relatedModelName, config.disconnect, typeMap, schemaBuilder);
-      opSchemas["disconnect"] = isList ? import_zod8.z.union([disconnectSchema, import_zod8.z.preprocess(coerceToArray, import_zod8.z.array(disconnectSchema))]).optional() : disconnectSchema.optional();
+      const disconnectSchema = buildWhereFieldsSchema(
+        relatedModelName,
+        config.disconnect,
+        typeMap,
+        schemaBuilder
+      );
+      if (isList) {
+        opSchemas["disconnect"] = import_zod8.z.union([
+          disconnectSchema,
+          import_zod8.z.preprocess(coerceToArray, import_zod8.z.array(disconnectSchema))
+        ]).optional();
+      } else {
+        opSchemas["disconnect"] = import_zod8.z.union([import_zod8.z.literal(true), disconnectSchema]).optional();
+      }
     } else {
-      throw new ShapeError(`disconnect config on "${model}.${fieldName}" must be true (to-one) or an object of field names`);
+      throw new ShapeError(
+        `disconnect config on "${model}.${fieldName}" must be true (to-one) or an object of field names`
+      );
     }
   }
   if (config.delete !== void 0) {
     if (config.delete === true) {
       if (isList) {
-        throw new ShapeError(`delete on to-many relation "${model}.${fieldName}" requires field config, not true`);
+        throw new ShapeError(
+          `delete on to-many relation "${model}.${fieldName}" requires field config, not true`
+        );
       }
       opSchemas["delete"] = import_zod8.z.literal(true).optional();
     } else if (isPlainObject(config.delete)) {
-      const deleteSchema = buildWhereFieldsSchema(relatedModelName, config.delete, typeMap, schemaBuilder);
-      opSchemas["delete"] = isList ? import_zod8.z.union([deleteSchema, import_zod8.z.preprocess(coerceToArray, import_zod8.z.array(deleteSchema))]).optional() : deleteSchema.optional();
+      const deleteSchema = buildWhereFieldsSchema(
+        relatedModelName,
+        config.delete,
+        typeMap,
+        schemaBuilder
+      );
+      if (isList) {
+        opSchemas["delete"] = import_zod8.z.union([
+          deleteSchema,
+          import_zod8.z.preprocess(coerceToArray, import_zod8.z.array(deleteSchema))
+        ]).optional();
+      } else {
+        opSchemas["delete"] = import_zod8.z.union([import_zod8.z.literal(true), deleteSchema]).optional();
+      }
     } else {
-      throw new ShapeError(`delete config on "${model}.${fieldName}" must be true (to-one) or an object of field names`);
+      throw new ShapeError(
+        `delete config on "${model}.${fieldName}" must be true (to-one) or an object of field names`
+      );
+    }
+  }
+  if (config.delete !== void 0) {
+    if (config.delete === true) {
+      if (isList) {
+        throw new ShapeError(
+          `delete on to-many relation "${model}.${fieldName}" requires field config, not true`
+        );
+      }
+      opSchemas["delete"] = import_zod8.z.literal(true).optional();
+    } else if (isPlainObject(config.delete)) {
+      const deleteSchema = buildWhereFieldsSchema(
+        relatedModelName,
+        config.delete,
+        typeMap,
+        schemaBuilder
+      );
+      opSchemas["delete"] = isList ? import_zod8.z.union([
+        deleteSchema,
+        import_zod8.z.preprocess(coerceToArray, import_zod8.z.array(deleteSchema))
+      ]).optional() : deleteSchema.optional();
+    } else {
+      throw new ShapeError(
+        `delete config on "${model}.${fieldName}" must be true (to-one) or an object of field names`
+      );
     }
   }
   if (config.set !== void 0) {
     if (!isList) {
-      throw new ShapeError(`set is only valid on to-many relations ("${model}.${fieldName}")`);
+      throw new ShapeError(
+        `set is only valid on to-many relations ("${model}.${fieldName}")`
+      );
     }
     if (!isPlainObject(config.set)) {
-      throw new ShapeError(`set config on "${model}.${fieldName}" must be an object of field names`);
+      throw new ShapeError(
+        `set config on "${model}.${fieldName}" must be an object of field names`
+      );
     }
-    const setSchema = buildWhereFieldsSchema(relatedModelName, config.set, typeMap, schemaBuilder);
+    const setSchema = buildWhereFieldsSchema(
+      relatedModelName,
+      config.set,
+      typeMap,
+      schemaBuilder
+    );
     opSchemas["set"] = import_zod8.z.preprocess(coerceToArray, import_zod8.z.array(setSchema)).optional();
   }
   if (config.update !== void 0) {
     if (!isPlainObject(config.update)) {
-      throw new ShapeError(`update config on "${model}.${fieldName}" must be an object`);
+      throw new ShapeError(
+        `update config on "${model}.${fieldName}" must be an object`
+      );
     }
     const updateConfig = config.update;
     if (isList) {
       if (!updateConfig.where || !isPlainObject(updateConfig.where)) {
-        throw new ShapeError(`update on to-many "${model}.${fieldName}" requires "where" object`);
+        throw new ShapeError(
+          `update on to-many "${model}.${fieldName}" requires "where" object`
+        );
       }
       if (!updateConfig.data || !isPlainObject(updateConfig.data)) {
-        throw new ShapeError(`update on to-many "${model}.${fieldName}" requires "data" object`);
+        throw new ShapeError(
+          `update on to-many "${model}.${fieldName}" requires "data" object`
+        );
       }
-      const whereSchema = buildWhereFieldsSchema(relatedModelName, updateConfig.where, typeMap, schemaBuilder);
-      const dataSchema = buildNestedDataSchema(relatedModelName, updateConfig.data, typeMap, schemaBuilder);
+      const whereSchema = buildWhereFieldsSchema(
+        relatedModelName,
+        updateConfig.where,
+        typeMap,
+        schemaBuilder
+      );
+      const dataSchema = buildNestedDataSchema(
+        relatedModelName,
+        updateConfig.data,
+        typeMap,
+        schemaBuilder
+      );
       const updateSchema = import_zod8.z.object({ where: whereSchema, data: dataSchema }).strict();
-      opSchemas["update"] = import_zod8.z.union([updateSchema, import_zod8.z.preprocess(coerceToArray, import_zod8.z.array(updateSchema))]).optional();
+      opSchemas["update"] = import_zod8.z.union([
+        updateSchema,
+        import_zod8.z.preprocess(coerceToArray, import_zod8.z.array(updateSchema))
+      ]).optional();
     } else {
-      const dataSchema = buildNestedDataSchema(relatedModelName, updateConfig, typeMap, schemaBuilder);
+      const dataSchema = buildNestedDataSchema(
+        relatedModelName,
+        updateConfig,
+        typeMap,
+        schemaBuilder
+      );
       opSchemas["update"] = dataSchema.optional();
     }
   }
   if (config.upsert !== void 0) {
     if (!isPlainObject(config.upsert)) {
-      throw new ShapeError(`upsert config on "${model}.${fieldName}" must be an object`);
+      throw new ShapeError(
+        `upsert config on "${model}.${fieldName}" must be an object`
+      );
     }
     const upsertConfig = config.upsert;
-    if (!upsertConfig.where || !isPlainObject(upsertConfig.where)) {
-      throw new ShapeError(`upsert on "${model}.${fieldName}" requires "where" object`);
-    }
     if (!upsertConfig.create || !isPlainObject(upsertConfig.create)) {
-      throw new ShapeError(`upsert on "${model}.${fieldName}" requires "create" object`);
+      throw new ShapeError(
+        `upsert on "${model}.${fieldName}" requires "create" object`
+      );
     }
     if (!upsertConfig.update || !isPlainObject(upsertConfig.update)) {
-      throw new ShapeError(`upsert on "${model}.${fieldName}" requires "update" object`);
+      throw new ShapeError(
+        `upsert on "${model}.${fieldName}" requires "update" object`
+      );
+    }
+    const createSchema = buildNestedDataSchema(
+      relatedModelName,
+      upsertConfig.create,
+      typeMap,
+      schemaBuilder
+    );
+    const updateSchema = buildNestedDataSchema(
+      relatedModelName,
+      upsertConfig.update,
+      typeMap,
+      schemaBuilder
+    );
+    if (isList) {
+      if (!upsertConfig.where || !isPlainObject(upsertConfig.where)) {
+        throw new ShapeError(
+          `upsert on to-many "${model}.${fieldName}" requires "where" object`
+        );
+      }
+      const whereSchema = buildWhereFieldsSchema(
+        relatedModelName,
+        upsertConfig.where,
+        typeMap,
+        schemaBuilder
+      );
+      const upsertSchema = import_zod8.z.object({
+        where: whereSchema,
+        create: createSchema,
+        update: updateSchema
+      }).strict();
+      opSchemas["upsert"] = import_zod8.z.union([
+        upsertSchema,
+        import_zod8.z.preprocess(coerceToArray, import_zod8.z.array(upsertSchema))
+      ]).optional();
+    } else {
+      if (upsertConfig.where) {
+        const whereSchema = buildWhereFieldsSchema(
+          relatedModelName,
+          upsertConfig.where,
+          typeMap,
+          schemaBuilder
+        );
+        const upsertSchema = import_zod8.z.object({
+          where: whereSchema,
+          create: createSchema,
+          update: updateSchema
+        }).strict();
+        opSchemas["upsert"] = upsertSchema.optional();
+      } else {
+        const upsertSchema = import_zod8.z.object({ create: createSchema, update: updateSchema }).strict();
+        opSchemas["upsert"] = upsertSchema.optional();
+      }
     }
-    const whereSchema = buildWhereFieldsSchema(relatedModelName, upsertConfig.where, typeMap, schemaBuilder);
-    const createSchema = buildNestedDataSchema(relatedModelName, upsertConfig.create, typeMap, schemaBuilder);
-    const updateSchema = buildNestedDataSchema(relatedModelName, upsertConfig.update, typeMap, schemaBuilder);
-    const upsertSchema = import_zod8.z.object({ where: whereSchema, create: createSchema, update: updateSchema }).strict();
-    opSchemas["upsert"] = isList ? import_zod8.z.union([upsertSchema, import_zod8.z.preprocess(coerceToArray, import_zod8.z.array(upsertSchema))]).optional() : upsertSchema.optional();
   }
   if (config.updateMany !== void 0) {
     if (!isList) {
-      throw new ShapeError(`updateMany is only valid on to-many relations ("${model}.${fieldName}")`);
+      throw new ShapeError(
+        `updateMany is only valid on to-many relations ("${model}.${fieldName}")`
+      );
     }
     if (!isPlainObject(config.updateMany)) {
-      throw new ShapeError(`updateMany config on "${model}.${fieldName}" must be an object`);
+      throw new ShapeError(
+        `updateMany config on "${model}.${fieldName}" must be an object`
+      );
     }
     const umConfig = config.updateMany;
     if (!umConfig.where || !isPlainObject(umConfig.where)) {
-      throw new ShapeError(`updateMany on "${model}.${fieldName}" requires "where" object`);
+      throw new ShapeError(
+        `updateMany on "${model}.${fieldName}" requires "where" object`
+      );
     }
     if (!umConfig.data || !isPlainObject(umConfig.data)) {
-      throw new ShapeError(`updateMany on "${model}.${fieldName}" requires "data" object`);
+      throw new ShapeError(
+        `updateMany on "${model}.${fieldName}" requires "data" object`
+      );
     }
-    const whereSchema = buildWhereFieldsSchema(relatedModelName, umConfig.where, typeMap, schemaBuilder);
-    const dataSchema = buildNestedDataSchema(relatedModelName, umConfig.data, typeMap, schemaBuilder);
+    const whereSchema = buildWhereFieldsSchema(
+      relatedModelName,
+      umConfig.where,
+      typeMap,
+      schemaBuilder
+    );
+    const dataSchema = buildNestedDataSchema(
+      relatedModelName,
+      umConfig.data,
+      typeMap,
+      schemaBuilder
+    );
     const umSchema = import_zod8.z.object({ where: whereSchema, data: dataSchema }).strict();
     opSchemas["updateMany"] = import_zod8.z.union([umSchema, import_zod8.z.preprocess(coerceToArray, import_zod8.z.array(umSchema))]).optional();
   }
   if (config.deleteMany !== void 0) {
     if (!isList) {
-      throw new ShapeError(`deleteMany is only valid on to-many relations ("${model}.${fieldName}")`);
+      throw new ShapeError(
+        `deleteMany is only valid on to-many relations ("${model}.${fieldName}")`
+      );
     }
     if (!isPlainObject(config.deleteMany)) {
-      throw new ShapeError(`deleteMany config on "${model}.${fieldName}" must be an object`);
+      throw new ShapeError(
+        `deleteMany config on "${model}.${fieldName}" must be an object`
+      );
     }
     const dmConfig = config.deleteMany;
     if (!dmConfig.where || !isPlainObject(dmConfig.where)) {
-      throw new ShapeError(`deleteMany on "${model}.${fieldName}" requires "where" object`);
+      throw new ShapeError(
+        `deleteMany on "${model}.${fieldName}" requires "where" object`
+      );
     }
-    const whereSchema = buildWhereFieldsSchema(relatedModelName, dmConfig.where, typeMap, schemaBuilder);
+    const whereSchema = buildWhereFieldsSchema(
+      relatedModelName,
+      dmConfig.where,
+      typeMap,
+      schemaBuilder
+    );
     const dmSchema = import_zod8.z.object({ where: whereSchema }).strict();
     opSchemas["deleteMany"] = import_zod8.z.union([dmSchema, import_zod8.z.preprocess(coerceToArray, import_zod8.z.array(dmSchema))]).optional();
   }
@@ -3175,7 +3425,9 @@ function buildDataSchema(model, dataConfig, mode, typeMap, schemaBuilder, zodDef
       throw new ShapeError(`Unknown field "${fieldName}" on model "${model}"`);
     if (fieldMeta.isRelation) {
       if (!isPlainObject(value)) {
-        throw new ShapeError(`Relation field "${fieldName}" on model "${model}" requires a relation write config object`);
+        throw new ShapeError(
+          `Relation field "${fieldName}" on model "${model}" requires a relation write config object`
+        );
       }
       schemaMap[fieldName] = buildRelationWriteSchema(
         model,
@@ -3189,9 +3441,14 @@ function buildDataSchema(model, dataConfig, mode, typeMap, schemaBuilder, zodDef
       continue;
     }
     if (fieldMeta.isUpdatedAt)
-      throw new ShapeError(`updatedAt field "${fieldName}" cannot be used in data shape`);
+      throw new ShapeError(
+        `updatedAt field "${fieldName}" cannot be used in data shape`
+      );
     if (typeof value === "function") {
-      let baseSchema = schemaBuilder.buildBaseFieldSchema(model, fieldName);
+      let baseSchema = schemaBuilder.buildBaseFieldSchema(
+        model,
+        fieldName
+      );
       let refined;
       try {
         refined = value(baseSchema);
@@ -3202,7 +3459,9 @@ function buildDataSchema(model, dataConfig, mode, typeMap, schemaBuilder, zodDef
         );
       }
       if (!isZodSchema(refined)) {
-        throw new ShapeError(`Inline refine for "${model}.${fieldName}" must return a Zod schema`);
+        throw new ShapeError(
+          `Inline refine for "${model}.${fieldName}" must return a Zod schema`
+        );
       }
       let fieldSchema = refined;
       const handlesUndefined = schemaProducesValueForUndefined(fieldSchema);
@@ -3223,7 +3482,10 @@ function buildDataSchema(model, dataConfig, mode, typeMap, schemaBuilder, zodDef
       }
       schemaMap[fieldName] = fieldSchema;
     } else if (value === true) {
-      let fieldSchema = schemaBuilder.buildFieldSchema(model, fieldName);
+      let fieldSchema = schemaBuilder.buildFieldSchema(
+        model,
+        fieldName
+      );
       const isZodDefaultField = zodDefaultSet !== void 0 && zodDefaultSet.has(fieldName);
       if (mode === "create") {
         if (!fieldMeta.isRequired) {
@@ -3243,7 +3505,10 @@ function buildDataSchema(model, dataConfig, mode, typeMap, schemaBuilder, zodDef
       schemaMap[fieldName] = fieldSchema;
     } else {
       const actualValue = isForcedValue(value) ? value.value : value;
-      let fieldSchema = schemaBuilder.buildFieldSchema(model, fieldName);
+      let fieldSchema = schemaBuilder.buildFieldSchema(
+        model,
+        fieldName
+      );
       if (!fieldMeta.isRequired) {
         fieldSchema = fieldSchema.nullable();
       }