zod-nest 3.2.0 → 3.2.2

package/dist/index.mjs

@@ -1,5 +1,9 @@
+import { isZodDto, ZodNestError, ZodValidationException, defaultRegistry, ZOD_DTO_SYMBOL, ZOD_NEST_DTO_EXTENSION, flattenObjectIntersection, resolveSchemaRef, isZodObject, registerSchema, expandObjectSchema, paramSchemaBody, COMPONENTS_SCHEMAS_PREFIX, isZodSchema, buildToJsonSchemaOptions, resolveAnonId, ANON_RESPONSE_PREFIX, ZOD_NEST_ERROR_DUPLICATE_ID, ZOD_NEST_ERROR_EXTENSION } from './chunk-LHNXO52A.mjs';
+export { COMPONENTS_SCHEMAS_PREFIX, ZOD_DTO_SYMBOL, ZOD_NEST_DTO_EXTENSION, ZOD_NEST_ERROR_DUPLICATE_ID, ZOD_NEST_ERROR_EXTENSION, ZodNestError, ZodNestUnrepresentableError, ZodValidationException, createRegistry, defaultRegistry, extend, getLineage, isZodDto, isZodSchema, registerSchema, toOpenApi } from './chunk-LHNXO52A.mjs';
+import { singleton, __name } from './chunk-ZZW54ETO.mjs';
+export { overrideJSONSchema } from './chunk-ZZW54ETO.mjs';
+import { InternalServerErrorException, HttpStatus, Injectable, Optional, Inject, Logger, RequestMethod, applyDecorators } from '@nestjs/common';
 import { z } from 'zod';
-import { InternalServerErrorException, HttpStatus, BadRequestException, Injectable, Optional, Inject, Logger, RequestMethod, applyDecorators } from '@nestjs/common';
 import { HTTP_CODE_METADATA, METHOD_METADATA, HEADERS_METADATA } from '@nestjs/common/constants.js';
 import { ApiBody, ApiQuery, ApiResponse, ApiExtraModels, getSchemaPath } from '@nestjs/swagger';
 import { Reflector, APP_PIPE, APP_INTERCEPTOR } from '@nestjs/core';
@@ -7,690 +11,6 @@ import { from } from 'rxjs';
 import { mergeMap } from 'rxjs/operators';
 import stringify from 'fast-json-stable-stringify';
 
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
-// 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 ZOD_NEST_DTO_EXTENSION = "x-zod-nest-dto";
-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/registry.ts
-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 OPTIONAL_WRAPPER_TYPES = /* @__PURE__ */ new Set([
-  "optional",
-  "default"
-]);
-var isOptionalProp = /* @__PURE__ */ __name((propSchema) => OPTIONAL_WRAPPER_TYPES.has(propSchema._zod.def.type), "isOptionalProp");
-var computeShapeKeys = /* @__PURE__ */ __name((schema) => {
-  const { shape } = schema;
-  const properties = Object.keys(shape);
-  const required = properties.filter((key) => {
-    const propSchema = shape[key];
-    return propSchema !== void 0 && !isOptionalProp(propSchema);
-  });
-  return {
-    properties,
-    required
-  };
-}, "computeShapeKeys");
-var computeOverriddenKeys = /* @__PURE__ */ __name((parent, child) => {
-  const overriddenKeys = /* @__PURE__ */ new Set();
-  for (const key of Object.keys(child.shape)) {
-    const parentProp = parent.shape[key];
-    if (parentProp !== void 0 && parentProp !== child.shape[key]) {
-      overriddenKeys.add(key);
-    }
-  }
-  return overriddenKeys;
-}, "computeOverriddenKeys");
-var extend = /* @__PURE__ */ __name((parent, build) => {
-  const result = build(parent);
-  lineageMap.set(result, {
-    op: "extend",
-    parent,
-    overriddenKeys: computeOverriddenKeys(parent, result)
-  });
-  if (!propsMap.has(parent)) {
-    propsMap.set(parent, computeShapeKeys(parent));
-  }
-  registerSchema(parent);
-  registerSchema(result);
-  return result;
-}, "extend");
-var getLineage = /* @__PURE__ */ __name((schema) => lineageMap.get(schema), "getLineage");
-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/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/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/dto/marker.ts
 var makeZodDtoMarker = /* @__PURE__ */ __name((dtoId, io) => ({
   type: /* @__PURE__ */ __name(() => Object, "type"),
@@ -706,11 +26,8 @@ var isZodDtoMarker = /* @__PURE__ */ __name((value) => {
   return value.__zodNestDto === true;
 }, "isZodDtoMarker");
 
-// src/dto/symbols.ts
-var ZOD_DTO_SYMBOL = /* @__PURE__ */ Symbol.for("zod-nest.dto");
-
 // src/dto/output-dto.ts
-var outputCache = /* @__PURE__ */ new WeakMap();
+var outputCache = singleton("output-dto-cache", () => /* @__PURE__ */ new WeakMap());
 var buildSiblingClass = /* @__PURE__ */ __name((parent, schema) => {
   const SiblingClass = class {
     static {
@@ -754,16 +71,18 @@ var resolveOutput = /* @__PURE__ */ __name((parent, schema) => {
 }, "resolveOutput");
 
 // src/dto/create-zod-dto.ts
-var anonCounter = 0;
-var warnedOnAnonymous = false;
+var anonState = singleton("anon-dto-state", () => ({
+  counter: 0,
+  warned: false
+}));
 var resolveFallbackId = /* @__PURE__ */ __name((className) => {
   if (className !== "" && className.length > 1) {
     return className;
   }
-  anonCounter += 1;
-  const fallback = `_AnonZodDto_${anonCounter}`;
-  if (!warnedOnAnonymous) {
-    warnedOnAnonymous = true;
+  anonState.counter += 1;
+  const fallback = `_AnonZodDto_${anonState.counter}`;
+  if (!anonState.warned) {
+    anonState.warned = true;
     console.warn(`[zod-nest] Could not resolve a DTO id from class name (got "${className}"). Using "${fallback}". Set an explicit id via \`schema.meta({ id: 'Foo' })\` (preferred) or \`createZodDto(schema, { id: 'Foo' })\` \u2014 important under minification, where class names become single mangled characters.`);
   }
   return fallback;
@@ -817,8 +136,6 @@ var createZodDto = /* @__PURE__ */ __name((schema, options) => {
   };
   return ZodDtoBase;
 }, "createZodDto");
-var isZodDto = /* @__PURE__ */ __name((value) => typeof value === "function" && value[ZOD_DTO_SYMBOL] === true, "isZodDto");
-var isZodSchema = /* @__PURE__ */ __name((value) => value instanceof z.ZodType, "isZodSchema");
 var ZodSerializationException = class extends InternalServerErrorException {
   static {
     __name(this, "ZodSerializationException");
@@ -836,24 +153,6 @@ var ZodSerializationException = class extends InternalServerErrorException {
     this.executionContext = executionContext;
   }
 };
-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;
-  }
-};
 var DEFAULT_LOGGER_CONTEXT = "ZodValidation";
 var REDACTED = "[REDACTED]";
 var PREVIEW_RESERVE_BYTES = 100;
@@ -1250,24 +549,8 @@ var appendResponseVariant = /* @__PURE__ */ __name((handler, variant) => {
   ], handler);
 }, "appendResponseVariant");
 
-// src/schema/anon-id.ts
-var ANON_RESPONSE_PREFIX = "_AnonResponseSchema_";
-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/response/normalize-type.ts
-var responseDtoCache = /* @__PURE__ */ new WeakMap();
+var responseDtoCache = singleton("response-dto-cache", () => /* @__PURE__ */ new WeakMap());
 var schemaToOutputDto = /* @__PURE__ */ __name((schema) => {
   const cached = responseDtoCache.get(schema);
   if (cached !== void 0) {
@@ -1475,166 +758,6 @@ var ZodResponse = /* @__PURE__ */ __name((opts) => {
     });
   };
 }, "ZodResponse");
-
-// 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");
-var expandObjectSchema = /* @__PURE__ */ __name((schema, options) => {
-  if (!isZodObject(schema)) {
-    throw new ZodNestError(`${options.decoratorName} requires a \`z.object({...})\` schema (got \`${schema._zod.def.type}\`). Each property of the object becomes one OpenAPI parameter. For non-object body shapes (intersections, unions, primitives), use \`@ZodBody\` instead.`);
-  }
-  const registry = options.registry ?? defaultRegistry;
-  registerSchema(schema, registry, {
-    id: options.id
-  });
-  const result = [];
-  for (const [name, propSchema] of Object.entries(schema.shape)) {
-    const resolution = resolveSchemaRef(propSchema, {
-      registry
-    });
-    const required = options.forceRequired === true || !isOptionalProp(propSchema);
-    result.push({
-      name,
-      required,
-      resolution
-    });
-  }
-  return result;
-}, "expandObjectSchema");
-var paramSchemaBody = /* @__PURE__ */ __name((resolution) => resolution.kind === "ref" ? resolution.ref : resolution.schema, "paramSchemaBody");
-
-// 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");
-
-// src/decorators/zod-body.decorator.ts
 var ZodBody = /* @__PURE__ */ __name((schema, options) => {
   const apiBodySchema = resolveBodySchema(schema, options);
   return ApiBody({
@@ -2618,7 +1741,7 @@ var addRefTitles = /* @__PURE__ */ __name((node, titleById) => {
 }, "addRefTitles");
 
 // src/document/rewrite-refs.ts
-var rewriteRefs2 = /* @__PURE__ */ __name((params) => {
+var rewriteRefs = /* @__PURE__ */ __name((params) => {
   const { doc, renames, divergentOutputIds } = params;
   if (renames.size > 0) {
     walkRefs(doc, (ref) => {
@@ -2752,7 +1875,7 @@ var applyZodNest = /* @__PURE__ */ __name((doc, opts = {}) => {
     outputSchemas,
     queryParamStyle: opts.queryParamStyle
   });
-  rewriteRefs2({
+  rewriteRefs({
     doc,
     renames,
     divergentOutputIds
@@ -2773,6 +1896,6 @@ var applyZodNest = /* @__PURE__ */ __name((doc, opts = {}) => {
   return doc;
 }, "applyZodNest");
 
-export { COMPONENTS_SCHEMAS_PREFIX, DEFAULT_MAX_LOGGED_VALUE_BYTES, DEFAULT_REDACT_KEYS, DEFAULT_STREAM_CONTENT_TYPES, ZOD_DTO_SYMBOL, ZOD_NEST_DTO_EXTENSION, ZOD_NEST_ERROR_DUPLICATE_ID, ZOD_NEST_ERROR_EXTENSION, ZOD_NEST_OPTIONS, ZOD_RESPONSES_METADATA_KEY, ZodBody, ZodCookies, ZodHeaders, ZodNestDocumentError, ZodNestError, ZodNestModule, ZodNestUnrepresentableError, ZodQuery, ZodResponse, ZodSerializationException, ZodSerializerInterceptor, ZodValidationException, ZodValidationPipe, applyZodNest, createRegistry, createZodDto, defaultRegistry, defaultStatusFor, extend, getLineage, isZodDto, isZodDtoMarker, isZodSchema, makeZodDtoMarker, overrideJSONSchema, registerSchema, resolveEffectiveStatus, toOpenApi };
+export { DEFAULT_MAX_LOGGED_VALUE_BYTES, DEFAULT_REDACT_KEYS, DEFAULT_STREAM_CONTENT_TYPES, ZOD_NEST_OPTIONS, ZOD_RESPONSES_METADATA_KEY, ZodBody, ZodCookies, ZodHeaders, ZodNestDocumentError, ZodNestModule, ZodQuery, ZodResponse, ZodSerializationException, ZodSerializerInterceptor, ZodValidationPipe, applyZodNest, createZodDto, defaultStatusFor, isZodDtoMarker, makeZodDtoMarker, resolveEffectiveStatus };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map