Supports minItems / maxItems

fix #871

Author: kgtkr

bin/cli.js

@@ -42,7 +42,7 @@ function errorAndExit(errorMessage) {
 const [, , input, ...args] = process.argv;
 const flags = parser(args, {
   array: ["header"],
-  boolean: ["defaultNonNullable", "immutableTypes", "rawSchema", "exportType"],
+  boolean: ["defaultNonNullable", "immutableTypes", "rawSchema", "exportType", "supportArrayLength"],
   number: ["version"],
   string: ["auth", "header", "headersObject", "httpMethod", "prettierConfig"],
   alias: {
@@ -92,6 +92,7 @@ async function generateSchema(pathToSpec) {
     httpHeaders,
     httpMethod: flags.httpMethod,
     exportType: flags.exportType,
+    supportArrayLength: flags.supportArrayLength,
   });
 
   // output

src/index.ts

@@ -41,6 +41,7 @@ async function openapiTS(
     immutableTypes: options.immutableTypes || false,
     rawSchema: options.rawSchema || false,
     version: options.version || 3,
+    supportArrayLength: options.supportArrayLength,
   } as any;
 
   // note: we may be loading many large schemas into memory at once; take care to reuse references without cloning

src/transform/schema.ts

@@ -189,7 +189,31 @@ export function transformSchemaObj(node: any, options: TransformSchemaObjOptions
         if (Array.isArray(node.items)) {
           output += `${readonly}${tsTupleOf(node.items.map((node: any) => transformSchemaObj(node, options)))}`;
         } else {
-          output += `${readonly}${tsArrayOf(node.items ? transformSchemaObj(node.items as any, options) : "unknown")}`;
+          const minItems: number = Number.isInteger(node.minItems) && node.minItems >= 0 ? node.minItems : 0;
+          const maxItems: number | undefined =
+            Number.isInteger(node.maxItems) && node.maxItems >= 0 && minItems <= node.maxItems
+              ? node.maxItems
+              : undefined;
+
+          const estimateCodeSize =
+            maxItems === undefined ? minItems : (maxItems * (maxItems + 1) - minItems * (minItems - 1)) / 2;
+          const items = node.items ? transformSchemaObj(node.items as any, options) : "unknown";
+          if ((minItems !== 0 || maxItems !== undefined) && options.supportArrayLength && estimateCodeSize < 30) {
+            if (maxItems === undefined) {
+              output += `${readonly}${tsTupleOf([
+                ...Array.from({ length: minItems }).map(() => items),
+                `...${tsArrayOf(items)}`,
+              ])}`;
+            } else {
+              output += tsUnionOf(
+                Array.from({ length: maxItems - minItems + 1 })
+                  .map((_, i) => i + minItems)
+                  .map((n) => `${readonly}${tsTupleOf(Array.from({ length: n }).map(() => items))}`)
+              );
+            }
+          } else {
+            output += `${readonly}${tsArrayOf(items)}`;
+          }
         }
         break;
       }

src/types.ts

@@ -155,6 +155,7 @@ export interface SwaggerToTSOptions {
    * (optional) Export type instead of interface
    */
   exportType?: boolean;
+  supportArrayLength?: boolean;
 }
 
 /** Context passed to all submodules */
@@ -169,4 +170,5 @@ export interface GlobalContext {
   namespace?: string;
   rawSchema: boolean;
   version: number;
+  supportArrayLength?: boolean;
 }

test/core/schema.test.js

@@ -11,6 +11,7 @@ const defaults = {
   required: new Set(),
   rawSchema: false,
   version: 3,
+  supportArrayLength: false,
 };
 
 describe("SchemaObject", () => {
@@ -150,6 +151,34 @@ describe("SchemaObject", () => {
       );
     });
 
+    it("array (supportArrayLength)", () => {
+      // (same as above test, but with supportArrayLength: true)
+      const opts = { ...defaults, supportArrayLength: true };
+      expect(transform({ type: "array", items: { type: "string" } }, opts)).to.equal(`(string)[]`);
+      expect(transform({ type: "array", items: { type: "string" }, minItems: 1 }, opts)).to.equal(
+        `[string, ...(string)[]]`
+      );
+      expect(transform({ type: "array", items: { type: "string" }, maxItems: 2 }, opts)).to.equal(
+        `([]) | ([string]) | ([string, string])`
+      );
+      expect(transform({ type: "array", items: { type: "string" }, maxItems: 20 }, opts)).to.equal(`(string)[]`);
+    });
+
+    it("array (immutableTypes, supportArrayLength)", () => {
+      // (same as above test, but with immutableTypes: true, supportArrayLength: true)
+      const opts = { ...defaults, immutableTypes: true, supportArrayLength: true };
+      expect(transform({ type: "array", items: { type: "string" } }, opts)).to.equal(`readonly (string)[]`);
+      expect(transform({ type: "array", items: { type: "string" }, minItems: 1 }, opts)).to.equal(
+        `readonly [string, ...(string)[]]`
+      );
+      expect(transform({ type: "array", items: { type: "string" }, maxItems: 2 }, opts)).to.equal(
+        `(readonly []) | (readonly [string]) | (readonly [string, string])`
+      );
+      expect(transform({ type: "array", items: { type: "string" }, maxItems: 20 }, opts)).to.equal(
+        `readonly (string)[]`
+      );
+    });
+
     it("enum", () => {
       const enumBasic = ["Totoro", "Sats'uki", "Mei"]; // note: also tests quotes in enum
       expect(