zod-nest 2.1.2 → 2.1.4

package/dist/index.mjs

@@ -413,10 +413,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;
   }
@@ -427,32 +427,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");
@@ -539,6 +627,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,
@@ -549,7 +641,10 @@ var toOpenApi = /* @__PURE__ */ __name((schema, opts) => {
   });
   const raw = 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;