zod-nest 3.2.0 → 3.2.1

package/dist/chunk-BAG3BDRM.mjs

@@ -0,0 +1,847 @@
+import { singleton, __name, createCustomOverride, peekRegistration } from './chunk-ZZW54ETO.mjs';
+import { z } from 'zod';
+import { BadRequestException, HttpStatus } from '@nestjs/common';
+
+// 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 = singleton("default-registry", 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 = singleton("lineage-map", () => /* @__PURE__ */ new WeakMap());
+var propsMap = singleton("props-map", () => /* @__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/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/symbols.ts
+var ZOD_DTO_SYMBOL = /* @__PURE__ */ Symbol.for("zod-nest.dto");
+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 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/schema/anon-id.ts
+var ANON_RESPONSE_PREFIX = "_AnonResponseSchema_";
+var ANON_BODY_PREFIX = "_AnonBodySchema_";
+var anonIdCache = singleton("anon-id-cache", () => /* @__PURE__ */ new WeakMap());
+var counterRef = singleton("anon-id-counter", () => ({
+  value: 0
+}));
+var resolveAnonId = /* @__PURE__ */ __name((schema, prefix) => {
+  const cached = anonIdCache.get(schema);
+  if (cached !== void 0) {
+    return cached;
+  }
+  counterRef.value += 1;
+  const id = `${prefix}${counterRef.value}`;
+  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");
+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");
+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");
+
+export { ANON_RESPONSE_PREFIX, COMPONENTS_SCHEMAS_PREFIX, ZOD_DTO_SYMBOL, ZOD_NEST_DTO_EXTENSION, ZOD_NEST_ERROR_DUPLICATE_ID, ZOD_NEST_ERROR_EXTENSION, ZodNestError, ZodNestUnrepresentableError, ZodValidationException, buildToJsonSchemaOptions, createRegistry, defaultRegistry, expandObjectSchema, extend, flattenObjectIntersection, getLineage, isZodDto, isZodObject, isZodSchema, paramSchemaBody, registerSchema, resolveAnonId, resolveSchemaRef, toOpenApi };
+//# sourceMappingURL=chunk-BAG3BDRM.mjs.map
+//# sourceMappingURL=chunk-BAG3BDRM.mjs.map