zod-openapi 2.12.0 → 2.14.0

package/lib-esm/{index.js → index.mjs}

@@ -10,30 +10,27 @@ var isAnyZodType = (zodType) => Boolean(
   zodType?._def?.typeName
 );
 
-// src/openapi.ts
-var openApiVersions = [
-  "3.0.0",
-  "3.0.1",
-  "3.0.2",
-  "3.0.3",
-  "3.1.0"
-];
-var satisfiesVersion = (test, against) => openApiVersions.indexOf(test) >= openApiVersions.indexOf(against);
-var isReferenceObject = (schemaOrRef) => Boolean("$ref" in schemaOrRef && schemaOrRef.$ref);
-
 // src/create/schema/metadata.ts
-var enhanceWithMetadata = (schemaObject, metadata) => {
-  if (isReferenceObject(schemaObject)) {
+var enhanceWithMetadata = (schema, metadata) => {
+  if (schema.type === "ref") {
     if (Object.values(metadata).every((val) => val === void 0)) {
-      return schemaObject;
+      return schema;
     }
     return {
-      allOf: [schemaObject, metadata]
+      type: "schema",
+      schema: {
+        allOf: [schema.schema, metadata]
+      },
+      effects: schema.effects
     };
   }
   return {
-    ...schemaObject,
-    ...metadata
+    type: "schema",
+    schema: {
+      ...schema.schema,
+      ...metadata
+    },
+    effects: schema.effects
   };
 };
 
@@ -42,17 +39,25 @@ var createArraySchema = (zodArray, state) => {
   const zodType = zodArray._def.type;
   const minItems = zodArray._def.exactLength?.value ?? zodArray._def.minLength?.value;
   const maxItems = zodArray._def.exactLength?.value ?? zodArray._def.maxLength?.value;
+  const items = createSchemaObject(zodType, state, ["array items"]);
   return {
-    type: "array",
-    items: createSchemaObject(zodType, state, ["array items"]),
-    ...minItems !== void 0 && { minItems },
-    ...maxItems !== void 0 && { maxItems }
+    type: "schema",
+    schema: {
+      type: "array",
+      items: items.schema,
+      ...minItems !== void 0 && { minItems },
+      ...maxItems !== void 0 && { maxItems }
+    },
+    effects: items.effects
   };
 };
 
 // src/create/schema/parsers/boolean.ts
 var createBooleanSchema = (_zodBoolean) => ({
-  type: "boolean"
+  type: "schema",
+  schema: {
+    type: "boolean"
+  }
 });
 
 // src/create/schema/parsers/brand.ts
@@ -63,7 +68,10 @@ var createCatchSchema = (zodCatch, state) => createSchemaObject(zodCatch._def.in
 
 // src/create/schema/parsers/date.ts
 var createDateSchema = (_zodDate) => ({
-  type: "string"
+  type: "schema",
+  schema: {
+    type: "string"
+  }
 });
 
 // src/create/schema/parsers/default.ts
@@ -76,21 +84,186 @@ var createDefaultSchema = (zodDefault, state) => {
   });
 };
 
+// src/create/schema/parsers/transform.ts
+var createTransformSchema = (zodTransform, state) => {
+  if (zodTransform._def.openapi?.effectType === "output") {
+    return {
+      type: "schema",
+      schema: createManualOutputTransformSchema(zodTransform, state)
+    };
+  }
+  if (zodTransform._def.openapi?.effectType === "input" || zodTransform._def.openapi?.effectType === "same") {
+    return createSchemaObject(zodTransform._def.schema, state, [
+      "transform input"
+    ]);
+  }
+  if (state.type === "output") {
+    return {
+      type: "schema",
+      schema: createManualOutputTransformSchema(zodTransform, state)
+    };
+  }
+  const schema = createSchemaObject(zodTransform._def.schema, state, [
+    "transform input"
+  ]);
+  return {
+    ...schema,
+    effects: flattenEffects([
+      [
+        {
+          type: "schema",
+          creationType: "input",
+          zodType: zodTransform,
+          path: [...state.path]
+        }
+      ],
+      schema.effects
+    ])
+  };
+};
+var createManualOutputTransformSchema = (zodTransform, state) => {
+  if (!zodTransform._def.openapi?.type) {
+    const zodType = zodTransform.constructor.name;
+    const schemaName = `${zodType} - ${zodTransform._def.effect.type}`;
+    throw new Error(
+      `Failed to determine a type for ${schemaName} at ${state.path.join(
+        " > "
+      )}. Please change the 'effectType' to 'input', wrap it in a ZodPipeline or assign it a manual 'type'.`
+    );
+  }
+  return {
+    type: zodTransform._def.openapi.type
+  };
+};
+var getZodTypeName = (zodType) => {
+  if (isZodType(zodType, "ZodEffects")) {
+    return `${zodType._def.typeName} - ${zodType._def.effect.type}`;
+  }
+  return zodType._def.typeName;
+};
+var throwTransformError = (effect) => {
+  const typeName = getZodTypeName(effect.zodType);
+  const input = effect.creationType;
+  const opposite = input === "input" ? "output" : "input";
+  throw new Error(
+    `The ${typeName} at ${effect.path.join(
+      " > "
+    )} is used within a registered compoment schema${effect.component ? ` (${effect.component.ref})` : ""} and contains an ${input} transformation${effect.component ? ` (${getZodTypeName(
+      effect.component.zodType
+    )}) defined at ${effect.component.path.join(" > ")}` : ""} which is also used in an ${opposite} schema.
+
+This may cause the schema to render incorrectly and is most likely a mistake. You can resolve this by:
+
+1. Setting an \`effectType\` on one of the transformations to \`same\` (Not applicable for ZodDefault), \`input\` or \`output\` eg. \`.openapi({type: 'same'})\`
+2. Wrapping the transformation in a ZodPipeline
+3. Assigning a manual type to the transformation eg. \`.openapi({type: 'string'})\`
+4. Removing the transformation
+5. Deregister the component containing the transformation`
+  );
+};
+var resolveSingleEffect = (effect, state) => {
+  if (effect.type === "schema") {
+    return {
+      creationType: effect.creationType,
+      path: effect.path,
+      zodType: effect.zodType
+    };
+  }
+  if (effect.type === "component") {
+    if (state.visited.has(effect.zodType)) {
+      return;
+    }
+    const component = state.components.schemas.get(effect.zodType);
+    if (component?.type !== "complete") {
+      throw new Error("Something went wrong, component schema is not complete");
+    }
+    if (component.resolvedEffect) {
+      return {
+        creationType: component.resolvedEffect.creationType,
+        path: effect.path,
+        zodType: effect.zodType,
+        component: {
+          ref: component.ref,
+          zodType: component.resolvedEffect.zodType,
+          path: component.resolvedEffect.path
+        }
+      };
+    }
+    if (!component.effects) {
+      return void 0;
+    }
+    state.visited.add(effect.zodType);
+    const resolved = resolveEffect(component.effects, state);
+    state.visited.delete(effect.zodType);
+    if (!resolved) {
+      return void 0;
+    }
+    component.resolvedEffect = resolved;
+    return resolved;
+  }
+  return void 0;
+};
+var resolveEffect = (effects, state) => {
+  const { input, output } = effects.reduce(
+    (acc, effect) => {
+      const resolvedSchemaEffect = resolveSingleEffect(effect, state);
+      if (resolvedSchemaEffect?.creationType === "input") {
+        acc.input.push(resolvedSchemaEffect);
+      }
+      if (resolvedSchemaEffect?.creationType === "output") {
+        acc.output.push(resolvedSchemaEffect);
+      }
+      if (resolvedSchemaEffect && acc.input.length > 1 && acc.output.length > 1) {
+        throwTransformError(resolvedSchemaEffect);
+      }
+      return acc;
+    },
+    { input: [], output: [] }
+  );
+  if (input.length > 0) {
+    return input[0];
+  }
+  if (output.length > 0) {
+    return output[0];
+  }
+  return void 0;
+};
+var verifyEffects = (effects, state) => {
+  const resolved = resolveEffect(effects, state);
+  if (resolved?.creationType && resolved.creationType !== state.type) {
+    throwTransformError(resolved);
+  }
+};
+var flattenEffects = (effects) => {
+  const allEffects = effects.reduce((acc, effect) => {
+    if (effect) {
+      return acc.concat(effect);
+    }
+    return acc;
+  }, []);
+  return allEffects.length ? allEffects : void 0;
+};
+
 // src/create/schema/parsers/discriminatedUnion.ts
 var createDiscriminatedUnionSchema = (zodDiscriminatedUnion, state) => {
   const options = zodDiscriminatedUnion.options;
   const schemas = options.map(
     (option, index) => createSchemaObject(option, state, [`discriminated union option ${index}`])
   );
+  const schemaObjects = schemas.map((schema) => schema.schema);
   const discriminator = mapDiscriminator(
-    schemas,
+    schemaObjects,
     options,
     zodDiscriminatedUnion.discriminator,
     state
   );
   return {
-    oneOf: schemas,
-    ...discriminator && { discriminator }
+    type: "schema",
+    schema: {
+      oneOf: schemaObjects,
+      ...discriminator && { discriminator }
+    },
+    effects: flattenEffects(schemas.map((schema) => schema.effects))
   };
 };
 var mapDiscriminator = (schemas, zodObjects, discriminator, state) => {
@@ -129,19 +302,29 @@ var mapDiscriminator = (schemas, zodObjects, discriminator, state) => {
 
 // src/create/schema/parsers/enum.ts
 var createEnumSchema = (zodEnum) => ({
-  type: "string",
-  enum: zodEnum._def.values
+  type: "schema",
+  schema: {
+    type: "string",
+    enum: zodEnum._def.values
+  }
 });
 
 // src/create/schema/parsers/intersection.ts
-var createIntersectionSchema = (zodIntersection, state) => ({
-  allOf: [
-    createSchemaObject(zodIntersection._def.left, state, ["intersection left"]),
-    createSchemaObject(zodIntersection._def.right, state, [
-      "intersection right"
-    ])
-  ]
-});
+var createIntersectionSchema = (zodIntersection, state) => {
+  const left = createSchemaObject(zodIntersection._def.left, state, [
+    "intersection left"
+  ]);
+  const right = createSchemaObject(zodIntersection._def.right, state, [
+    "intersection right"
+  ]);
+  return {
+    type: "schema",
+    schema: {
+      allOf: [left.schema, right.schema]
+    },
+    effects: flattenEffects([left.effects, right.effects])
+  };
+};
 
 // src/create/schema/parsers/lazy.ts
 var createLazySchema = (zodLazy, state) => {
@@ -151,8 +334,11 @@ var createLazySchema = (zodLazy, state) => {
 
 // src/create/schema/parsers/literal.ts
 var createLiteralSchema = (zodLiteral) => ({
-  type: typeof zodLiteral.value,
-  enum: [zodLiteral._def.value]
+  type: "schema",
+  schema: {
+    type: typeof zodLiteral.value,
+    enum: [zodLiteral._def.value]
+  }
 });
 
 // src/create/schema/parsers/manual.ts
@@ -166,10 +352,23 @@ var createManualTypeSchema = (zodSchema, state) => {
     );
   }
   return {
-    type: zodSchema._def.openapi.type
+    type: "schema",
+    schema: {
+      type: zodSchema._def.openapi.type
+    }
   };
 };
 
+// src/openapi.ts
+var openApiVersions = [
+  "3.0.0",
+  "3.0.1",
+  "3.0.2",
+  "3.0.3",
+  "3.1.0"
+];
+var satisfiesVersion = (test, against) => openApiVersions.indexOf(test) >= openApiVersions.indexOf(against);
+
 // src/create/schema/parsers/nativeEnum.ts
 var createNativeEnumSchema = (zodEnum, state) => {
   const enumValues = getValidEnumValues(zodEnum._def.values);
@@ -177,25 +376,37 @@ var createNativeEnumSchema = (zodEnum, state) => {
   if (strings.length && numbers.length) {
     if (satisfiesVersion(state.components.openapi, "3.1.0"))
       return {
-        type: ["string", "number"],
-        enum: [...strings, ...numbers]
+        type: "schema",
+        schema: {
+          type: ["string", "number"],
+          enum: [...strings, ...numbers]
+        }
       };
     return {
-      oneOf: [
-        { type: "string", enum: strings },
-        { type: "number", enum: numbers }
-      ]
+      type: "schema",
+      schema: {
+        oneOf: [
+          { type: "string", enum: strings },
+          { type: "number", enum: numbers }
+        ]
+      }
     };
   }
   if (strings.length) {
     return {
-      type: "string",
-      enum: strings
+      type: "schema",
+      schema: {
+        type: "string",
+        enum: strings
+      }
     };
   }
   return {
-    type: "number",
-    enum: numbers
+    type: "schema",
+    schema: {
+      type: "number",
+      enum: numbers
+    }
   };
 };
 var getValidEnumValues = (enumValues) => {
@@ -211,7 +422,10 @@ var sortStringsAndNumbers = (values) => ({
 
 // src/create/schema/parsers/null.ts
 var createNullSchema = (_zodNull) => ({
-  type: "null"
+  type: "schema",
+  schema: {
+    type: "null"
+  }
 });
 
 // src/create/schema/parsers/nullable.ts
@@ -220,45 +434,69 @@ var createNullableSchema = (zodNullable, state) => {
     "nullable"
   ]);
   if (satisfiesVersion(state.components.openapi, "3.1.0")) {
-    if (isReferenceObject(schemaObject) || schemaObject.allOf) {
+    if (schemaObject.type === "ref" || schemaObject.schema.allOf) {
       return {
-        oneOf: mapNullOf([schemaObject], state.components.openapi)
+        type: "schema",
+        schema: {
+          oneOf: mapNullOf([schemaObject.schema], state.components.openapi)
+        },
+        effects: schemaObject.effects
       };
     }
-    if (schemaObject.oneOf) {
-      const { oneOf, ...schema3 } = schemaObject;
+    if (schemaObject.schema.oneOf) {
+      const { oneOf, ...schema3 } = schemaObject.schema;
       return {
-        oneOf: mapNullOf(oneOf, state.components.openapi),
-        ...schema3
+        type: "schema",
+        schema: {
+          oneOf: mapNullOf(oneOf, state.components.openapi),
+          ...schema3
+        },
+        effects: schemaObject.effects
       };
     }
-    if (schemaObject.anyOf) {
-      const { anyOf, ...schema3 } = schemaObject;
+    if (schemaObject.schema.anyOf) {
+      const { anyOf, ...schema3 } = schemaObject.schema;
       return {
-        anyOf: mapNullOf(anyOf, state.components.openapi),
-        ...schema3
+        type: "schema",
+        schema: {
+          anyOf: mapNullOf(anyOf, state.components.openapi),
+          ...schema3
+        },
+        effects: schemaObject.effects
       };
     }
-    const { type: type2, ...schema2 } = schemaObject;
+    const { type: type2, ...schema2 } = schemaObject.schema;
     return {
-      type: mapNullType(type2),
-      ...schema2
+      type: "schema",
+      schema: {
+        type: mapNullType(type2),
+        ...schema2
+      },
+      effects: schemaObject.effects
     };
   }
-  if (isReferenceObject(schemaObject)) {
+  if (schemaObject.type === "ref") {
     return {
-      allOf: [schemaObject],
-      nullable: true
+      type: "schema",
+      schema: {
+        allOf: [schemaObject.schema],
+        nullable: true
+      },
+      effects: schemaObject.effects
     };
   }
-  const { type, ...schema } = schemaObject;
+  const { type, ...schema } = schemaObject.schema;
   return {
-    ...type && { type },
-    nullable: true,
-    ...schema,
-    // https://github.com/OAI/OpenAPI-Specification/blob/main/proposals/2019-10-31-Clarify-Nullable.md#if-a-schema-specifies-nullable-true-and-enum-1-2-3-does-that-schema-allow-null-values-see-1900
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    ...schema.enum && { enum: [...schema.enum, null] }
+    type: "schema",
+    schema: {
+      ...type && { type },
+      nullable: true,
+      ...schema,
+      // https://github.com/OAI/OpenAPI-Specification/blob/main/proposals/2019-10-31-Clarify-Nullable.md#if-a-schema-specifies-nullable-true-and-enum-1-2-3-does-that-schema-allow-null-values-see-1900
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      ...schema.enum && { enum: [...schema.enum, null] }
+    },
+    effects: schemaObject.effects
   };
 };
 var mapNullType = (type) => {
@@ -283,10 +521,13 @@ var createNumberSchema = (zodNumber, state) => {
   const minimum = mapMinimum(zodNumberChecks, state.components.openapi);
   const maximum = mapMaximum(zodNumberChecks, state.components.openapi);
   return {
-    type: mapNumberType(zodNumberChecks),
-    ...minimum && minimum,
-    // Union types are not easy to tame
-    ...maximum && maximum
+    type: "schema",
+    schema: {
+      type: mapNumberType(zodNumberChecks),
+      ...minimum && minimum,
+      // Union types are not easy to tame
+      ...maximum && maximum
+    }
   };
 };
 var mapMaximum = (zodNumberCheck, openapi) => {
@@ -322,16 +563,29 @@ var getZodNumberChecks = (zodNumber) => zodNumber._def.checks.reduce((acc, check
 var mapNumberType = (zodNumberChecks) => zodNumberChecks.int ? "integer" : "number";
 
 // src/create/schema/parsers/optional.ts
-var createOptionalSchema = (zodOptional, state) => (
-  // Optional doesn't change OpenAPI schema
-  createSchemaObject(zodOptional.unwrap(), state, ["optional"])
-);
+var createOptionalSchema = (zodOptional, state) => createSchemaObject(zodOptional.unwrap(), state, ["optional"]);
 var isOptionalSchema = (zodSchema, state) => {
   if (isZodType(zodSchema, "ZodOptional") || isZodType(zodSchema, "ZodNever") || isZodType(zodSchema, "ZodUndefined")) {
-    return true;
+    return { optional: true };
   }
   if (isZodType(zodSchema, "ZodDefault")) {
-    return state.type === "input";
+    if (zodSchema._def.openapi?.effectType === "input") {
+      return { optional: true };
+    }
+    if (zodSchema._def.openapi?.effectType === "output") {
+      return { optional: false };
+    }
+    return {
+      optional: state.type === "input",
+      effects: [
+        {
+          type: "schema",
+          creationType: state.type,
+          zodType: zodSchema,
+          path: [...state.path]
+        }
+      ]
+    };
   }
   if (isZodType(zodSchema, "ZodNullable") || isZodType(zodSchema, "ZodCatch")) {
     return isOptionalSchema(zodSchema._def.innerType, state);
@@ -340,27 +594,42 @@ var isOptionalSchema = (zodSchema, state) => {
     return isOptionalSchema(zodSchema._def.schema, state);
   }
   if (isZodType(zodSchema, "ZodUnion") || isZodType(zodSchema, "ZodDiscriminatedUnion")) {
-    return zodSchema._def.options.some(
+    const results = zodSchema._def.options.map(
       (schema) => isOptionalSchema(schema, state)
     );
+    return results.reduce(
+      (acc, result) => ({
+        optional: acc.optional || result.optional,
+        effects: flattenEffects([acc.effects, result.effects])
+      }),
+      { optional: false }
+    );
   }
   if (isZodType(zodSchema, "ZodIntersection")) {
-    return [zodSchema._def.left, zodSchema._def.right].some(
+    const results = [zodSchema._def.left, zodSchema._def.right].map(
       (schema) => isOptionalSchema(schema, state)
     );
+    return results.reduce(
+      (acc, result) => ({
+        optional: acc.optional || result.optional,
+        effects: flattenEffects([acc.effects, result.effects])
+      }),
+      { optional: false }
+    );
   }
   if (isZodType(zodSchema, "ZodPipeline")) {
-    if (state.effectType === "input" || state.type === "input" && state.effectType !== "output") {
+    const type = zodSchema._def.openapi?.effectType ?? state.type;
+    if (type === "input") {
       return isOptionalSchema(zodSchema._def.in, state);
     }
-    if (state.effectType === "output" || state.type === "output" && state.effectType !== "input") {
+    if (type === "output") {
       return isOptionalSchema(zodSchema._def.out, state);
     }
   }
   if (isZodType(zodSchema, "ZodLazy")) {
     return isOptionalSchema(zodSchema._def.getter(), state);
   }
-  return zodSchema.isOptional();
+  return { optional: zodSchema.isOptional() };
 };
 
 // src/create/schema/parsers/object.ts
@@ -414,9 +683,28 @@ var createExtendedSchema = (zodObject, baseZodObject, state) => {
   if (!diffShape) {
     return void 0;
   }
+  const extendedSchema = createObjectSchemaFromShape(
+    diffShape,
+    diffOpts,
+    state
+  );
   return {
-    allOf: [{ $ref: createComponentSchemaRef(completeComponent.ref) }],
-    ...createObjectSchemaFromShape(diffShape, diffOpts, state)
+    type: "schema",
+    schema: {
+      allOf: [{ $ref: createComponentSchemaRef(completeComponent.ref) }],
+      ...extendedSchema.schema
+    },
+    effects: flattenEffects([
+      completeComponent.type === "complete" ? completeComponent.effects : [],
+      completeComponent.type === "in-progress" ? [
+        {
+          type: "component",
+          zodType: zodObject,
+          path: [...state.path]
+        }
+      ] : [],
+      extendedSchema.effects
+    ])
   };
 };
 var createDiffOpts = (baseOpts, extendedOpts) => {
@@ -446,50 +734,114 @@ var createShapeDiff = (baseObj, extendedObj) => {
 var createObjectSchemaFromShape = (shape, { unknownKeys, catchAll }, state) => {
   const properties = mapProperties(shape, state);
   const required = mapRequired(shape, state);
+  const additionalProperties = !isZodType(catchAll, "ZodNever") ? createSchemaObject(catchAll, state, ["additional properties"]) : void 0;
   return {
-    type: "object",
-    ...properties && { properties },
-    ...required && { required },
-    ...unknownKeys === "strict" && { additionalProperties: false },
-    ...!isZodType(catchAll, "ZodNever") && {
-      additionalProperties: createSchemaObject(catchAll, state, [
-        "additional properties"
-      ])
-    }
+    type: "schema",
+    schema: {
+      type: "object",
+      ...properties && { properties: properties.properties },
+      ...required?.required.length && { required: required.required },
+      ...unknownKeys === "strict" && { additionalProperties: false },
+      ...additionalProperties && {
+        additionalProperties: additionalProperties.schema
+      }
+    },
+    effects: flattenEffects([
+      ...properties?.effects ?? [],
+      additionalProperties?.effects,
+      required?.effects
+    ])
   };
 };
 var mapRequired = (shape, state) => {
-  const required = Object.entries(shape).filter(([_key, zodSchema]) => !isOptionalSchema(zodSchema, state)).map(([key]) => key);
-  if (!required.length) {
+  const { required, effects: allEffects } = Object.entries(shape).reduce(
+    (acc, [key, zodSchema]) => {
+      state.path.push(`property: ${key}`);
+      const { optional, effects } = isOptionalSchema(zodSchema, state);
+      state.path.pop();
+      if (!optional) {
+        acc.required.push(key);
+      }
+      if (effects) {
+        acc.effects.push(effects);
+      }
+      return acc;
+    },
+    {
+      required: [],
+      effects: []
+    }
+  );
+  return { required, effects: flattenEffects(allEffects) };
+};
+var mapProperties = (shape, state) => {
+  const shapeEntries = Object.entries(shape);
+  if (!shapeEntries.length) {
     return void 0;
   }
-  return required;
-};
-var mapProperties = (shape, state) => Object.entries(shape).reduce(
-  (acc, [key, zodSchema]) => {
-    if (isZodType(zodSchema, "ZodNever") || isZodType(zodSchema, "ZodUndefined")) {
+  return shapeEntries.reduce(
+    (acc, [key, zodSchema]) => {
+      if (isZodType(zodSchema, "ZodNever") || isZodType(zodSchema, "ZodUndefined")) {
+        return acc;
+      }
+      const property = createSchemaObject(zodSchema, state, [
+        `property: ${key}`
+      ]);
+      acc.properties[key] = property.schema;
+      acc.effects.push(property.effects);
       return acc;
+    },
+    {
+      properties: {},
+      effects: []
     }
-    acc[key] = createSchemaObject(zodSchema, state, [`property: ${key}`]);
-    return acc;
-  },
-  {}
-);
+  );
+};
 
 // src/create/schema/parsers/pipeline.ts
 var createPipelineSchema = (zodPipeline, state) => {
-  if (zodPipeline._def.openapi?.effectType === "input") {
+  if (zodPipeline._def.openapi?.effectType === "input" || zodPipeline._def.openapi?.effectType === "same") {
     return createSchemaObject(zodPipeline._def.in, state, ["pipeline input"]);
   }
   if (zodPipeline._def.openapi?.effectType === "output") {
     return createSchemaObject(zodPipeline._def.out, state, ["pipeline output"]);
   }
   if (state.type === "input") {
-    state.effectType = "input";
-    return createSchemaObject(zodPipeline._def.in, state, ["pipeline input"]);
+    const schema2 = createSchemaObject(zodPipeline._def.in, state, [
+      "pipeline input"
+    ]);
+    return {
+      ...schema2,
+      effects: flattenEffects([
+        [
+          {
+            type: "schema",
+            creationType: "input",
+            path: [...state.path],
+            zodType: zodPipeline
+          }
+        ],
+        schema2.effects
+      ])
+    };
   }
-  state.effectType = "output";
-  return createSchemaObject(zodPipeline._def.out, state, ["pipeline output"]);
+  const schema = createSchemaObject(zodPipeline._def.out, state, [
+    "pipeline output"
+  ]);
+  return {
+    ...schema,
+    effects: flattenEffects([
+      [
+        {
+          type: "schema",
+          creationType: "output",
+          path: [...state.path],
+          zodType: zodPipeline
+        }
+      ],
+      schema.effects
+    ])
+  };
 };
 
 // src/create/schema/parsers/preprocess.ts
@@ -511,29 +863,50 @@ var createRecordSchema = (zodRecord, state) => {
   const keySchema = createSchemaObject(zodRecord.keySchema, state, [
     "record key"
   ]);
-  const maybeComponent = "$ref" in keySchema && state.components.schemas.get(zodRecord.keySchema);
-  const maybeSchema = maybeComponent && maybeComponent.type === "complete" && maybeComponent.schemaObject;
-  const renderedKeySchema = maybeSchema || keySchema;
+  const maybeComponent = state.components.schemas.get(zodRecord.keySchema);
+  const isComplete = maybeComponent && maybeComponent.type === "complete";
+  const maybeSchema = isComplete && maybeComponent.schemaObject;
+  const maybeEffects = isComplete && maybeComponent.effects || void 0;
+  const renderedKeySchema = maybeSchema || keySchema.schema;
   if ("enum" in renderedKeySchema && renderedKeySchema.enum) {
     return {
-      type: "object",
-      properties: renderedKeySchema.enum.reduce((acc, key) => {
-        acc[key] = additionalProperties;
-        return acc;
-      }, {}),
-      additionalProperties: false
+      type: "schema",
+      schema: {
+        type: "object",
+        properties: renderedKeySchema.enum.reduce((acc, key) => {
+          acc[key] = additionalProperties.schema;
+          return acc;
+        }, {}),
+        additionalProperties: false
+      },
+      effects: flattenEffects([
+        keySchema.effects,
+        additionalProperties.effects,
+        maybeEffects
+      ])
     };
   }
   if (satisfiesVersion(state.components.openapi, "3.1.0") && "type" in renderedKeySchema && renderedKeySchema.type === "string" && Object.keys(renderedKeySchema).length > 1) {
     return {
-      type: "object",
-      propertyNames: keySchema,
-      additionalProperties
+      type: "schema",
+      schema: {
+        type: "object",
+        propertyNames: keySchema.schema,
+        additionalProperties: additionalProperties.schema
+      },
+      effects: flattenEffects([
+        keySchema.effects,
+        additionalProperties.effects
+      ])
     };
   }
   return {
-    type: "object",
-    additionalProperties
+    type: "schema",
+    schema: {
+      type: "object",
+      additionalProperties: additionalProperties.schema
+    },
+    effects: additionalProperties.effects
   };
 };
 
@@ -545,12 +918,17 @@ var createSetSchema = (zodSet, state) => {
   const schema = zodSet._def.valueType;
   const minItems = zodSet._def.minSize?.value;
   const maxItems = zodSet._def.maxSize?.value;
+  const itemSchema = createSchemaObject(schema, state, ["set items"]);
   return {
-    type: "array",
-    items: createSchemaObject(schema, state, ["set items"]),
-    uniqueItems: true,
-    ...minItems !== void 0 && { minItems },
-    ...maxItems !== void 0 && { maxItems }
+    type: "schema",
+    schema: {
+      type: "array",
+      items: itemSchema.schema,
+      uniqueItems: true,
+      ...minItems !== void 0 && { minItems },
+      ...maxItems !== void 0 && { maxItems }
+    },
+    effects: itemSchema.effects
   };
 };
 
@@ -563,29 +941,35 @@ var createStringSchema = (zodString) => {
   const maxLength = zodStringChecks.length?.[0]?.value ?? zodStringChecks.max?.[0]?.value;
   if (patterns.length <= 1) {
     return {
-      type: "string",
-      ...format && { format },
-      ...patterns[0] && { pattern: patterns[0] },
-      ...minLength !== void 0 && { minLength },
-      ...maxLength !== void 0 && { maxLength }
-    };
-  }
-  return {
-    allOf: [
-      {
+      type: "schema",
+      schema: {
         type: "string",
         ...format && { format },
         ...patterns[0] && { pattern: patterns[0] },
         ...minLength !== void 0 && { minLength },
         ...maxLength !== void 0 && { maxLength }
-      },
-      ...patterns.slice(1).map(
-        (pattern) => ({
+      }
+    };
+  }
+  return {
+    type: "schema",
+    schema: {
+      allOf: [
+        {
           type: "string",
-          pattern
-        })
-      )
-    ]
+          ...format && { format },
+          ...patterns[0] && { pattern: patterns[0] },
+          ...minLength !== void 0 && { minLength },
+          ...maxLength !== void 0 && { maxLength }
+        },
+        ...patterns.slice(1).map(
+          (pattern) => ({
+            type: "string",
+            pattern
+          })
+        )
+      ]
+    }
   };
 };
 var getZodStringChecks = (zodString) => zodString._def.checks.reduce(
@@ -651,96 +1035,88 @@ var mapStringFormat = (zodStringChecks) => {
   return void 0;
 };
 
-// src/create/schema/parsers/transform.ts
-var createTransformSchema = (zodTransform, state) => {
-  if (zodTransform._def.openapi?.effectType === "output") {
-    return createManualOutputTransformSchema(zodTransform, state);
-  }
-  if (zodTransform._def.openapi?.effectType === "input") {
-    return createSchemaObject(zodTransform._def.schema, state, [
-      "transform input"
-    ]);
-  }
-  if (state.type === "output") {
-    return createManualOutputTransformSchema(zodTransform, state);
-  }
-  state.effectType = "input";
-  return createSchemaObject(zodTransform._def.schema, state, [
-    "transform input"
-  ]);
-};
-var createManualOutputTransformSchema = (zodTransform, state) => {
-  if (!zodTransform._def.openapi?.type) {
-    const zodType = zodTransform.constructor.name;
-    const schemaName = `${zodType} - ${zodTransform._def.effect.type}`;
-    throw new Error(
-      `Failed to determine a type for ${schemaName} at ${state.path.join(
-        " > "
-      )}. Please change the 'effectType' to 'input', wrap it in a ZodPipeline or assign it a manual 'type'.`
-    );
-  }
-  return {
-    type: zodTransform._def.openapi.type
-  };
-};
-var throwTransformError = (zodType, state) => {
-  throw new Error(
-    `${JSON.stringify(zodType)} at ${state.path.join(
-      " > "
-    )} contains a transformation but is used in both an input and an output. This is likely a mistake. Set an \`effectType\`, wrap it in a ZodPipeline or assign it a manual type to resolve`
-  );
-};
-
 // src/create/schema/parsers/tuple.ts
 var createTupleSchema = (zodTuple, state) => {
   const items = zodTuple.items;
   const rest = zodTuple._def.rest;
-  return {
-    type: "array",
-    ...mapItemProperties(items, rest, state)
-  };
-};
-var mapPrefixItems = (items, state) => {
-  if (items.length) {
-    return items.map(
-      (item, index) => createSchemaObject(item, state, [`tuple item ${index}`])
-    );
-  }
-  return void 0;
-};
-var mapItemProperties = (items, rest, state) => {
   const prefixItems = mapPrefixItems(items, state);
   if (satisfiesVersion(state.components.openapi, "3.1.0")) {
     if (!rest) {
       return {
-        maxItems: items.length,
-        minItems: items.length,
-        ...prefixItems && { prefixItems }
+        type: "schema",
+        schema: {
+          type: "array",
+          maxItems: items.length,
+          minItems: items.length,
+          ...prefixItems && {
+            prefixItems: prefixItems.schemas.map((item) => item.schema)
+          }
+        },
+        effects: prefixItems?.effects
       };
     }
+    const itemSchema = createSchemaObject(rest, state, ["tuple items"]);
     return {
-      items: createSchemaObject(rest, state, ["tuple items"]),
-      ...prefixItems && { prefixItems }
+      type: "schema",
+      schema: {
+        type: "array",
+        items: itemSchema.schema,
+        ...prefixItems && {
+          prefixItems: prefixItems.schemas.map((item) => item.schema)
+        }
+      },
+      effects: flattenEffects([prefixItems?.effects, itemSchema.effects])
     };
   }
   if (!rest) {
     return {
-      maxItems: items.length,
-      minItems: items.length,
-      ...prefixItems && { items: { oneOf: prefixItems } }
+      type: "schema",
+      schema: {
+        type: "array",
+        maxItems: items.length,
+        minItems: items.length,
+        ...prefixItems && {
+          items: { oneOf: prefixItems.schemas.map((item) => item.schema) }
+        }
+      },
+      effects: prefixItems?.effects
+    };
+  }
+  if (prefixItems) {
+    const restSchema = createSchemaObject(rest, state, ["tuple items"]);
+    return {
+      type: "schema",
+      schema: {
+        type: "array",
+        items: {
+          oneOf: [
+            ...prefixItems.schemas.map((item) => item.schema),
+            restSchema.schema
+          ]
+        }
+      },
+      effects: flattenEffects([restSchema.effects, prefixItems.effects])
     };
   }
   return {
-    ...prefixItems && {
-      items: {
-        oneOf: [
-          ...prefixItems,
-          createSchemaObject(rest, state, ["tuple items"])
-        ]
-      }
+    type: "schema",
+    schema: {
+      type: "array"
     }
   };
 };
+var mapPrefixItems = (items, state) => {
+  if (items.length) {
+    const schemas = items.map(
+      (item, index) => createSchemaObject(item, state, [`tuple item ${index}`])
+    );
+    return {
+      effects: flattenEffects(schemas.map((s) => s.effects)),
+      schemas
+    };
+  }
+  return void 0;
+};
 
 // src/create/schema/parsers/union.ts
 var createUnionSchema = (zodUnion, state) => {
@@ -749,16 +1125,27 @@ var createUnionSchema = (zodUnion, state) => {
   );
   if (zodUnion._def.openapi?.unionOneOf) {
     return {
-      oneOf: schemas
+      type: "schema",
+      schema: {
+        oneOf: schemas.map((s) => s.schema)
+      },
+      effects: flattenEffects(schemas.map((s) => s.effects))
     };
   }
   return {
-    anyOf: schemas
+    type: "schema",
+    schema: {
+      anyOf: schemas.map((s) => s.schema)
+    },
+    effects: flattenEffects(schemas.map((s) => s.effects))
   };
 };
 
 // src/create/schema/parsers/unknown.ts
-var createUnknownSchema = (_zodUnknown) => ({});
+var createUnknownSchema = (_zodUnknown) => ({
+  type: "schema",
+  schema: {}
+});
 
 // src/create/schema/parsers/index.ts
 var createSchemaSwitch = (zodSchema, state) => {
@@ -856,22 +1243,16 @@ var createSchemaSwitch = (zodSchema, state) => {
 };
 
 // src/create/schema/index.ts
-var newSchemaState = (state) => ({
-  type: state.type,
-  components: state.components,
-  path: [...state.path],
-  visited: new Set(state.visited)
-});
-var createNewSchema = (zodSchema, newState, subpath) => {
-  newState.path.push(...subpath);
-  if (newState.visited.has(zodSchema)) {
+var isDescriptionEqual = (schema, zodSchema) => schema.type === "ref" && zodSchema.description === schema.zodType.description;
+var createNewSchema = (zodSchema, state) => {
+  if (state.visited.has(zodSchema)) {
     throw new Error(
-      `The schema at ${newState.path.join(
+      `The schema at ${state.path.join(
         " > "
       )} needs to be registered because it's circularly referenced`
     );
   }
-  newState.visited.add(zodSchema);
+  state.visited.add(zodSchema);
   const {
     effectType,
     param,
@@ -881,99 +1262,112 @@ var createNewSchema = (zodSchema, newState, subpath) => {
     unionOneOf,
     ...additionalMetadata
   } = zodSchema._def.openapi ?? {};
-  const schema = createSchemaSwitch(zodSchema, newState);
-  const description = zodSchema.description;
+  const schema = createSchemaSwitch(zodSchema, state);
+  const description = zodSchema.description && !isDescriptionEqual(schema, zodSchema) ? zodSchema.description : void 0;
   const schemaWithMetadata = enhanceWithMetadata(schema, {
     ...description && { description },
     ...additionalMetadata
   });
-  return {
-    schema: schemaWithMetadata,
-    newState
-  };
+  state.visited.delete(zodSchema);
+  return schemaWithMetadata;
 };
-var createNewRef = (ref, zodSchema, state, subpath) => {
+var createNewRef = (ref, zodSchema, state) => {
   state.components.schemas.set(zodSchema, {
     type: "in-progress",
     ref
   });
-  const newSchema = createNewSchema(
-    zodSchema,
-    newSchemaState({ ...state, visited: /* @__PURE__ */ new Set() }),
-    subpath
-  );
+  const newSchema = createNewSchema(zodSchema, {
+    ...state,
+    visited: /* @__PURE__ */ new Set()
+  });
   state.components.schemas.set(zodSchema, {
     type: "complete",
     ref,
     schemaObject: newSchema.schema,
-    creationType: newSchema.newState?.effectType
+    effects: newSchema.effects
   });
   return {
+    type: "ref",
     schema: { $ref: createComponentSchemaRef(ref) },
-    newState: newSchema.newState
+    effects: newSchema.effects ? [
+      {
+        type: "component",
+        zodType: zodSchema,
+        path: [...state.path]
+      }
+    ] : void 0,
+    zodType: zodSchema
   };
 };
-var createExistingRef = (zodSchema, component, state, subpath) => {
-  const newState = newSchemaState(state);
-  newState.path.push(...subpath);
+var createExistingRef = (zodSchema, component, state) => {
   if (component && component.type === "complete") {
-    if (component.creationType && component.creationType !== state.type) {
-      throwTransformError(zodSchema, newState);
-    }
     return {
+      type: "ref",
       schema: { $ref: createComponentSchemaRef(component.ref) },
-      newState: {
-        ...newState,
-        effectType: component.creationType
-      }
+      effects: component.effects ? [
+        {
+          type: "component",
+          zodType: zodSchema,
+          path: [...state.path]
+        }
+      ] : void 0,
+      zodType: zodSchema
     };
   }
   if (component && component.type === "in-progress") {
     return {
+      type: "ref",
       schema: { $ref: createComponentSchemaRef(component.ref) },
-      newState
+      effects: [
+        {
+          type: "component",
+          zodType: zodSchema,
+          path: [...state.path]
+        }
+      ],
+      zodType: zodSchema
     };
   }
   return;
 };
-var createSchemaOrRef = (zodSchema, state, subpath) => {
+var createSchemaOrRef = (zodSchema, state) => {
   const component = state.components.schemas.get(zodSchema);
-  const existingRef = createExistingRef(zodSchema, component, state, subpath);
+  const existingRef = createExistingRef(zodSchema, component, state);
   if (existingRef) {
     return existingRef;
   }
   const ref = zodSchema._def.openapi?.ref ?? component?.ref;
   if (ref) {
-    return createNewRef(ref, zodSchema, state, subpath);
+    return createNewRef(ref, zodSchema, state);
   }
-  return createNewSchema(zodSchema, newSchemaState(state), subpath);
+  return createNewSchema(zodSchema, state);
 };
 var createSchemaObject = (zodSchema, state, subpath) => {
-  const { schema, newState } = createSchemaOrRef(zodSchema, state, subpath);
-  if (newState?.effectType) {
-    if (state.type !== newState?.effectType || state.effectType && newState.effectType !== state.effectType) {
-      throwTransformError(zodSchema, newState);
-    }
-    state.effectType = newState.effectType;
-  }
+  state.path.push(...subpath);
+  const schema = createSchemaOrRef(zodSchema, state);
+  state.path.pop();
   return schema;
 };
+var createSchema = (zodSchema, state, subpath) => {
+  const schema = createSchemaObject(zodSchema, state, subpath);
+  if (schema.effects) {
+    verifyEffects(schema.effects, state);
+  }
+  return schema.schema;
+};
 
 // src/create/parameters.ts
 var createComponentParamRef = (ref) => `#/components/parameters/${ref}`;
 var createBaseParameter = (schema, components, subpath) => {
   const { ref, ...rest } = schema._def.openapi?.param ?? {};
-  const state = newSchemaState({
+  const state = {
     components,
     type: "input",
     path: [],
     visited: /* @__PURE__ */ new Set()
-  });
-  const schemaObject = createSchemaObject(schema, state, [
-    ...subpath,
-    "schema"
-  ]);
-  const required = !isOptionalSchema(schema, state);
+  };
+  const schemaObject = createSchema(schema, state, [...subpath, "schema"]);
+  const required = !isOptionalSchema(schema, state)?.optional;
   const description = schema._def.openapi?.description ?? schema._def.description;
   return {
     ...description && { description },
@@ -993,7 +1387,7 @@ var createParamOrRef = (zodSchema, components, subpath, type, name) => {
     throw new Error("Parameter name missing");
   }
   if (component && component.type === "complete") {
-    if (!("$ref" in component.paramObject) && (component.in !== type || component.name !== name)) {
+    if (!("$ref" in component.paramObject) && (component.in !== paramType || component.name !== paramName)) {
       throw new Error(`parameterRef "${component.ref}" is already registered`);
     }
     return {
@@ -1024,11 +1418,12 @@ var createParamOrRef = (zodSchema, components, subpath, type, name) => {
   }
   return paramObject;
 };
-var createParameters = (type, zodObject, components, subpath) => {
-  if (!zodObject) {
+var createParameters = (type, zodObjectType, components, subpath) => {
+  if (!zodObjectType) {
     return [];
   }
-  return Object.entries(zodObject.shape).map(
+  const zodObject = getZodObject(zodObjectType, "input").shape;
+  return Object.entries(zodObject).map(
     ([key, zodSchema]) => createParamOrRef(zodSchema, components, [...subpath, key], type, key)
   );
 };
@@ -1082,6 +1477,27 @@ var createParametersObject = (parameters, requestParams, components, subpath) =>
   ];
   return combinedParameters.length ? combinedParameters : void 0;
 };
+var getZodObject = (schema, type) => {
+  if (isZodType(schema, "ZodObject")) {
+    return schema;
+  }
+  if (isZodType(schema, "ZodLazy")) {
+    return getZodObject(schema.schema, type);
+  }
+  if (isZodType(schema, "ZodEffects")) {
+    return getZodObject(schema.innerType(), type);
+  }
+  if (isZodType(schema, "ZodBranded")) {
+    return getZodObject(schema.unwrap(), type);
+  }
+  if (isZodType(schema, "ZodPipeline")) {
+    if (type === "input") {
+      return getZodObject(schema._def.in, type);
+    }
+    return getZodObject(schema._def.out, type);
+  }
+  throw new Error("failed to find ZodObject in schema");
+};
 
 // src/create/content.ts
 var createMediaTypeSchema = (schemaObject, components, type, subpath) => {
@@ -1091,14 +1507,14 @@ var createMediaTypeSchema = (schemaObject, components, type, subpath) => {
   if (!isAnyZodType(schemaObject)) {
     return schemaObject;
   }
-  return createSchemaObject(
+  return createSchema(
     schemaObject,
-    newSchemaState({
+    {
       components,
       type,
       path: [],
       visited: /* @__PURE__ */ new Set()
-    }),
+    },
     subpath
   );
 };
@@ -1172,14 +1588,14 @@ var createHeaderOrRef = (schema, components) => {
 };
 var createBaseHeader = (schema, components) => {
   const { ref, ...rest } = schema._def.openapi?.header ?? {};
-  const state = newSchemaState({
+  const state = {
     components,
     type: "output",
     path: [],
     visited: /* @__PURE__ */ new Set()
-  });
-  const schemaObject = createSchemaObject(schema, state, ["header"]);
-  const required = !isOptionalSchema(schema, state);
+  };
+  const schemaObject = createSchema(schema, state, ["header"]);
+  const required = !isOptionalSchema(schema, state)?.optional;
   return {
     ...rest,
     ...schema && { schema: schemaObject },
@@ -1470,13 +1886,13 @@ var createComponents = (componentsObject, components) => {
 var createSchemaComponents = (componentsObject, components) => {
   Array.from(components.schemas).forEach(([schema, { type }], index) => {
     if (type === "manual") {
-      const state = newSchemaState({
+      const state = {
         components,
         type: schema._def.openapi?.refType ?? "output",
         path: [],
         visited: /* @__PURE__ */ new Set()
-      });
-      createSchemaObject(schema, state, [`component schema index ${index}`]);
+      };
+      createSchema(schema, state, [`component schema index ${index}`]);
     }
   });
   const customComponents = Object.entries(