fix: correctly parse required only schema in allOf like https://editor.swagger.io/

Author: C-ra-ZY

.changeset/polite-bottles-relate.md

@@ -0,0 +1,5 @@
+---
+"openapi-zod-client": minor
+---
+
+Fix #260 by infer types of items in a required only allOf item.

lib/src/inferRequiredOnly.ts

@@ -0,0 +1,75 @@
+import { type SchemaObject, type ReferenceObject, isReferenceObject } from "openapi3-ts";
+import type { DocumentResolver } from "./makeSchemaResolver";
+
+const isBrokenAllOfItem = (item: SchemaObject | ReferenceObject): item is SchemaObject => {
+    if (
+        !isReferenceObject(item) &&
+        !!item.required &&
+        !item.type &&
+        !item.properties &&
+        !item?.allOf &&
+        !item?.anyOf &&
+        !item.oneOf
+    ) {
+        return true;
+    }
+    return false;
+};
+
+export function inferRequiredSchema(schema: SchemaObject) {
+    if (!schema.allOf) {
+        throw new Error(
+            "function inferRequiredSchema is specialized to handle item with required only in an allOf array."
+        );
+    }
+    const [standaloneRequisites, noRequiredOnlyAllof] = schema.allOf.reduce(
+        (acc, cur) => {
+            if (isBrokenAllOfItem(cur)) {
+                const required = (cur as SchemaObject).required;
+                acc[0].push(...(required ?? []));
+            } else {
+                acc[1].push(cur);
+            }
+            return acc;
+        },
+        [[], []] as [string[], (SchemaObject | ReferenceObject)[]]
+    );
+
+    const composedRequiredSchema = {
+        properties: standaloneRequisites.reduce(
+            (acc, cur) => {
+                acc[cur] = {
+                    // type: "unknown" as SchemaObject["type"],
+                } as SchemaObject;
+                return acc;
+            },
+            {} as {
+                [propertyName: string]: SchemaObject | ReferenceObject;
+            }
+        ),
+        type: "object" as const,
+        required: standaloneRequisites,
+    };
+
+    return {
+        noRequiredOnlyAllof,
+        composedRequiredSchema,
+        patchRequiredSchemaInLoop: (prop: SchemaObject | ReferenceObject, resolver: DocumentResolver) => {
+            if (isReferenceObject(prop)) {
+                const refType = resolver.getSchemaByRef(prop.$ref);
+                if (refType) {
+                    composedRequiredSchema.required.forEach((required) => {
+                        composedRequiredSchema.properties[required] = refType?.properties?.[required] ?? {};
+                    });
+                }
+            } else {
+                const properties = prop["properties"] ?? {};
+                composedRequiredSchema.required.forEach((required) => {
+                    if (properties[required]) {
+                        composedRequiredSchema.properties[required] = properties[required] ?? {};
+                    }
+                });
+            }
+        },
+    };
+}

lib/src/openApiToTypescript.ts

@@ -6,6 +6,7 @@ import { isReferenceObject } from "./isReferenceObject";
 import type { DocumentResolver } from "./makeSchemaResolver";
 import type { TemplateContext } from "./template-context";
 import { wrapWithQuotesIfNeeded } from "./utils";
+import { inferRequiredSchema } from "./inferRequiredOnly";
 
 type TsConversionArgs = {
     schema: SchemaObject | ReferenceObject;
@@ -96,7 +97,12 @@ TsConversionArgs): ts.Node | TypeDefinitionObject | string => {
 
         if (Array.isArray(schema.type)) {
             if (schema.type.length === 1) {
-                return getTypescriptFromOpenApi({ schema: { ...schema, type: schema.type[0]! }, ctx, meta, options });
+                return getTypescriptFromOpenApi({
+                    schema: { ...schema, type: schema.type[0]! },
+                    ctx,
+                    meta,
+                    options,
+                });
             }
 
             const types = schema.type.map(
@@ -149,10 +155,25 @@ TsConversionArgs): ts.Node | TypeDefinitionObject | string => {
             if (schema.allOf.length === 1) {
                 return getTypescriptFromOpenApi({ schema: schema.allOf[0]!, ctx, meta, options });
             }
+            const { patchRequiredSchemaInLoop, noRequiredOnlyAllof, composedRequiredSchema } =
+                inferRequiredSchema(schema);
 
-            const types = schema.allOf.map(
-                (prop) => getTypescriptFromOpenApi({ schema: prop, ctx, meta, options }) as TypeDefinition
-            );
+            const types = noRequiredOnlyAllof.map((prop) => {
+                const type = getTypescriptFromOpenApi({ schema: prop, ctx, meta, options }) as TypeDefinition;
+                ctx?.resolver && patchRequiredSchemaInLoop(prop, ctx.resolver);
+                return type;
+            });
+
+            if (Object.keys(composedRequiredSchema.properties).length) {
+                types.push(
+                    getTypescriptFromOpenApi({
+                        schema: composedRequiredSchema,
+                        ctx,
+                        meta,
+                        options,
+                    }) as TypeDefinition
+                );
+            }
             return schema.nullable ? t.union([t.intersection(types), t.reference("null")]) : t.intersection(types);
         }
 
@@ -164,8 +185,10 @@ TsConversionArgs): ts.Node | TypeDefinitionObject | string => {
                 }
 
                 const hasNull = schema.enum.includes(null);
-                const withoutNull = schema.enum.filter(f => f !== null);
-                return schema.nullable || hasNull ? t.union([...withoutNull, t.reference("null")]) : t.union(withoutNull);
+                const withoutNull = schema.enum.filter((f) => f !== null);
+                return schema.nullable || hasNull
+                    ? t.union([...withoutNull, t.reference("null")])
+                    : t.union(withoutNull);
             }
 
             if (schemaType === "string")
@@ -278,7 +301,6 @@ TsConversionArgs): ts.Node | TypeDefinitionObject | string => {
         }
 
         if (!schemaType) return t.unknown();
-
         // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
         throw new Error(`Unsupported schema type: ${schemaType}`);
     };
@@ -293,7 +315,7 @@ type SingleType = Exclude<SchemaObject["type"], any[] | undefined>;
 const isPrimitiveType = (type: SingleType): type is PrimitiveType => primitiveTypeList.includes(type as any);
 
 const primitiveTypeList = ["string", "number", "integer", "boolean", "null"] as const;
-type PrimitiveType = typeof primitiveTypeList[number];
+type PrimitiveType = (typeof primitiveTypeList)[number];
 
 const wrapTypeIfInline = ({
     isInline,

lib/src/openApiToZod.ts

@@ -6,6 +6,7 @@ import { CodeMeta } from "./CodeMeta";
 import { isReferenceObject } from "./isReferenceObject";
 import type { TemplateContext } from "./template-context";
 import { escapeControlCharacters, isPrimitiveType, wrapWithQuotesIfNeeded } from "./utils";
+import { inferRequiredSchema } from "./inferRequiredOnly";
 
 type ConversionArgs = {
     schema: SchemaObject | ReferenceObject;
@@ -23,7 +24,6 @@ export function getZodSchema({ schema, ctx, meta: inheritedMeta, options }: Conv
     if (!schema) {
         throw new Error("Schema is required");
     }
-
     const code = new CodeMeta(schema, ctx, inheritedMeta);
     const meta = {
         parent: code.inherit(inheritedMeta?.parent),
@@ -87,14 +87,14 @@ export function getZodSchema({ schema, ctx, meta: inheritedMeta, options }: Conv
 
         /* when there are multiple allOf we are unable to use a discriminatedUnion as this library adds an
          *   'z.and' to the schema that it creates which breaks type inference */
-        const hasMultipleAllOf = schema.oneOf?.some((obj) => isSchemaObject(obj) && (obj?.allOf || []).length > 1)
+        const hasMultipleAllOf = schema.oneOf?.some((obj) => isSchemaObject(obj) && (obj?.allOf || []).length > 1);
         if (schema.discriminator && !hasMultipleAllOf) {
             const propertyName = schema.discriminator.propertyName;
 
             return code.assign(`
                 z.discriminatedUnion("${propertyName}", [${schema.oneOf
-                    .map((prop) => getZodSchema({ schema: prop, ctx, meta, options }))
-                    .join(", ")}])
+                .map((prop) => getZodSchema({ schema: prop, ctx, meta, options }))
+                .join(", ")}])
             `);
         }
 
@@ -136,8 +136,24 @@ export function getZodSchema({ schema, ctx, meta: inheritedMeta, options }: Conv
             const type = getZodSchema({ schema: schema.allOf[0]!, ctx, meta, options });
             return code.assign(type.toString());
         }
-
-        const types = schema.allOf.map((prop) => getZodSchema({ schema: prop, ctx, meta, options }));
+        const { patchRequiredSchemaInLoop, noRequiredOnlyAllof, composedRequiredSchema } = inferRequiredSchema(schema);
+
+        const types = noRequiredOnlyAllof.map((prop) => {
+            const zodSchema = getZodSchema({ schema: prop, ctx, meta, options });
+            ctx?.resolver && patchRequiredSchemaInLoop(prop, ctx.resolver);
+            return zodSchema;
+        });
+
+        if (composedRequiredSchema.required.length) {
+            types.push(
+                getZodSchema({
+                    schema: composedRequiredSchema,
+                    ctx,
+                    meta,
+                    options,
+                })
+            );
+        }
         const first = types.at(0)!;
         const rest = types
             .slice(1)
@@ -158,7 +174,9 @@ export function getZodSchema({ schema, ctx, meta: inheritedMeta, options }: Conv
                 }
 
                 // eslint-disable-next-line sonarjs/no-nested-template-literals
-                return code.assign(`z.enum([${schema.enum.map((value) => value === null ? "null" : `"${value}"`).join(", ")}])`);
+                return code.assign(
+                    `z.enum([${schema.enum.map((value) => (value === null ? "null" : `"${value}"`)).join(", ")}])`
+                );
             }
 
             if (schema.enum.some((e) => typeof e === "string")) {
@@ -200,15 +218,14 @@ export function getZodSchema({ schema, ctx, meta: inheritedMeta, options }: Conv
         return code.assign(`z.array(z.any())${readonly}`);
     }
 
-    if (
-        schemaType === "object" ||
-        schema.properties ||
-        schema.additionalProperties ||
-        (schema.required && Array.isArray(schema.required))
-    ) {
+    if (schemaType === "object" || schema.properties || schema.additionalProperties) {
         // additional properties default to true if additionalPropertiesDefaultValue not provided
-        const additionalPropsDefaultValue = options?.additionalPropertiesDefaultValue !== undefined ? options?.additionalPropertiesDefaultValue : true;
-        const additionalProps = schema.additionalProperties === null || schema.additionalProperties === undefined ? additionalPropsDefaultValue : schema.additionalProperties;
+        const additionalPropsDefaultValue =
+            options?.additionalPropertiesDefaultValue !== undefined ? options?.additionalPropertiesDefaultValue : true;
+        const additionalProps =
+            schema.additionalProperties === null || schema.additionalProperties === undefined
+                ? additionalPropsDefaultValue
+                : schema.additionalProperties;
         const additionalPropsSchema = additionalProps === false ? "" : ".passthrough()";
 
         if (typeof schema.additionalProperties === "object" && Object.keys(schema.additionalProperties).length > 0) {
@@ -235,8 +252,8 @@ export function getZodSchema({ schema, ctx, meta: inheritedMeta, options }: Conv
                     isRequired: isPartial
                         ? true
                         : hasRequiredArray
-                            ? schema.required?.includes(prop)
-                            : options?.withImplicitRequiredProps,
+                        ? schema.required?.includes(prop)
+                        : options?.withImplicitRequiredProps,
                     name: prop,
                 } as CodeMetaData;
 
@@ -263,26 +280,7 @@ export function getZodSchema({ schema, ctx, meta: inheritedMeta, options }: Conv
         }
 
         const partial = isPartial ? ".partial()" : "";
-
-        const schemaRequired = schema.required;
-        const schemaProperties = schema.properties;
-        // properties in required array but not in properties should be validated seprately, when additional props are allowed
-        const extraPropertiesFromRequiredArray =
-            additionalProps !== false && schemaRequired
-                ? schemaProperties
-                    ? schemaRequired.filter((p) => !(p in schemaProperties))
-                    : schemaRequired
-                : [];
-        const extraProperties =
-            extraPropertiesFromRequiredArray.length > 0
-                ? "z.object({ " + extraPropertiesFromRequiredArray.map((p) => `${p}: z.unknown()`).join(", ") + " })"
-                : "";
-
-        return code.assign(
-            `z.object(${properties})${partial}${
-                extraProperties && ".and(" + extraProperties + ")"
-            }${additionalPropsSchema}${readonly}`
-        );
+        return code.assign(`z.object(${properties})${partial}${additionalPropsSchema}${readonly}`);
     }
 
     if (!schemaType) return code.assign("z.unknown()");