Always checks for required properties, even if they are missing from properties (#620)

* Always checks for required properties, even if they are missing from properties

* Fix based on comments

Author: shuluster

src/transform/schema.ts

@@ -37,6 +37,19 @@ export function transformSchemaObjMap(obj: Record<string, any>, options: Transfo
   return output.replace(/\n+$/, "\n"); // replace repeat line endings with only one
 }
 
+/** make sure all required fields exist **/
+export function addRequiredProps(properties: Record<string, any>, required: Set<string>): string[] {
+  const missingRequired = [...required].filter((r: string) => !(r in properties));
+  if (missingRequired.length == 0) {
+    return [];
+  }
+  let output = "";
+  for (const r of missingRequired) {
+    output += `${r}: unknown;\n`;
+  }
+  return [`{\n${output}}`];
+}
+
 /** transform anyOf */
 export function transformAnyOf(anyOf: any, options: TransformSchemaObjOptions): string {
   // filter out anyOf keys that only have a `required` key. #642
@@ -99,14 +112,16 @@ export function transformSchemaObj(node: any, options: TransformSchemaObjOptions
       }
       case "object": {
         const isAnyOfOrOneOfOrAllOf = "anyOf" in node || "oneOf" in node || "allOf" in node;
-
+        const missingRequired = addRequiredProps(node.properties || {}, node.required || []);
         // if empty object, then return generic map type
         if (
           !isAnyOfOrOneOfOrAllOf &&
           (!node.properties || !Object.keys(node.properties).length) &&
           !node.additionalProperties
         ) {
-          output += `{ ${readonly}[key: string]: any }`;
+          const emptyObj = `{ ${readonly}[key: string]: unknown }`;
+
+          output += tsIntersectionOf([emptyObj, ...missingRequired]);
           break;
         }
 
@@ -144,6 +159,7 @@ export function transformSchemaObj(node: any, options: TransformSchemaObjOptions
           ...(node.anyOf ? [transformAnyOf(node.anyOf, options)] : []),
           ...(node.oneOf ? [transformOneOf(node.oneOf, options)] : []),
           ...(properties ? [`{\n${properties}\n}`] : []), // then properties (line breaks are important!)
+          ...missingRequired, // add required that are missing from properties
           ...(additionalProperties ? [additionalProperties] : []), // then additional properties
         ]);
 

tests/schema.test.ts

@@ -55,10 +55,10 @@ describe("SchemaObject", () => {
       );
 
       // unknown
-      expect(transform(objUnknown, { ...defaults })).toBe(`{ [key: string]: any }`);
+      expect(transform(objUnknown, { ...defaults })).toBe(`{ [key: string]: unknown }`);
 
       // empty
-      expect(transform({}, { ...defaults })).toBe(`{ [key: string]: any }`);
+      expect(transform({}, { ...defaults })).toBe(`{ [key: string]: unknown }`);
 
       // nullable
       expect(transform(objNullable, { ...defaults })).toBe(`({\n"string"?: string;\n\n}) | null`);
@@ -73,8 +73,8 @@ describe("SchemaObject", () => {
       expect(transform(objStd, opts)).toBe(
         `{\nreadonly "object"?: {\nreadonly "string"?: string;\nreadonly "number"?: components["schemas"]["object_ref"];\n\n};\n\n}`
       );
-      expect(transform(objUnknown, opts)).toBe(`{ readonly [key: string]: any }`);
-      expect(transform({}, opts)).toBe(`{ readonly [key: string]: any }`);
+      expect(transform(objUnknown, opts)).toBe(`{ readonly [key: string]: unknown }`);
+      expect(transform({}, opts)).toBe(`{ readonly [key: string]: unknown }`);
       expect(transform(objNullable, opts)).toBe(`({\nreadonly "string"?: string;\n\n}) | null`);
       expect(transform(objRequired, opts)).toBe(`{\nreadonly "required": string;\nreadonly "optional"?: boolean;\n\n}`);
     });
@@ -368,6 +368,39 @@ describe("SchemaObject", () => {
         }"
       `);
     });
+    it("empty object with required fields", () => {
+      expect(
+        transform(
+          {
+            type: "object",
+            required: ["abc"],
+          },
+          { ...defaults }
+        )
+      ).toBe(`({ [key: string]: unknown }) & ({
+abc: unknown;
+})`);
+    });
+  });
+
+  it("object with missing required fields", () => {
+    expect(
+      transform(
+        {
+          type: "object",
+          required: ["abc", "email"],
+          properties: {
+            email: { type: "string" },
+          },
+        },
+        { ...defaults }
+      )
+    ).toBe(`({
+"email": string;
+
+}) & ({
+abc: unknown;
+})`);
   });
 
   describe("comments", () => {

tests/v2/expected/petstore.immutable.ts

@@ -235,7 +235,7 @@ export interface operations {
         /** Additional data to pass to server */
         readonly additionalMetadata?: string;
         /** file to upload */
-        readonly file?: { readonly [key: string]: any };
+        readonly file?: { readonly [key: string]: unknown };
       };
     };
     readonly responses: {

tests/v2/expected/petstore.ts

@@ -235,7 +235,7 @@ export interface operations {
         /** Additional data to pass to server */
         additionalMetadata?: string;
         /** file to upload */
-        file?: { [key: string]: any };
+        file?: { [key: string]: unknown };
       };
     };
     responses: {