zod-nest 1.1.0 → 1.2.0

package/dist/index.d.mts

@@ -38,6 +38,9 @@ interface ZodNestRegistry {
      * underlying Zod registry is `z.globalRegistry`, which may hold third-party
      * entries — bulk emission filters its output against this snapshot to keep
      * only zod-nest-known ids.
+     *
+     * Includes ids discovered transitively via `.meta({ id })` on descendants
+     * of explicitly-registered schemas.
      */
     ids(): readonly string[];
 }

package/dist/index.d.ts

@@ -38,6 +38,9 @@ interface ZodNestRegistry {
      * underlying Zod registry is `z.globalRegistry`, which may hold third-party
      * entries — bulk emission filters its output against this snapshot to keep
      * only zod-nest-known ids.
+     *
+     * Includes ids discovered transitively via `.meta({ id })` on descendants
+     * of explicitly-registered schemas.
      */
     ids(): readonly string[];
 }

package/dist/index.js

@@ -120,6 +120,7 @@ var overrideJSONSchema = /* @__PURE__ */ __name((schema, arg) => {
     output: arg
   });
 }, "overrideJSONSchema");
+var peekRegistration = /* @__PURE__ */ __name((schema) => customOverrideMap.get(schema), "peekRegistration");
 var createCustomOverride = /* @__PURE__ */ __name((io) => {
   return ({ zodSchema, jsonSchema }) => {
     const record = customOverrideMap.get(zodSchema);
@@ -259,6 +260,18 @@ var isStrictlyUnrepresentable = /* @__PURE__ */ __name((jsonSchema, zodSchema) =
   }
   return Object.keys(jsonSchema).length === 0;
 }, "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({
@@ -268,8 +281,15 @@ var buildToJsonSchemaOptions = /* @__PURE__ */ __name((params) => {
   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;
     }
@@ -277,7 +297,8 @@ var buildToJsonSchemaOptions = /* @__PURE__ */ __name((params) => {
       path: [
         ...ctx.path
       ],
-      zodType: ctx.zodSchema._zod.def.type
+      zodType: ctx.zodSchema._zod.def.type,
+      zodSchema: ctx.zodSchema
     });
   }, "wrapped");
   const options = {
@@ -295,7 +316,7 @@ var buildToJsonSchemaOptions = /* @__PURE__ */ __name((params) => {
   return {
     options,
     consumeUnrepresentable: /* @__PURE__ */ __name(() => {
-      const firstHit = unrepresentableHits[0];
+      const firstHit = unrepresentableHits.find((hit) => !coveredByPipe.has(hit.zodSchema));
       if (firstHit !== void 0) {
         throw new ZodNestUnrepresentableError(firstHit.path, firstHit.zodType);
       }
@@ -324,20 +345,146 @@ var toOpenApi = /* @__PURE__ */ __name((schema, opts) => {
   }
   return result;
 }, "toOpenApi");
+var INNER_TYPE_WRAPPERS = /* @__PURE__ */ new Set([
+  "optional",
+  "nullable",
+  "default",
+  "prefault",
+  "catch",
+  "nonoptional",
+  "success",
+  "readonly",
+  "promise"
+]);
+var readId = /* @__PURE__ */ __name((schema) => {
+  const meta = zod.z.globalRegistry.get(schema);
+  if (meta === void 0) {
+    return void 0;
+  }
+  const id = meta.id;
+  return typeof id === "string" ? id : void 0;
+}, "readId");
+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 [
+      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 (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 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");
   return {
     zodRegistry: zod.z.globalRegistry,
     register: /* @__PURE__ */ __name((schema, id) => {
       zod.z.globalRegistry.add(schema, {
         id
       });
-      let set = seen.get(id);
-      if (set === void 0) {
-        set = /* @__PURE__ */ new Set();
-        seen.set(id, set);
+      if (!recordOnce(schema, id)) {
+        return;
+      }
+      for (const [child, childId] of discoverDependents(schema)) {
+        recordOnce(child, childId);
       }
-      set.add(schema);
     }, "register"),
     hasCollision: /* @__PURE__ */ __name((id) => {
       const set = seen.get(id);
@@ -1279,6 +1426,39 @@ var hintFor = /* @__PURE__ */ __name((ref, collected) => {
   return "no DTO with this id was registered \u2014 check for a meta.id typo or a DTO used without createZodDto";
 }, "hintFor");
 
+// src/document/expose-closure.ts
+var extendExposureViaRefs = /* @__PURE__ */ __name((collected, inputSchemas, outputSchemas) => ({
+  ...collected,
+  inputExposedIds: closeOverRefs(collected.inputExposedIds, inputSchemas),
+  outputExposedIds: closeOverRefs(collected.outputExposedIds, outputSchemas)
+}), "extendExposureViaRefs");
+var closeOverRefs = /* @__PURE__ */ __name((seed, bodies) => {
+  const out = new Set(seed);
+  const queue = [
+    ...seed
+  ];
+  while (queue.length > 0) {
+    const id = queue.shift();
+    const body = bodies.get(id);
+    if (body === void 0) {
+      continue;
+    }
+    walkRefs(body, (ref) => {
+      if (!ref.startsWith(COMPONENTS_SCHEMAS_PREFIX)) {
+        return void 0;
+      }
+      const target = ref.slice(COMPONENTS_SCHEMAS_PREFIX.length);
+      if (out.has(target)) {
+        return void 0;
+      }
+      out.add(target);
+      queue.push(target);
+      return void 0;
+    });
+  }
+  return out;
+}, "closeOverRefs");
+
 // src/document/constants.ts
 var OUTPUT_SUFFIX = "Output";
 
@@ -1470,11 +1650,12 @@ var applyZodNest = /* @__PURE__ */ __name((doc, opts) => {
     override: opts.override,
     strict: opts.strict
   });
+  const extended = extendExposureViaRefs(collected, inputSchemas, outputSchemas);
   const { divergentOutputIds, renames } = mergeSchemas({
     doc,
     inputSchemas,
     outputSchemas,
-    collected,
+    collected: extended,
     collisions: registry.getCollisions()
   });
   rewriteRefs2({
@@ -1485,7 +1666,7 @@ var applyZodNest = /* @__PURE__ */ __name((doc, opts) => {
   stripMarkers(doc);
   assertNoDanglingRefs({
     doc,
-    collected
+    collected: extended
   });
   return doc;
 }, "applyZodNest");