Constraint Composite for empty objects inside an allOf

[MisterMunchkin]

I ran into a bug where if I had this yaml fragment:

 requestBody:
        required: true
        content:
          application/json:
            schema:
              allOf:
                - $ref: '#/components/schemas/ShiftPayload'
                - type: object
                  required:
                    - end_at
                    - job_id
                    - start_at

ShiftPayload

ShiftPayload:
      type: object
      additionalProperties: false
      properties:
        end_at:
          type: string
          format: date-time
          description: Visit end datetime in ISO 8601 format (must be after `start_at` if provided)
        job_id:
          type: integer
          description: The ID of the job the shift is logged against
        start_at:
          type: string
          format: date-time
          description: Visit start datetime in ISO 8601 format

It generates this output:

  requestBody: {
            content: {
                "application/json": components["schemas"]["ShiftPayload"] & Record<string, never>;
            };
        };

Which isn't ideal because the yaml definition is essentially just trying to turn the 3 fields end_at job_id and start_at into required fields instead of optional.

I think we should handle required constraints in allOf compositions! We can update collectAllCompositions in ./packages/openapi-typescript/src/transform/schema-object.ts to handle required constraints like so:

function isConstraintOnlySchemas(item: SchemaObject | ReferenceObject): boolean {
    return !("$ref" in item) &&
      typeof item === "object" &&
      "type" in item &&
      item.type === "object" &&
      Array.isArray(item.required) &&
      !item.properties &&
      !item.additionalProperties &&
      !item.patternProperties;
  }

  /** Collect allOf with Omit<> for discriminators */
  function collectAllOfCompositions(items: (SchemaObject | ReferenceObject)[], required?: string[]): ts.TypeNode[] {
    const output: ts.TypeNode[] = [];
  
    const constraintRequired = items
    .filter(isConstraintOnlySchemas)
    .flatMap(item => (item as SchemaObject).required ?? []);

    const allRequired = [...(required ?? []), ...constraintRequired];
    for (const item of items) {
      //Constraints will be handled via WithRequired
      if (isConstraintOnlySchemas(item)) continue;

      let itemType: ts.TypeNode;
      // if this is a $ref, use WithRequired<X, Y> if parent specifies required properties
      // (but only for valid keys)
      if ("$ref" in item) {
        itemType = transformSchemaObject(item, options);

        const resolved = options.ctx.resolve<SchemaObject>(item.$ref);

        // make keys required, if necessary
        if (
          resolved &&
          typeof resolved === "object" &&
          "properties" in resolved &&
          // we have already handled this item (discriminator property was already added as required)
          !options.ctx.discriminators.refsHandled.includes(item.$ref)
        ) {
          // add WithRequired<X, Y> if necessary
          const validRequired = allRequired.filter((key) => !!resolved.properties?.[key]);
          if (validRequired.length) {
            itemType = tsWithRequired(itemType, validRequired, options.ctx.injectFooter);
          }
        }
      }
      // otherwise, if this is a schema object, combine parent `required[]` with its own, if any
      else {
        const itemRequired = [...allRequired];
        if (typeof item === "object" && Array.isArray(item.required)) {
          itemRequired.push(...item.required);
        }
        itemType = transformSchemaObject({ ...item, required: itemRequired }, options);
      }
    ...rest of code
  }

TDD

    "allOf > constraint-only required fields",
      {
        given: {
          allOf: [
            { $ref: "#/components/schemas/ShiftPayload" },
            {
              type: "object",
              required: ["end_at", "job_id", "start_at"]
            },
          ],
        },
        want: `WithRequired<components["schemas"]["ShiftPayload"], "end_at" | "job_id" | "start_at">`,
        options: {
          ...DEFAULT_OPTIONS,
          ctx: {
            ...DEFAULT_OPTIONS.ctx,
            resolve($ref) {
              switch ($ref) {
                case "#/components/schemas/ShiftPayload": {
                  return {
                    type: "object",
                    properties: {
                      end_at: { type: "string", format: "date-time" },
                      job_id: { type: "integer" },
                      start_at: { type: "string", format: "date-time" }
                    }
                  }
                }
                default: {
                  return undefined as any;
                }
              }
            }
          }
        }
      }
    ],

Failing test

AssertionError: expected 'components["schemas"]["ShiftPayload"]…' to be 'WithRequired<components["schemas"]["S…' // Object.is equality

- Expected
+ Received

- WithRequired<components["schemas"]["ShiftPayload"], "end_at" | "job_id" | "start_at">
+ components["schemas"]["ShiftPayload"] & Record<string, never>


 ❯ test/transform/schema-object/composition.test.ts:663:26
    661|           await expect(result).toMatchFileSnapshot(fileURLToPath(want));
    662|         } else {
    663|           expect(result).toBe(`${want}\n`);
       |                          ^
    664|         }
    665|       },

Tests with new changes:

 FAIL  test/node-api.test.ts > Node.js API > snapshot > DigitalOcean
Error: Snapshot `Node.js API > snapshot > DigitalOcean 1` mismatched

- Expected
+ Received

@@ -12927,11 +12927,11 @@
               * @description discriminator enum property added by openapi-typescript
               * @enum {string}
               */
              type: "assign";
          };
-         floating_ip_action_unassign: Omit<components["schemas"]["floatingIPsAction"], "type"> & Record<string, never> & {
+         floating_ip_action_unassign: Omit<WithRequired<components["schemas"]["floatingIPsAction"], "type">, "type"> & {
              /**
               * @description discriminator enum property added by openapi-typescript
               * @enum {string}
               */
              type: "unassign";
@@ -14895,11 +14895,11 @@
               * @description discriminator enum property added by openapi-typescript
               * @enum {string}
               */
              type: "assign";
          };
-         reserved_ip_action_unassign: Omit<components["schemas"]["reserved_ip_action_type"], "type"> & Record<string, never> & {
+         reserved_ip_action_unassign: Omit<WithRequired<components["schemas"]["reserved_ip_action_type"], "type">, "type"> & {
              /**
               * @description discriminator enum property added by openapi-typescript
               * @enum {string}
               */
              type: "unassign";

 ❯ test/node-api.test.ts:1474:11
    1472|         const result = astToString(await openapiTS(given, options));
    1473|         if (want instanceof URL) {
    1474|           await expect(`${COMMENT_HEADER}${result}`).toMatchFileSnapshot(fileURLToPath(want));
       |           ^
    1475|         } else {
    1476|           expect(result).toBe(`${want}\n`);

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[1/1]⎯


  Snapshots  1 failed
 Test Files  1 failed | 24 passed (25)
      Tests  1 failed | 269 passed (270)
   Start at  10:26:39
   Duration  14.55s (transform 477ms, setup 0ms, collect 12.54s, tests 23.44s, environment 2ms, prepare 1.76s)

test/node-api.test.ts > Node.js API > snapshot > DigitalOcean fails but it looks like the actual type composition is still correct.

Related to this issue: #1520