zod-nest 2.1.2 → 2.1.4

package/README.md

@@ -531,11 +531,14 @@ See [`docs/recipes/custom-openapi-overrides.md`](docs/recipes/custom-openapi-ove
 | ------------------------- | ------ | ---------------- | -------------- | ----------------- | ------ | ------------------ |
 | `floor`                   | 4.4.0  | 11.0.1           | 11.0.1         | 11.0.0            | 7.6.0  | 0.2.0              |
 | `zod-latest`              | latest | 11.0.1           | 11.0.1         | 11.0.0            | 7.6.0  | 0.2.0              |
+| `zod-4.5`                 | 4.5.4  | 11.0.1           | 11.0.1         | 11.0.0            | 7.6.0  | 0.2.0              |
 | `nest-latest`             | 4.4.0  | latest           | latest         | latest            | 7.6.0  | 0.2.0              |
 | `rxjs-latest`             | 4.4.0  | 11.0.1           | 11.0.1         | 11.0.0            | latest | 0.2.0              |
 | `reflect-metadata-latest` | 4.4.0  | 11.0.1           | 11.0.1         | 11.0.0            | 7.6.0  | latest             |
 | `all-latest`              | latest | latest           | latest         | latest            | latest | latest             |
 
+One emission difference is visible across the supported `zod` range: from 4.5, a union of primitives — including `.nullable()` — emits `{ "type": ["string", "null"] }` where 4.4 emitted `{ "anyOf": [{ "type": "string" }, { "type": "null" }] }`. Both are valid OpenAPI 3.1 and validate identically; only the spelling changes. Everything else — `$ref` layout, composition `allOf`, input/output siblings, `paths` — is byte-identical across 4.4 and 4.5.
+
 Cell definitions live in [`.github/compat-matrix.json`](.github/compat-matrix.json). The CI workflow ([`.github/workflows/compat-matrix.yml`](.github/workflows/compat-matrix.yml)) runs on every push to `main` and weekly on Monday — when a cell fails, the workflow opens (or comments on) a GitHub issue labelled `compat-matrix-failure` so the regression is tracked outside the Actions UI. Editing the JSON is the formal way to extend or shrink supported ranges. Node is not matrixed — the `>=22` floor is enforced by `engines`.
 
 ## Migration from `nestjs-zod`

package/dist/index.js

@@ -419,10 +419,10 @@ var combine = /* @__PURE__ */ __name((...overrides) => {
 }, "combine");
 
 // src/schema/post-process.ts
-var rewriteRefs = /* @__PURE__ */ __name((node, selfRef) => {
+var rewriteRefs = /* @__PURE__ */ __name((node, rootRef) => {
   if (Array.isArray(node)) {
     for (const item of node) {
-      rewriteRefs(item, selfRef);
+      rewriteRefs(item, rootRef);
     }
     return;
   }
@@ -433,32 +433,120 @@ var rewriteRefs = /* @__PURE__ */ __name((node, selfRef) => {
   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 === "#" && selfRef !== void 0) {
-    obj.$ref = selfRef;
+  } else if (ref === "#" && rootRef !== void 0) {
+    obj.$ref = rootRef;
   }
   for (const value of Object.values(obj)) {
-    rewriteRefs(value, selfRef);
+    rewriteRefs(value, rootRef);
   }
 }, "rewriteRefs");
-var postProcess = /* @__PURE__ */ __name((raw) => {
-  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);
+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;
-  rewriteRefs(root, void 0);
-  for (const [id, body] of refs) {
-    rewriteRefs(body, `${COMPONENTS_SCHEMAS_PREFIX}${id}`);
+  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: root,
+    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");
@@ -545,6 +633,10 @@ var buildToJsonSchemaOptions = /* @__PURE__ */ __name((params) => {
     }, "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,
@@ -555,7 +647,10 @@ var toOpenApi = /* @__PURE__ */ __name((schema, opts) => {
   });
   const raw = zod.z.toJSONSchema(schema, built.options);
   built.consumeUnrepresentable();
-  const result = postProcess(raw);
+  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;