zod-nest 3.1.0 → 3.2.0

package/dist/fastify/index.mjs

@@ -103,15 +103,18 @@ var sizeCheck = /* @__PURE__ */ __name((readSize, options) => {
 // src/multipart/file-marker.ts
 var fileSchemas = /* @__PURE__ */ new WeakSet();
 var isZodType = /* @__PURE__ */ __name((value) => value !== null && typeof value === "object" && "_zod" in value, "isZodType");
-var unwrapOnce = /* @__PURE__ */ __name((schema) => {
-  const def = schema._zod.def;
+var innerOf = /* @__PURE__ */ __name((def) => {
   if ("innerType" in def) {
-    return isZodType(def.innerType) ? def.innerType : void 0;
+    return def.innerType;
   }
   if ("element" in def) {
-    return isZodType(def.element) ? def.element : void 0;
+    return def.element;
   }
   return void 0;
+}, "innerOf");
+var unwrapOnce = /* @__PURE__ */ __name((schema) => {
+  const inner = innerOf(schema._zod.def);
+  return isZodType(inner) ? inner : void 0;
 }, "unwrapOnce");
 var markFileSchema = /* @__PURE__ */ __name((schema) => {
   fileSchemas.add(schema);
@@ -787,12 +790,172 @@ var toOpenApi = /* @__PURE__ */ __name((schema, opts) => {
   return result;
 }, "toOpenApi");
 
+// src/schema/anon-id.ts
+var ANON_BODY_PREFIX = "_AnonBodySchema_";
+var anonIdCache = /* @__PURE__ */ new WeakMap();
+var counter = 0;
+var resolveAnonId = /* @__PURE__ */ __name((schema, prefix) => {
+  const cached = anonIdCache.get(schema);
+  if (cached !== void 0) {
+    return cached;
+  }
+  counter += 1;
+  const id = `${prefix}${counter}`;
+  anonIdCache.set(schema, id);
+  return id;
+}, "resolveAnonId");
+
+// src/decorators/internal/zod-schema-ref.ts
+function resolveSchemaRef(schema, options) {
+  const registry = options?.registry ?? defaultRegistry;
+  const id = registerSchema(schema, registry, {
+    id: options?.id
+  });
+  if (id !== void 0) {
+    return {
+      kind: "ref",
+      ref: {
+        $ref: `${COMPONENTS_SCHEMAS_PREFIX}${id}`
+      }
+    };
+  }
+  if (options?.deferAnonInline === true) {
+    const anonId = resolveAnonId(schema, ANON_BODY_PREFIX);
+    registerSchema(schema, registry, {
+      id: anonId,
+      anonymous: true
+    });
+    return {
+      kind: "ref",
+      ref: {
+        $ref: `${COMPONENTS_SCHEMAS_PREFIX}${anonId}`
+      }
+    };
+  }
+  for (const [child, childId] of discoverDependents(schema)) {
+    registry.register(child, childId);
+  }
+  const { schema: body } = toOpenApi(schema, {
+    io: "input",
+    registry
+  });
+  return {
+    kind: "inline",
+    schema: body
+  };
+}
+__name(resolveSchemaRef, "resolveSchemaRef");
+
+// src/decorators/internal/zod-param-expand.ts
+var isZodObject = /* @__PURE__ */ __name((schema) => schema._zod.def.type === "object", "isZodObject");
+
+// src/decorators/internal/flatten-intersection.ts
+var intersectionArms = /* @__PURE__ */ __name((schema) => {
+  if (schema._zod.def.type !== "intersection") {
+    return null;
+  }
+  const def = schema._zod.def;
+  return {
+    left: def.left,
+    right: def.right
+  };
+}, "intersectionArms");
+var unionOptions = /* @__PURE__ */ __name((schema) => {
+  if (schema._zod.def.type !== "union") {
+    return null;
+  }
+  const def = schema._zod.def;
+  return def.options;
+}, "unionOptions");
+var collectObjectShapes = /* @__PURE__ */ __name((schema) => {
+  if (isZodObject(schema)) {
+    return {
+      shapes: [
+        schema.shape
+      ],
+      unionCrossed: false
+    };
+  }
+  const options = unionOptions(schema);
+  if (options !== null) {
+    const allShapes = [];
+    for (const variant of options) {
+      const variantResult = collectObjectShapes(variant);
+      if (variantResult === null) {
+        return null;
+      }
+      allShapes.push(...variantResult.shapes);
+    }
+    return {
+      shapes: allShapes,
+      unionCrossed: true
+    };
+  }
+  const arms = intersectionArms(schema);
+  if (arms === null) {
+    return null;
+  }
+  const left = collectObjectShapes(arms.left);
+  if (left === null) {
+    return null;
+  }
+  const right = collectObjectShapes(arms.right);
+  if (right === null) {
+    return null;
+  }
+  return {
+    shapes: [
+      ...left.shapes,
+      ...right.shapes
+    ],
+    unionCrossed: left.unionCrossed || right.unionCrossed
+  };
+}, "collectObjectShapes");
+var flattenObjectIntersection = /* @__PURE__ */ __name((schema, registry, decoratorName) => {
+  const collected = collectObjectShapes(schema);
+  if (collected === null) {
+    throw new ZodNestError(`${decoratorName} \`flatten: true\` requires every leaf of the schema to be a \`z.object({...})\` \u2014 intersections and unions of objects are supported, but primitives, tuples, transforms, and other non-object leaves are not. Drop \`flatten: true\` to emit the original schema with its composition intact.`);
+  }
+  const mergedShape = {};
+  for (const shape of collected.shapes) {
+    Object.assign(mergedShape, shape);
+  }
+  if (collected.unionCrossed) {
+    for (const key of Object.keys(mergedShape)) {
+      const value = mergedShape[key];
+      if (value !== void 0) {
+        mergedShape[key] = value.optional();
+      }
+    }
+  }
+  const merged = z.object(mergedShape);
+  registerSchema(schema, registry);
+  for (const [child, childId] of discoverDependents(schema)) {
+    registry.register(child, childId);
+  }
+  const { schema: body } = toOpenApi(merged, {
+    io: "input",
+    registry
+  });
+  return body;
+}, "flattenObjectIntersection");
+var isZodSchema = /* @__PURE__ */ __name((value) => value instanceof z.ZodType, "isZodSchema");
+
 // src/multipart/zod-multipart.decorator.ts
 var MULTIPART_CONTENT_TYPE = "multipart/form-data";
+var toSchema = /* @__PURE__ */ __name((body) => isZodSchema(body) ? body : z.object({
+  ...body
+}), "toSchema");
+var toShape = /* @__PURE__ */ __name((body) => {
+  if (!isZodSchema(body)) {
+    return body;
+  }
+  return isZodObject(body) ? body.shape : void 0;
+}, "toShape");
 var partitionKeys = /* @__PURE__ */ __name((shape) => {
   const fileKeys = [];
   const textKeys = [];
-  for (const [key, schema] of Object.entries(shape)) {
+  for (const [key, schema] of Object.entries(shape ?? {})) {
     if (isFileSchema(schema)) {
       fileKeys.push(key);
       continue;
@@ -804,30 +967,28 @@ var partitionKeys = /* @__PURE__ */ __name((shape) => {
     textKeys
   };
 }, "partitionKeys");
-var emitInlineBody = /* @__PURE__ */ __name((shape, registry) => {
-  const object = z.object({
-    ...shape
-  });
-  for (const [child, childId] of discoverDependents(object)) {
-    registry.register(child, childId);
+var resolveBody = /* @__PURE__ */ __name((schema, options, registry) => {
+  if (options?.flatten === true) {
+    return flattenObjectIntersection(schema, registry, "@ZodMultipart");
   }
-  const { schema } = toOpenApi(object, {
-    io: "input",
+  const resolved = resolveSchemaRef(schema, {
+    ...options?.id !== void 0 ? {
+      id: options.id
+    } : {},
     registry
   });
-  return schema;
-}, "emitInlineBody");
+  return resolved.kind === "ref" ? resolved.ref : resolved.schema;
+}, "resolveBody");
 var createZodMultipart = /* @__PURE__ */ __name((defaultFilesIn) => {
-  return (shape, options) => {
+  return (body, options) => {
     const registry = options?.registry ?? defaultRegistry;
-    const { fileKeys, textKeys } = partitionKeys(shape);
+    const shape = toShape(body);
     const metadata = {
       shape,
-      fileKeys,
-      textKeys,
+      ...partitionKeys(shape),
       filesIn: options?.filesIn ?? defaultFilesIn
     };
-    const body = emitInlineBody(shape, registry);
+    const schema = resolveBody(toSchema(body), options, registry);
     return (target, propertyKey, descriptor) => {
       const handler = descriptor.value;
       if (typeof handler !== "function") {
@@ -837,7 +998,7 @@ var createZodMultipart = /* @__PURE__ */ __name((defaultFilesIn) => {
       const swaggerDescriptor = descriptor;
       ApiConsumes(MULTIPART_CONTENT_TYPE)(target, propertyKey, swaggerDescriptor);
       ApiBody({
-        schema: body,
+        schema,
         ...options?.description !== void 0 ? {
           description: options.description
         } : {},
@@ -874,10 +1035,17 @@ var readMetadata = /* @__PURE__ */ __name((ctx, decorator) => {
   return metadata;
 }, "readMetadata");
 var isMultipartMetadata = /* @__PURE__ */ __name((value) => value !== null && typeof value === "object" && "shape" in value && "filesIn" in value, "isMultipartMetadata");
+var requireShape = /* @__PURE__ */ __name((metadata, decorator) => {
+  if (metadata.shape !== void 0) {
+    return metadata.shape;
+  }
+  throw new Error(`[zod-nest] ${decorator} needs a flat body shape, but @ZodMultipart was given a composite schema (an intersection or union). Validate it with @Body(new ZodValidationPipe(schema)) instead.`);
+}, "requireShape");
 var schemaFor = /* @__PURE__ */ __name((metadata, name, decorator) => {
-  const schema = metadata.shape[name];
+  const shape = requireShape(metadata, decorator);
+  const schema = shape[name];
   if (schema === void 0) {
-    throw new Error(`[zod-nest] ${decorator}('${name}') has no matching property in the @ZodMultipart shape. Declared: ${Object.keys(metadata.shape).join(", ")}.`);
+    throw new Error(`[zod-nest] ${decorator}('${name}') has no matching property in the @ZodMultipart shape. Declared: ${Object.keys(shape).join(", ")}.`);
   }
   return schema;
 }, "schemaFor");
@@ -918,14 +1086,15 @@ var resolveUploadedFiles = /* @__PURE__ */ __name(async (name, ctx) => {
   const metadata = readMetadata(ctx, "@ZodUploadedFiles");
   assertFilesOnRequest(metadata, "@ZodUploadedFiles");
   const request = ctx.switchToHttp().getRequest();
-  const schema = name === void 0 ? pick(metadata.shape, metadata.fileKeys) : schemaFor(metadata, name, "@ZodUploadedFiles");
+  const schema = name === void 0 ? pick(requireShape(metadata, "@ZodUploadedFiles"), metadata.fileKeys) : schemaFor(metadata, name, "@ZodUploadedFiles");
   return validate(schema, request.files, "custom");
 }, "resolveUploadedFiles");
 var resolveMultipartBody = /* @__PURE__ */ __name(async (_data, ctx) => {
   const metadata = readMetadata(ctx, "@ZodMultipartBody");
+  const shape = requireShape(metadata, "@ZodMultipartBody");
   const request = ctx.switchToHttp().getRequest();
-  const keys = metadata.filesIn === MultipartFilesIn.Body ? Object.keys(metadata.shape) : metadata.textKeys;
-  return validate(pick(metadata.shape, keys), request.body, "body");
+  const keys = metadata.filesIn === MultipartFilesIn.Body ? Object.keys(shape) : metadata.textKeys;
+  return validate(pick(shape, keys), request.body, "body");
 }, "resolveMultipartBody");
 createParamDecorator(resolveUploadedFile);
 createParamDecorator(resolveUploadedFiles);