zod-nest 3.0.2 → 3.2.0

package/dist/express/index.mjs

@@ -0,0 +1,1139 @@
+import { z } from 'zod';
+import { ApiConsumes, ApiBody } from '@nestjs/swagger';
+import { BadRequestException, HttpStatus, createParamDecorator } from '@nestjs/common';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/helpers/fragments.ts
+var binaryFragment = {
+  type: "string",
+  format: "binary"
+};
+var binary = /* @__PURE__ */ __name((opts) => ({
+  ...binaryFragment,
+  ...opts
+}), "binary");
+
+// src/schema/custom-override.ts
+var customOverrideMap = /* @__PURE__ */ new WeakMap();
+var isWrapper = /* @__PURE__ */ __name((arg) => "input" in arg || "output" in arg, "isWrapper");
+var overrideJSONSchema = /* @__PURE__ */ __name((schema, arg) => {
+  const overrideSchema = isWrapper(arg) ? {
+    ...arg
+  } : {
+    input: arg,
+    output: arg
+  };
+  const schemaDescription = schema.description;
+  if (typeof schemaDescription === "string") {
+    overrideSchema.description = schemaDescription;
+  }
+  customOverrideMap.set(schema, overrideSchema);
+  return schema;
+}, "overrideJSONSchema");
+var peekRegistration = /* @__PURE__ */ __name((schema) => customOverrideMap.get(schema), "peekRegistration");
+var createCustomOverride = /* @__PURE__ */ __name((io) => {
+  return ({ zodSchema, jsonSchema }) => {
+    const record = customOverrideMap.get(zodSchema);
+    if (record === void 0) {
+      return;
+    }
+    const fragment = record[io];
+    if (fragment === void 0) {
+      return;
+    }
+    for (const key of Object.keys(jsonSchema)) {
+      Reflect.deleteProperty(jsonSchema, key);
+    }
+    Object.assign(jsonSchema, fragment);
+    if (fragment.description === void 0 && record.description !== void 0) {
+      jsonSchema.description = record.description;
+    }
+  };
+}, "createCustomOverride");
+
+// src/multipart/file-checks.ts
+var normalizeExtension = /* @__PURE__ */ __name((extension) => extension.startsWith(".") ? extension.toLowerCase() : `.${extension.toLowerCase()}`, "normalizeExtension");
+var mimeTypeCheck = /* @__PURE__ */ __name((accessors, options) => {
+  const allowed = new Set(options.mimeTypes.map((mimeType) => mimeType.toLowerCase()));
+  return (payload) => {
+    const mimeType = accessors.mimeType(payload.value).toLowerCase();
+    if (allowed.has(mimeType)) {
+      return;
+    }
+    payload.issues.push({
+      code: "custom",
+      input: payload.value,
+      message: `Expected one of ${options.mimeTypes.join(", ")}, received ${mimeType}`
+    });
+  };
+}, "mimeTypeCheck");
+var extensionCheck = /* @__PURE__ */ __name((accessors, options) => {
+  const allowed = new Set(options.extensions.map(normalizeExtension));
+  return (payload) => {
+    const fileName = accessors.fileName(payload.value).toLowerCase();
+    const matched = [
+      ...allowed
+    ].some((extension) => fileName.endsWith(extension));
+    if (matched) {
+      return;
+    }
+    payload.issues.push({
+      code: "custom",
+      input: payload.value,
+      message: `Expected a file ending in ${options.extensions.map(normalizeExtension).join(", ")}, received ${fileName}`
+    });
+  };
+}, "extensionCheck");
+var sizeCheck = /* @__PURE__ */ __name((readSize, options) => {
+  return (payload) => {
+    const size = readSize(payload.value);
+    if (size <= options.maxSize) {
+      return;
+    }
+    payload.issues.push({
+      code: "custom",
+      input: payload.value,
+      message: `Expected at most ${options.maxSize} bytes, received ${size}`
+    });
+  };
+}, "sizeCheck");
+
+// 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 innerOf = /* @__PURE__ */ __name((def) => {
+  if ("innerType" in def) {
+    return def.innerType;
+  }
+  if ("element" in def) {
+    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);
+  return schema;
+}, "markFileSchema");
+var isFileSchema = /* @__PURE__ */ __name((schema) => {
+  if (fileSchemas.has(schema)) {
+    return true;
+  }
+  const inner = unwrapOnce(schema);
+  if (inner === void 0) {
+    return false;
+  }
+  return isFileSchema(inner);
+}, "isFileSchema");
+
+// src/multipart/build-file-schema.ts
+var resolveFragment = /* @__PURE__ */ __name((options) => {
+  const contentMediaType = options?.contentMediaType ?? singleMimeType(options?.mimeTypes);
+  return binary({
+    ...options?.description !== void 0 ? {
+      description: options.description
+    } : {},
+    ...contentMediaType !== void 0 ? {
+      contentMediaType
+    } : {}
+  });
+}, "resolveFragment");
+var singleMimeType = /* @__PURE__ */ __name((mimeTypes) => {
+  if (mimeTypes === void 0 || mimeTypes.length !== 1) {
+    return void 0;
+  }
+  return mimeTypes[0];
+}, "singleMimeType");
+var collectChecks = /* @__PURE__ */ __name((params) => {
+  const { accessors, options, maxSize } = params;
+  const checks = [];
+  if (options?.mimeTypes !== void 0) {
+    checks.push(mimeTypeCheck(accessors, {
+      mimeTypes: options.mimeTypes
+    }));
+  }
+  if (options?.extensions !== void 0) {
+    checks.push(extensionCheck(accessors, {
+      extensions: options.extensions
+    }));
+  }
+  if (maxSize !== void 0 && accessors.size !== void 0) {
+    checks.push(sizeCheck(accessors.size, {
+      maxSize
+    }));
+  }
+  return checks;
+}, "collectChecks");
+var withId = /* @__PURE__ */ __name((schema, options, fragment) => {
+  if (options?.id === void 0) {
+    return schema;
+  }
+  return overrideJSONSchema(schema.meta({
+    id: options.id
+  }), fragment);
+}, "withId");
+var buildFileSchema = /* @__PURE__ */ __name((params) => {
+  const fragment = resolveFragment(params.options);
+  const base = overrideJSONSchema(z.custom(params.predicate), fragment);
+  const checks = collectChecks(params);
+  const checked = checks.length === 0 ? base : overrideJSONSchema(base.check(...checks), fragment);
+  return markFileSchema(withId(checked, params.options, fragment));
+}, "buildFileSchema");
+
+// src/multipart/metadata.ts
+var MultipartFilesIn = {
+  Request: "request",
+  Body: "body"
+};
+var ZOD_MULTIPART_METADATA_KEY = /* @__PURE__ */ Symbol.for("zod-nest.multipart");
+var INNER_TYPE_WRAPPERS = /* @__PURE__ */ new Set([
+  "optional",
+  "nullable",
+  "default",
+  "prefault",
+  "catch",
+  "nonoptional",
+  "success",
+  "readonly",
+  "promise"
+]);
+var readId = /* @__PURE__ */ __name((schema) => {
+  const meta = z.globalRegistry.get(schema);
+  if (meta === void 0) {
+    return void 0;
+  }
+  const id = meta.id;
+  return typeof id === "string" ? id : void 0;
+}, "readId");
+var resolveLazyTarget = /* @__PURE__ */ __name((getter) => {
+  try {
+    return [
+      getter()
+    ];
+  } catch (error) {
+    if (error instanceof ReferenceError) {
+      return [];
+    }
+    throw error;
+  }
+}, "resolveLazyTarget");
+var collectChildren = /* @__PURE__ */ __name((schema) => {
+  const def = schema._zod.def;
+  if (def.type === "object") {
+    const out = [];
+    const shape = def.shape;
+    if (shape !== void 0) {
+      for (const value of Object.values(shape)) {
+        out.push(value);
+      }
+    }
+    if (def.catchall !== void 0) {
+      out.push(def.catchall);
+    }
+    return out;
+  }
+  if (def.type === "array") {
+    return [
+      def.element
+    ];
+  }
+  if (def.type === "union") {
+    return def.options.map((opt) => opt);
+  }
+  if (def.type === "intersection") {
+    return [
+      def.left,
+      def.right
+    ];
+  }
+  if (def.type === "tuple") {
+    const out = def.items.map((it) => it);
+    if (def.rest !== null) {
+      out.push(def.rest);
+    }
+    return out;
+  }
+  if (def.type === "record" || def.type === "map") {
+    return [
+      def.keyType,
+      def.valueType
+    ];
+  }
+  if (def.type === "set") {
+    return [
+      def.valueType
+    ];
+  }
+  if (def.type === "pipe") {
+    return [
+      def.in,
+      def.out
+    ];
+  }
+  if (def.type === "lazy") {
+    return resolveLazyTarget(() => def.getter());
+  }
+  if (INNER_TYPE_WRAPPERS.has(def.type)) {
+    return [
+      def.innerType
+    ];
+  }
+  return [];
+}, "collectChildren");
+var discoverDependents = /* @__PURE__ */ __name((schema) => {
+  const visited = /* @__PURE__ */ new WeakSet();
+  const out = [];
+  const stack = [
+    schema
+  ];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (visited.has(current)) {
+      continue;
+    }
+    visited.add(current);
+    for (const child of collectChildren(current)) {
+      if (child === void 0 || visited.has(child)) {
+        continue;
+      }
+      const id = readId(child);
+      if (id !== void 0) {
+        out.push([
+          child,
+          id
+        ]);
+      }
+      stack.push(child);
+    }
+  }
+  return out;
+}, "discoverDependents");
+
+// src/schema/constants.ts
+var COMPONENTS_SCHEMAS_PREFIX = "#/components/schemas/";
+var DEFS_PREFIX = "#/$defs/";
+var ZOD_NEST_ERROR_EXTENSION = "x-zod-nest-error";
+var ZOD_NEST_ERROR_DUPLICATE_ID = "duplicate-id";
+var createRegistry = /* @__PURE__ */ __name(() => {
+  const seen = /* @__PURE__ */ new Map();
+  const forceExposed = /* @__PURE__ */ new Set();
+  const anonymous = /* @__PURE__ */ new Set();
+  const pendingRoots = [];
+  const recordOnce = /* @__PURE__ */ __name((schema, id) => {
+    let set = seen.get(id);
+    if (set === void 0) {
+      set = /* @__PURE__ */ new Set();
+      seen.set(id, set);
+    }
+    if (set.has(schema)) {
+      return false;
+    }
+    set.add(schema);
+    return true;
+  }, "recordOnce");
+  const flushPendingDiscovery = /* @__PURE__ */ __name(() => {
+    for (const root of pendingRoots.splice(0)) {
+      for (const [child, childId] of discoverDependents(root)) {
+        recordOnce(child, childId);
+      }
+    }
+  }, "flushPendingDiscovery");
+  return {
+    zodRegistry: z.globalRegistry,
+    register: /* @__PURE__ */ __name((schema, id, flags) => {
+      if (flags?.expose === true) {
+        forceExposed.add(id);
+      }
+      if (flags?.anonymous === true) {
+        anonymous.add(id);
+      }
+      if (z.globalRegistry.has(schema)) {
+        const existing = z.globalRegistry.get(schema);
+        if (existing?.id !== id) {
+          z.globalRegistry.add(schema, {
+            ...existing ?? {},
+            id
+          });
+        }
+      } else {
+        z.globalRegistry.add(schema, {
+          id
+        });
+      }
+      if (!recordOnce(schema, id)) {
+        return;
+      }
+      pendingRoots.push(schema);
+    }, "register"),
+    hasCollision: /* @__PURE__ */ __name((id) => {
+      flushPendingDiscovery();
+      const set = seen.get(id);
+      return set !== void 0 && set.size > 1;
+    }, "hasCollision"),
+    getCollisions: /* @__PURE__ */ __name(() => {
+      flushPendingDiscovery();
+      const out = /* @__PURE__ */ new Map();
+      for (const [id, set] of seen) {
+        if (set.size <= 1) {
+          continue;
+        }
+        out.set(id, set);
+      }
+      return out;
+    }, "getCollisions"),
+    ids: /* @__PURE__ */ __name(() => {
+      flushPendingDiscovery();
+      return [
+        ...seen.keys()
+      ];
+    }, "ids"),
+    forceExposedIds: /* @__PURE__ */ __name(() => [
+      ...forceExposed
+    ], "forceExposedIds"),
+    anonymousIds: /* @__PURE__ */ __name(() => [
+      ...anonymous
+    ], "anonymousIds")
+  };
+}, "createRegistry");
+var defaultRegistry = createRegistry();
+var registerSchema = /* @__PURE__ */ __name((schema, registry = defaultRegistry, options) => {
+  const flags = {
+    expose: options?.expose,
+    anonymous: options?.anonymous
+  };
+  const explicit = options?.id;
+  if (typeof explicit === "string" && explicit !== "") {
+    registry.register(schema, explicit, flags);
+    return explicit;
+  }
+  const meta = registry.zodRegistry.get(schema);
+  const metaId = meta === void 0 ? void 0 : meta.id;
+  if (typeof metaId !== "string" || metaId === "") {
+    return void 0;
+  }
+  registry.register(schema, metaId, flags);
+  return metaId;
+}, "registerSchema");
+
+// src/schema/composition.ts
+var lineageMap = /* @__PURE__ */ new WeakMap();
+var propsMap = /* @__PURE__ */ new WeakMap();
+var DEFAULT_BUILD_REF = /* @__PURE__ */ __name((id) => `${DEFS_PREFIX}${id}`, "DEFAULT_BUILD_REF");
+var createCompositionOverride = /* @__PURE__ */ __name((opts) => {
+  const { buildRef, registry } = opts;
+  return (ctx) => {
+    const { jsonSchema, zodSchema } = ctx;
+    const entry = lineageMap.get(zodSchema);
+    if (entry === void 0) {
+      return;
+    }
+    const parentCache = propsMap.get(entry.parent);
+    if (parentCache === void 0) {
+      return;
+    }
+    const parentId = registry.zodRegistry.get(entry.parent)?.id;
+    if (parentId === void 0) {
+      return;
+    }
+    registerSchema(entry.parent, registry);
+    const childProps = jsonSchema.properties ?? {};
+    const childRequired = jsonSchema.required ?? [];
+    const parentPropSet = new Set(parentCache.properties);
+    const parentReqSet = new Set(parentCache.required);
+    const deltaProps = {};
+    for (const [key, value] of Object.entries(childProps)) {
+      if (parentPropSet.has(key) && !entry.overriddenKeys.has(key)) {
+        continue;
+      }
+      deltaProps[key] = value;
+    }
+    const deltaRequired = childRequired.filter((key) => !parentReqSet.has(key) || entry.overriddenKeys.has(key));
+    const delta = {
+      type: "object",
+      properties: deltaProps
+    };
+    if (deltaRequired.length > 0) {
+      delta.required = deltaRequired;
+    }
+    delete jsonSchema.properties;
+    delete jsonSchema.required;
+    delete jsonSchema.additionalProperties;
+    jsonSchema.type = "object";
+    jsonSchema.allOf = [
+      {
+        $ref: buildRef(parentId)
+      },
+      delta
+    ];
+    jsonSchema.unevaluatedProperties = false;
+  };
+}, "createCompositionOverride");
+
+// src/schema/errors.ts
+var ZodNestError = class extends Error {
+  static {
+    __name(this, "ZodNestError");
+  }
+  constructor(message) {
+    super(message);
+    this.name = "ZodNestError";
+  }
+};
+var ZodNestUnrepresentableError = class extends ZodNestError {
+  static {
+    __name(this, "ZodNestUnrepresentableError");
+  }
+  path;
+  zodType;
+  constructor(path, zodType) {
+    super(`Unrepresentable Zod schema \`${zodType}\` at ${formatPath(path)}: no override produced a JSON Schema body. Set strict: false to emit \`{}\` instead, or supply an \`override\` that handles this Zod type.`);
+    this.name = "ZodNestUnrepresentableError";
+    this.path = path;
+    this.zodType = zodType;
+  }
+};
+var formatPath = /* @__PURE__ */ __name((path) => {
+  if (path.length === 0) {
+    return "<root>";
+  }
+  return "/" + path.map(String).join("/");
+}, "formatPath");
+
+// src/schema/override.ts
+var primitiveOverride = /* @__PURE__ */ __name(({ zodSchema, jsonSchema }) => {
+  const type = zodSchema._zod.def.type;
+  if (type === "bigint") {
+    jsonSchema.type = "integer";
+    return;
+  }
+  if (type === "date") {
+    jsonSchema.type = "string";
+    jsonSchema.format = "date-time";
+    return;
+  }
+}, "primitiveOverride");
+var combine = /* @__PURE__ */ __name((...overrides) => {
+  const list = [];
+  for (const candidate of overrides) {
+    if (typeof candidate !== "function") {
+      continue;
+    }
+    list.push(candidate);
+  }
+  return (ctx) => {
+    for (const o of list) {
+      o(ctx);
+    }
+  };
+}, "combine");
+
+// src/schema/post-process.ts
+var rewriteRefs = /* @__PURE__ */ __name((node, rootRef) => {
+  if (Array.isArray(node)) {
+    for (const item of node) {
+      rewriteRefs(item, rootRef);
+    }
+    return;
+  }
+  if (node === null || typeof node !== "object") {
+    return;
+  }
+  const obj = node;
+  const ref = obj.$ref;
+  if (typeof ref === "string" && ref.startsWith(DEFS_PREFIX)) {
+    obj.$ref = COMPONENTS_SCHEMAS_PREFIX + ref.slice(DEFS_PREFIX.length);
+  } else if (ref === "#" && rootRef !== void 0) {
+    obj.$ref = rootRef;
+  }
+  for (const value of Object.values(obj)) {
+    rewriteRefs(value, rootRef);
+  }
+}, "rewriteRefs");
+var refsIn = /* @__PURE__ */ __name(function* (node) {
+  if (Array.isArray(node)) {
+    for (const item of node) {
+      yield* refsIn(item);
+    }
+    return;
+  }
+  if (node === null || typeof node !== "object") {
+    return;
+  }
+  const obj = node;
+  if (typeof obj.$ref === "string") {
+    yield obj.$ref;
+  }
+  for (const value of Object.values(obj)) {
+    yield* refsIn(value);
+  }
+}, "refsIn");
+var rootDefId = /* @__PURE__ */ __name((raw) => {
+  const ref = raw.$ref;
+  if (typeof ref !== "string" || !ref.startsWith(DEFS_PREFIX)) {
+    return void 0;
+  }
+  return ref.slice(DEFS_PREFIX.length);
+}, "rootDefId");
+var isReferenced = /* @__PURE__ */ __name((defs, id) => {
+  const ownRef = `${DEFS_PREFIX}${id}`;
+  for (const ref of refsIn(defs)) {
+    if (ref === "#" || ref === ownRef) {
+      return true;
+    }
+  }
+  return false;
+}, "isReferenced");
+var referencesRoot = /* @__PURE__ */ __name((raw) => {
+  for (const ref of refsIn(raw)) {
+    if (ref === "#") {
+      return true;
+    }
+  }
+  return false;
+}, "referencesRoot");
+var stripEnvelope = /* @__PURE__ */ __name((raw) => {
+  const root = {
+    ...raw
+  };
+  delete root.$schema;
+  delete root.$defs;
+  return root;
+}, "stripEnvelope");
+var resolveRoot = /* @__PURE__ */ __name((raw, refs, options) => {
+  const liftedId = rootDefId(raw);
+  if (liftedId !== void 0) {
+    const body = refs.get(liftedId);
+    if (body !== void 0 && !isReferenced(raw.$defs, liftedId)) {
+      refs.delete(liftedId);
+      return {
+        schema: body,
+        rootRef: void 0
+      };
+    }
+    return {
+      schema: stripEnvelope(raw),
+      rootRef: `${COMPONENTS_SCHEMAS_PREFIX}${liftedId}`
+    };
+  }
+  const root = stripEnvelope(raw);
+  if (!referencesRoot(raw)) {
+    return {
+      schema: root,
+      rootRef: void 0
+    };
+  }
+  const rootId = options?.rootId;
+  if (rootId === void 0) {
+    if (options?.strict ?? true) {
+      throw new ZodNestError('A schema referenced from inside its own emission has no id, so the reference cannot be resolved. Add `.meta({ id: "\u2026" })` to the root schema, or set strict: false to leave the reference unresolved.');
+    }
+    return {
+      schema: root,
+      rootRef: void 0
+    };
+  }
+  refs.set(rootId, root);
+  const rootRef = `${COMPONENTS_SCHEMAS_PREFIX}${rootId}`;
+  return {
+    schema: {
+      $ref: rootRef
+    },
+    rootRef
+  };
+}, "resolveRoot");
+var postProcess = /* @__PURE__ */ __name((raw, options) => {
+  const refs = /* @__PURE__ */ new Map();
+  const rawDefs = raw.$defs;
+  if (rawDefs !== void 0) {
+    for (const [id, body] of Object.entries(rawDefs)) {
+      refs.set(id, body);
+    }
+  }
+  const { schema, rootRef } = resolveRoot(raw, refs, options);
+  rewriteRefs(schema, rootRef);
+  for (const body of refs.values()) {
+    rewriteRefs(body, rootRef);
+  }
+  return {
+    schema,
+    refs
+  };
+}, "postProcess");
+
+// src/schema/engine.ts
+var STRICT_REQUIRES_OVERRIDE = /* @__PURE__ */ new Set([
+  "bigint",
+  "date",
+  "symbol",
+  "undefined",
+  "void",
+  "map",
+  "set",
+  "transform",
+  "nan",
+  "custom"
+]);
+var ANNOTATION_ONLY_KEYS = /* @__PURE__ */ new Set([
+  "title",
+  "description",
+  "deprecated",
+  "examples",
+  "default",
+  "readOnly",
+  "writeOnly",
+  "$id",
+  "$schema",
+  "$comment",
+  "id"
+]);
+var isStrictlyUnrepresentable = /* @__PURE__ */ __name((jsonSchema, zodSchema) => {
+  if (!STRICT_REQUIRES_OVERRIDE.has(zodSchema._zod.def.type)) {
+    return false;
+  }
+  return Object.keys(jsonSchema).every((key) => ANNOTATION_ONLY_KEYS.has(key));
+}, "isStrictlyUnrepresentable");
+var markPipeCoverage = /* @__PURE__ */ __name((schema, io, covered) => {
+  const def = schema._zod.def;
+  if (def.type !== "pipe" || def.in === void 0 || def.out === void 0) {
+    return;
+  }
+  const target = io === "output" ? def.out : def.in._zod.traits.has("$ZodTransform") ? def.out : def.in;
+  if (covered.has(target)) {
+    return;
+  }
+  covered.add(target);
+  markPipeCoverage(target, io, covered);
+}, "markPipeCoverage");
+var buildToJsonSchemaOptions = /* @__PURE__ */ __name((params) => {
+  const strict = params.strict ?? true;
+  const compositionOverride = createCompositionOverride({
+    buildRef: params.uri ?? DEFAULT_BUILD_REF,
+    registry: params.registry
+  });
+  const customOverride = createCustomOverride(params.io);
+  const merged = combine(primitiveOverride, compositionOverride, customOverride, params.override);
+  const unrepresentableHits = [];
+  const coveredByPipe = /* @__PURE__ */ new WeakSet();
+  const wrapped = /* @__PURE__ */ __name((ctx) => {
+    merged(ctx);
+    if (ctx.zodSchema._zod.def.type === "pipe") {
+      const record = peekRegistration(ctx.zodSchema);
+      if (record !== void 0 && record[params.io] !== void 0) {
+        markPipeCoverage(ctx.zodSchema, params.io, coveredByPipe);
+      }
+    }
+    if (!strict || !isStrictlyUnrepresentable(ctx.jsonSchema, ctx.zodSchema)) {
+      return;
+    }
+    unrepresentableHits.push({
+      path: [
+        ...ctx.path
+      ],
+      zodType: ctx.zodSchema._zod.def.type,
+      zodSchema: ctx.zodSchema
+    });
+  }, "wrapped");
+  const options = {
+    target: "draft-2020-12",
+    io: params.io,
+    unrepresentable: "any",
+    metadata: params.registry.zodRegistry,
+    override: wrapped,
+    cycles: "ref",
+    reused: params.reused
+  };
+  if (params.uri !== void 0) {
+    options.uri = params.uri;
+  }
+  return {
+    options,
+    consumeUnrepresentable: /* @__PURE__ */ __name(() => {
+      const firstHit = unrepresentableHits.find((hit) => !coveredByPipe.has(hit.zodSchema));
+      if (firstHit !== void 0) {
+        throw new ZodNestUnrepresentableError(firstHit.path, firstHit.zodType);
+      }
+    }, "consumeUnrepresentable")
+  };
+}, "buildToJsonSchemaOptions");
+var resolveRootId = /* @__PURE__ */ __name((schema, registry) => {
+  const id = registry.zodRegistry.get(schema)?.id;
+  return typeof id === "string" && id !== "" ? id : void 0;
+}, "resolveRootId");
+var toOpenApi = /* @__PURE__ */ __name((schema, opts) => {
+  const built = buildToJsonSchemaOptions({
+    registry: opts.registry,
+    io: opts.io,
+    override: opts.override,
+    strict: opts.strict,
+    reused: "inline"
+  });
+  const raw = z.toJSONSchema(schema, built.options);
+  built.consumeUnrepresentable();
+  const result = postProcess(raw, {
+    rootId: resolveRootId(schema, opts.registry),
+    strict: opts.strict
+  });
+  for (const [id] of opts.registry.getCollisions()) {
+    if (!result.refs.has(id)) {
+      continue;
+    }
+    result.refs.set(id, {
+      description: `ERROR: duplicate zod-nest id <${id}>`,
+      [ZOD_NEST_ERROR_EXTENSION]: ZOD_NEST_ERROR_DUPLICATE_ID
+    });
+  }
+  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 ?? {})) {
+    if (isFileSchema(schema)) {
+      fileKeys.push(key);
+      continue;
+    }
+    textKeys.push(key);
+  }
+  return {
+    fileKeys,
+    textKeys
+  };
+}, "partitionKeys");
+var resolveBody = /* @__PURE__ */ __name((schema, options, registry) => {
+  if (options?.flatten === true) {
+    return flattenObjectIntersection(schema, registry, "@ZodMultipart");
+  }
+  const resolved = resolveSchemaRef(schema, {
+    ...options?.id !== void 0 ? {
+      id: options.id
+    } : {},
+    registry
+  });
+  return resolved.kind === "ref" ? resolved.ref : resolved.schema;
+}, "resolveBody");
+var createZodMultipart = /* @__PURE__ */ __name((defaultFilesIn) => {
+  return (body, options) => {
+    const registry = options?.registry ?? defaultRegistry;
+    const shape = toShape(body);
+    const metadata = {
+      shape,
+      ...partitionKeys(shape),
+      filesIn: options?.filesIn ?? defaultFilesIn
+    };
+    const schema = resolveBody(toSchema(body), options, registry);
+    return (target, propertyKey, descriptor) => {
+      const handler = descriptor.value;
+      if (typeof handler !== "function") {
+        throw new TypeError("[zod-nest] @ZodMultipart can only be applied to methods.");
+      }
+      Reflect.defineMetadata(ZOD_MULTIPART_METADATA_KEY, metadata, handler);
+      const swaggerDescriptor = descriptor;
+      ApiConsumes(MULTIPART_CONTENT_TYPE)(target, propertyKey, swaggerDescriptor);
+      ApiBody({
+        schema,
+        ...options?.description !== void 0 ? {
+          description: options.description
+        } : {},
+        required: options?.required ?? true
+      })(target, propertyKey, swaggerDescriptor);
+    };
+  };
+}, "createZodMultipart");
+var ZodValidationException = class extends BadRequestException {
+  static {
+    __name(this, "ZodValidationException");
+  }
+  zodError;
+  argMetadata;
+  constructor(zodError, argMetadata) {
+    super({
+      statusCode: HttpStatus.BAD_REQUEST,
+      message: "Validation failed",
+      errors: z.treeifyError(zodError)
+    }, {
+      cause: zodError
+    });
+    this.zodError = zodError;
+    this.argMetadata = argMetadata;
+  }
+};
+
+// src/multipart/param-decorators.ts
+var readMetadata = /* @__PURE__ */ __name((ctx, decorator) => {
+  const metadata = Reflect.getMetadata(ZOD_MULTIPART_METADATA_KEY, ctx.getHandler());
+  if (!isMultipartMetadata(metadata)) {
+    throw new Error(`[zod-nest] ${decorator} requires @ZodMultipart on the same handler \u2014 it reads the declared shape from there.`);
+  }
+  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 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(shape).join(", ")}.`);
+  }
+  return schema;
+}, "schemaFor");
+var pick = /* @__PURE__ */ __name((shape, keys) => {
+  const wanted = new Set(keys);
+  const picked = {};
+  for (const [key, schema] of Object.entries(shape)) {
+    if (wanted.has(key)) {
+      picked[key] = schema;
+    }
+  }
+  return z.object(picked);
+}, "pick");
+var validate = /* @__PURE__ */ __name(async (schema, value, argType) => {
+  const result = await schema.safeParseAsync(value);
+  if (result.success) {
+    return result.data;
+  }
+  throw new ZodValidationException(result.error, {
+    type: argType,
+    metatype: void 0,
+    data: void 0
+  });
+}, "validate");
+var assertFilesOnRequest = /* @__PURE__ */ __name((metadata, decorator) => {
+  if (metadata.filesIn === MultipartFilesIn.Request) {
+    return;
+  }
+  throw new Error(`[zod-nest] ${decorator} is unavailable under filesIn: 'body' \u2014 the parser puts files in the request body, so read them with @ZodMultipartBody().`);
+}, "assertFilesOnRequest");
+var resolveUploadedFile = /* @__PURE__ */ __name(async (name, ctx) => {
+  const metadata = readMetadata(ctx, "@ZodUploadedFile");
+  assertFilesOnRequest(metadata, "@ZodUploadedFile");
+  const request = ctx.switchToHttp().getRequest();
+  return validate(schemaFor(metadata, name, "@ZodUploadedFile"), request.file, "custom");
+}, "resolveUploadedFile");
+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(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(shape) : metadata.textKeys;
+  return validate(pick(shape, keys), request.body, "body");
+}, "resolveMultipartBody");
+var ZodUploadedFile = createParamDecorator(resolveUploadedFile);
+var ZodUploadedFiles = createParamDecorator(resolveUploadedFiles);
+var ZodMultipartBody = createParamDecorator(resolveMultipartBody);
+
+// src/express/index.ts
+var hasCommonFields = /* @__PURE__ */ __name((value) => value !== null && typeof value === "object" && "mimetype" in value && "originalname" in value && "size" in value, "hasCommonFields");
+var isMulterMemoryFile = /* @__PURE__ */ __name((value) => hasCommonFields(value) && Buffer.isBuffer(value.buffer), "isMulterMemoryFile");
+var isMulterDiskFile = /* @__PURE__ */ __name((value) => hasCommonFields(value) && typeof value.path === "string", "isMulterDiskFile");
+var memoryAccessors = {
+  mimeType: /* @__PURE__ */ __name((file) => file.mimetype, "mimeType"),
+  fileName: /* @__PURE__ */ __name((file) => file.originalname, "fileName"),
+  size: /* @__PURE__ */ __name((file) => file.size, "size")
+};
+var diskAccessors = {
+  mimeType: /* @__PURE__ */ __name((file) => file.mimetype, "mimeType"),
+  fileName: /* @__PURE__ */ __name((file) => file.originalname, "fileName"),
+  size: /* @__PURE__ */ __name((file) => file.size, "size")
+};
+var multerMemoryFile = /* @__PURE__ */ __name((options) => buildFileSchema({
+  predicate: isMulterMemoryFile,
+  accessors: memoryAccessors,
+  options,
+  ...options?.maxSize !== void 0 ? {
+    maxSize: options.maxSize
+  } : {}
+}), "multerMemoryFile");
+var multerDiskFile = /* @__PURE__ */ __name((options) => buildFileSchema({
+  predicate: isMulterDiskFile,
+  accessors: diskAccessors,
+  options,
+  ...options?.maxSize !== void 0 ? {
+    maxSize: options.maxSize
+  } : {}
+}), "multerDiskFile");
+var MulterMemoryFileSchema = multerMemoryFile();
+var MulterDiskFileSchema = multerDiskFile();
+var ZodMultipart = createZodMultipart(MultipartFilesIn.Request);
+
+export { MULTIPART_CONTENT_TYPE, MulterDiskFileSchema, MulterMemoryFileSchema, ZodMultipart, ZodMultipartBody, ZodUploadedFile, ZodUploadedFiles, multerDiskFile, multerMemoryFile };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map