feat: add with required utility to enforce properties of allOf

Resolves openapi-ts#657

Author: Swiftwork

src/index.ts

@@ -190,19 +190,30 @@ async function openapiTS(
     output.push(`export type operations = Record<string, never>;`, "");
   }
 
-  // 4. OneOf type helper (@see https://github.com/Microsoft/TypeScript/issues/14094#issuecomment-723571692)
+  // 4a. OneOf type helper (@see https://github.com/Microsoft/TypeScript/issues/14094#issuecomment-723571692)
   if (output.join("\n").includes("OneOf")) {
     output.splice(
       1,
       0,
-      "/** Type helpers */",
+      "/** OneOf type helpers */",
       "type Without<T, U> = { [P in Exclude<keyof T, keyof U>]?: never };",
       "type XOR<T, U> = (T | U) extends object ? (Without<T, U> & U) | (Without<U, T> & T) : T | U;",
       "type OneOf<T extends any[]> = T extends [infer Only] ? Only : T extends [infer A, infer B, ...infer Rest] ? OneOf<[XOR<A, B>, ...Rest]> : never;",
       ""
     );
   }
 
+  // 4b. WithRequired type helper (@see https://github.com/drwpow/openapi-typescript/issues/657#issuecomment-1399274607)
+  if (output.join("\n").includes("WithRequired")) {
+    output.splice(
+      1,
+      0,
+      "/** WithRequired type helpers */",
+      "type WithRequired<T, K extends keyof T> = T & { [P in K]-?: T[P] };",
+      ""
+    );
+  }
+
   return output.join("\n");
 }
 

src/transform/schema-object.ts

@@ -14,6 +14,7 @@ import {
   tsReadonly,
   tsTupleOf,
   tsUnionOf,
+  tsWithRequired,
 } from "../utils.js";
 
 export interface TransformSchemaObjectOptions {
@@ -229,8 +230,12 @@ export function defaultSchemaObjectTransform(
     finalType = finalType ? tsIntersectionOf(finalType, oneOfType) : oneOfType;
   } else {
     // allOf
-    if ("allOf" in schemaObject && Array.isArray(schemaObject.allOf))
+    if ("allOf" in schemaObject && Array.isArray(schemaObject.allOf)) {
       finalType = tsIntersectionOf(...(finalType ? [finalType] : []), ...collectCompositions(schemaObject.allOf));
+      if ("required" in schemaObject && Array.isArray(schemaObject.required)) {
+        finalType = tsWithRequired(finalType, schemaObject.required);
+      }
+    }
     // anyOf
     if ("anyOf" in schemaObject && Array.isArray(schemaObject.anyOf)) {
       const anyOfTypes = tsUnionOf(...collectCompositions(schemaObject.anyOf));

src/types.ts

@@ -449,8 +449,8 @@ export type SchemaObject = {
       allOf?: (SchemaObject | ReferenceObject)[];
       anyOf?: (SchemaObject | ReferenceObject)[];
     }
-  | { allOf: (SchemaObject | ReferenceObject)[]; anyOf?: (SchemaObject | ReferenceObject)[] }
-  | { allOf?: (SchemaObject | ReferenceObject)[]; anyOf: (SchemaObject | ReferenceObject)[] }
+  | { allOf: (SchemaObject | ReferenceObject)[]; anyOf?: (SchemaObject | ReferenceObject)[]; required?: string[]; }
+  | { allOf?: (SchemaObject | ReferenceObject)[]; anyOf: (SchemaObject | ReferenceObject)[]; required?: string[]; }
 );
 
 /**

src/utils.ts

@@ -182,6 +182,11 @@ export function tsOmit(root: string, keys: string[]): string {
   return `Omit<${root}, ${tsUnionOf(...keys.map(escStr))}>`;
 }
 
+/** WithRequired<T> */
+export function tsWithRequired(root: string, keys: string[]): string {
+  return `WithRequired<${root}, ${tsUnionOf(...keys.map(escStr))}>`;
+}
+
 /** make a given property key optional */
 export function tsOptionalProperty(key: string): string {
   return `${key}?`;

test/index.test.ts

@@ -9,13 +9,18 @@ const BOILERPLATE = `/**
 
 `;
 
-const TYPE_HELPERS = `
-/** Type helpers */
+const ONE_OF_TYPE_HELPERS = `
+/** OneOf type helpers */
 type Without<T, U> = { [P in Exclude<keyof T, keyof U>]?: never };
 type XOR<T, U> = (T | U) extends object ? (Without<T, U> & U) | (Without<U, T> & T) : T | U;
 type OneOf<T extends any[]> = T extends [infer Only] ? Only : T extends [infer A, infer B, ...infer Rest] ? OneOf<[XOR<A, B>, ...Rest]> : never;
 `;
 
+const WITH_REQUIRED_TYPE_HELPERS = `
+/** WithRequired type helpers */
+type WithRequired<T, K extends keyof T> = T & { [P in K]-?: T[P] };
+`;
+
 beforeAll(() => {
   vi.spyOn(process, "exit").mockImplementation(((code: number) => {
     throw new Error(`Process exited with error code ${code}`);
@@ -494,7 +499,7 @@ export type operations = Record<string, never>;
           },
           { exportType: false }
         );
-        expect(generated).toBe(`${BOILERPLATE}${TYPE_HELPERS}
+        expect(generated).toBe(`${BOILERPLATE}${ONE_OF_TYPE_HELPERS}
 export type paths = Record<string, never>;
 
 export type webhooks = Record<string, never>;
@@ -516,11 +521,66 @@ export interface components {
 
 export type external = Record<string, never>;
 
+export type operations = Record<string, never>;
+`);
+      });
+    });
+
+    describe("WithRequired type helpers", () => {
+      test("should be added only when used", async () => {
+        const generated = await openapiTS(
+          {
+            openapi: "3.1",
+            info: { title: "Test", version: "1.0" },
+            components: {
+              schemas: {
+                User: {
+                  allOf: [
+                    {
+                      type: "object",
+                      properties: { firstName: { type: "string" }, lastName: { type: "string" } },
+                    },
+                    {
+                      type: "object",
+                      properties: { middleName: { type: "string" } },
+                    },
+                  ],
+                  required: ["firstName", "lastName"],
+                },
+              },
+            },
+          },
+          { exportType: false }
+        );
+        expect(generated).toBe(`${BOILERPLATE}${WITH_REQUIRED_TYPE_HELPERS}
+export type paths = Record<string, never>;
+
+export type webhooks = Record<string, never>;
+
+export interface components {
+  schemas: {
+    User: WithRequired<{
+      firstName?: string;
+      lastName?: string;
+    } & {
+      middleName?: string;
+    }, "firstName" | "lastName">;
+  };
+  responses: never;
+  parameters: never;
+  requestBodies: never;
+  headers: never;
+  pathItems: never;
+}
+
+export type external = Record<string, never>;
+
 export type operations = Record<string, never>;
 `);
       });
     });
   });
+  
 
   // note: this tests the Node API; the snapshots in cli.test.ts test the CLI
   describe("snapshots", () => {

test/schema-object.test.ts

@@ -255,6 +255,26 @@ describe("Schema Object", () => {
   green: number;
 }`);
       });
+
+      test("sibling required", () => {
+        const schema: SchemaObject = {
+          required: ["red", "blue", "green"],
+          allOf: [
+            {
+              type: "object",
+              properties: { red: { type: "number" }, blue: { type: "number" } },
+            },
+            { type: "object", properties: { green: { type: "number" } } },
+          ],
+        };
+        const generated = transformSchemaObject(schema, options);
+        expect(generated).toBe(`WithRequired<{
+  red?: number;
+  blue?: number;
+} & {
+  green?: number;
+}, "red" | "blue" | "green">`);
+      });
     });
 
     describe("anyOf", () => {