prisma-guard 1.11.0 → 1.12.0

package/dist/runtime/index.cjs

@@ -2858,6 +2858,19 @@ var VALID_SHAPE_KEYS_UPDATE_PROJECTION = /* @__PURE__ */ new Set(["data", "where
 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 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)) {
@@ -2882,6 +2895,26 @@ 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;
@@ -2897,11 +2930,237 @@ 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`
     );
   }
 }
+function buildWhereFieldsSchema(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 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();
+  }
+  return import_zod8.z.object(fieldSchemas).strict();
+}
+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);
+      opSchemas["disconnect"] = isList ? import_zod8.z.union([disconnectSchema, import_zod8.z.preprocess(coerceToArray, import_zod8.z.array(disconnectSchema))]).optional() : 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);
+      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.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`);
+    }
+    if (!upsertConfig.update || !isPlainObject(upsertConfig.update)) {
+      throw new ShapeError(`upsert on "${model}.${fieldName}" requires "update" object`);
+    }
+    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}")`);
+    }
+    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,8 +3173,21 @@ 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`);
     if (typeof value === "function") {