prisma-guard 1.11.0 → 1.13.0

package/dist/runtime/index.cjs

@@ -2843,21 +2843,80 @@ 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",
+  "create",
+  "createMany",
+  "disconnect",
+  "delete",
+  "set",
+  "update",
+  "updateMany",
+  "upsert",
+  "deleteMany"
+]);
 function validateMutationBodyKeys(body, allowed, method) {
   for (const key of Object.keys(body)) {
     if (!allowed.has(key)) {
@@ -2902,6 +2961,456 @@ function validateCreateCompleteness(modelName, dataConfig, typeMap, scopeFks, zo
     );
   }
 }
+function buildWhereFieldsSchema(model, config, typeMap, schemaBuilder) {
+  const modelFields = typeMap[model];
+  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`
+      );
+    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`
+      );
+    fieldSchemas[fieldName] = schemaBuilder.buildFieldSchema(model, fieldName).optional();
+    fieldKeys.push(fieldName);
+  }
+  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];
+  if (!modelFields)
+    throw new ShapeError(`Unknown model: ${model}`);
+  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`
+      );
+    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}")`
+      );
+    if (meta.isUpdatedAt)
+      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();
+    } else if (meta.hasDefault) {
+      fieldSchema = fieldSchema.optional();
+    }
+    fieldSchemas[fieldName] = fieldSchema;
+  }
+  return import_zod8.z.object(fieldSchemas).strict();
+}
+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}"`
+    );
+  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(", ")}`
+      );
+    }
+  }
+  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`
+      );
+    }
+    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"`
+      );
+    }
+    const coc = config.connectOrCreate;
+    if (!coc.where || !isPlainObject(coc.where)) {
+      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`
+      );
+    }
+    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`
+      );
+    }
+    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}")`
+      );
+    }
+    if (!isPlainObject(config.createMany)) {
+      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`
+      );
+    }
+    const dataSchema = buildNestedDataSchema(
+      relatedModelName,
+      cmConfig.data,
+      typeMap,
+      schemaBuilder
+    );
+    const cmSchemaFields = {
+      data: import_zod8.z.preprocess(coerceToArray, import_zod8.z.array(dataSchema))
+    };
+    if ("skipDuplicates" in cmConfig) {
+      cmSchemaFields["skipDuplicates"] = import_zod8.z.boolean().optional();
+    }
+    opSchemas["createMany"] = import_zod8.z.object(cmSchemaFields).strict().optional();
+  }
+  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`
+        );
+      }
+      opSchemas["disconnect"] = import_zod8.z.literal(true).optional();
+    } else if (isPlainObject(config.disconnect)) {
+      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`
+      );
+    }
+  }
+  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
+      );
+      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`
+      );
+    }
+  }
+  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}")`
+      );
+    }
+    if (!isPlainObject(config.set)) {
+      throw new ShapeError(
+        `set config on "${model}.${fieldName}" must be an object of field names`
+      );
+    }
+    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`
+      );
+    }
+    const updateConfig = config.update;
+    if (isList) {
+      if (!updateConfig.where || !isPlainObject(updateConfig.where)) {
+        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`
+        );
+      }
+      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();
+    } else {
+      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`
+      );
+    }
+    const upsertConfig = config.upsert;
+    if (!upsertConfig.create || !isPlainObject(upsertConfig.create)) {
+      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`
+      );
+    }
+    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();
+      }
+    }
+  }
+  if (config.updateMany !== void 0) {
+    if (!isList) {
+      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`
+      );
+    }
+    const umConfig = config.updateMany;
+    if (!umConfig.where || !isPlainObject(umConfig.where)) {
+      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`
+      );
+    }
+    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}")`
+      );
+    }
+    if (!isPlainObject(config.deleteMany)) {
+      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`
+      );
+    }
+    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();
+  }
+  return import_zod8.z.object(opSchemas).strict();
+}
 function buildDataSchema(model, dataConfig, mode, typeMap, schemaBuilder, zodDefaults) {
   const modelFields = typeMap[model];
   if (!modelFields)
@@ -2914,12 +3423,32 @@ function buildDataSchema(model, dataConfig, mode, typeMap, schemaBuilder, zodDef
     const fieldMeta = modelFields[fieldName];
     if (!fieldMeta)
       throw new ShapeError(`Unknown field "${fieldName}" on model "${model}"`);
-    if (fieldMeta.isRelation)
-      throw new ShapeError(`Relation field "${fieldName}" cannot be used in data shape`);
+    if (fieldMeta.isRelation) {
+      if (!isPlainObject(value)) {
+        throw new ShapeError(
+          `Relation field "${fieldName}" on model "${model}" requires a relation write config object`
+        );
+      }
+      schemaMap[fieldName] = buildRelationWriteSchema(
+        model,
+        fieldName,
+        fieldMeta.type,
+        fieldMeta.isList,
+        value,
+        typeMap,
+        schemaBuilder
+      ).optional();
+      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);
@@ -2930,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);
@@ -2951,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) {
@@ -2971,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();
       }