Fix prefixItems / minItems / maxItems tuple generation (openapi-ts#2053)

* Simplify minItems / maxItems tuple generation

Closes openapi-ts#2048

Author: duncanbeevers

.changeset/clean-phones-deliver.md

@@ -0,0 +1,11 @@
+---
+"openapi-typescript": major
+---
+
+Extract types generation for Array-type schemas to `transformArraySchemaObject` method.
+Throw error when OpenAPI `items` is array.
+Generate correct number of union members for `minItems` * `maxItems` unions.
+Generate readonly tuple members for `minItems` & `maxItems` unions.
+Generate readonly spread member for `prefixItems` tuple.
+Preserve `prefixItems` type members in `minItems` & `maxItems` tuples.
+Generate spread member for `prefixItems` tuple with no `minItems` / `maxItems` constraints.

packages/openapi-typescript/package.json

@@ -68,6 +68,7 @@
     "yargs-parser": "^21.1.1"
   },
   "devDependencies": {
+    "@total-typescript/ts-reset": "^0.6.1",
     "@types/degit": "^2.8.6",
     "@types/js-yaml": "^4.0.9",
     "degit": "^2.8.4",

packages/openapi-typescript/src/reset.ts

@@ -0,0 +1,2 @@
+// Do not add any other lines of code to this file!
+import "@total-typescript/ts-reset";

packages/openapi-typescript/src/transform/schema-object.ts

@@ -25,7 +25,7 @@ import {
   tsWithRequired,
 } from "../lib/ts.js";
 import { createDiscriminatorProperty, createRef, getEntries } from "../lib/utils.js";
-import type { ReferenceObject, SchemaObject, TransformNodeOptions } from "../types.js";
+import type { ArraySubtype, ReferenceObject, SchemaObject, TransformNodeOptions } from "../types.js";
 
 /**
  * Transform SchemaObject nodes (4.8.24)
@@ -273,6 +273,96 @@ export function transformSchemaObjectWithComposition(
   return finalType;
 }
 
+type ArraySchemaObject = SchemaObject & ArraySubtype;
+function isArraySchemaObject(schemaObject: SchemaObject | ArraySchemaObject): schemaObject is ArraySchemaObject {
+  return schemaObject.type === "array";
+}
+
+/**
+ * Pad out the end of tuple members with item item
+ * @param prefixTypes The array before any padding occurs
+ * @param length The length of the returned array
+ * @param itemType The type to pad out the end of the array with
+ */
+function padTupleMembers(prefixTypes: readonly ts.TypeNode[], length: number, itemType: ts.TypeNode) {
+  return Array.from({ length }).map((_, index) =>
+    index < prefixTypes.length ? prefixTypes[index] : itemType
+  );
+}
+
+function toOptionsReadonly<TMembers extends ts.ArrayTypeNode | ts.TupleTypeNode>(
+  members: TMembers,
+  options: TransformNodeOptions,
+): TMembers | ts.TypeOperatorNode {
+  return options.ctx.immutable ? ts.factory.createTypeOperatorNode(ts.SyntaxKind.ReadonlyKeyword, members) : members;
+}
+
+/* Transform Array schema object */
+function transformArraySchemaObject(
+  schemaObject: ArraySchemaObject,
+  options: TransformNodeOptions,
+): ts.TypeNode | undefined {
+  const prefixTypes = (schemaObject.prefixItems ?? []).map((item) => transformSchemaObject(item, options));
+
+  if (Array.isArray(schemaObject.items)) {
+    return ts.factory.createTupleTypeNode(
+      schemaObject.items.map((tupleItem) => transformSchemaObject(tupleItem, options)),
+    );
+  }
+
+  const itemType =
+    // @ts-expect-error TS2367
+    schemaObject.items === false
+      ? undefined
+      : schemaObject.items
+        ? transformSchemaObject(schemaObject.items, options)
+        : UNKNOWN;
+
+  // The minimum number of tuple members in the return value
+  const min: number =
+    options.ctx.arrayLength && typeof schemaObject.minItems === "number" && schemaObject.minItems >= 0
+      ? schemaObject.minItems
+      : 0;
+  const max: number | undefined =
+    options.ctx.arrayLength &&
+    typeof schemaObject.maxItems === "number" &&
+    schemaObject.maxItems >= 0 &&
+    min <= schemaObject.maxItems
+      ? schemaObject.maxItems
+      : undefined;
+
+  // "30" is an arbitrary number but roughly around when TS starts to struggle with tuple inference in practice
+  const MAX_CODE_SIZE = 30;
+  const estimateCodeSize = max === undefined ? min : (max * (max + 1) - min * (min - 1)) / 2;
+  const shouldGeneratePermutations = (min !== 0 || max !== undefined) && estimateCodeSize < MAX_CODE_SIZE;
+
+  // if maxItems is set, then return a union of all permutations of possible tuple types
+  if (shouldGeneratePermutations && max !== undefined && itemType) {
+    return tsUnion(
+      Array.from({ length: max - min + 1 }).map((_, index) => {
+        return toOptionsReadonly(
+          ts.factory.createTupleTypeNode(padTupleMembers(prefixTypes, index + min, itemType)),
+          options,
+        );
+      }),
+    );
+  }
+
+  // if maxItems not set, then return a simple tuple type the length of `min`
+  const spreadType = itemType ? ts.factory.createArrayTypeNode(itemType) : undefined;
+  const tupleType =
+    shouldGeneratePermutations || prefixTypes.length
+      ? ts.factory.createTupleTypeNode(
+          [
+            ...(itemType ? padTupleMembers(prefixTypes, Math.max(min, prefixTypes.length), itemType) : prefixTypes),
+            spreadType ? ts.factory.createRestTypeNode(toOptionsReadonly(spreadType, options)) : undefined,
+          ].filter(Boolean),
+        )
+      : spreadType;
+
+  return tupleType ? toOptionsReadonly(tupleType, options) : undefined;
+}
+
 /**
  * Handle SchemaObject minus composition (anyOf/allOf/oneOf)
  */
@@ -312,73 +402,8 @@ function transformSchemaObjectCore(schemaObject: SchemaObject, options: Transfor
     }
 
     // type: array (with support for tuples)
-    if (schemaObject.type === "array") {
-      // default to `unknown[]`
-      let itemType: ts.TypeNode = UNKNOWN;
-      // tuple type
-      if (schemaObject.prefixItems || Array.isArray(schemaObject.items)) {
-        const prefixItems = schemaObject.prefixItems ?? (schemaObject.items as (SchemaObject | ReferenceObject)[]);
-        itemType = ts.factory.createTupleTypeNode(prefixItems.map((item) => transformSchemaObject(item, options)));
-      }
-      // standard array type
-      else if (schemaObject.items) {
-        if ("type" in schemaObject.items && schemaObject.items.type === "array") {
-          itemType = ts.factory.createArrayTypeNode(transformSchemaObject(schemaObject.items, options));
-        } else {
-          itemType = transformSchemaObject(schemaObject.items, options);
-        }
-      }
-
-      const min: number =
-        typeof schemaObject.minItems === "number" && schemaObject.minItems >= 0 ? schemaObject.minItems : 0;
-      const max: number | undefined =
-        typeof schemaObject.maxItems === "number" && schemaObject.maxItems >= 0 && min <= schemaObject.maxItems
-          ? schemaObject.maxItems
-          : undefined;
-      const estimateCodeSize = typeof max !== "number" ? min : (max * (max + 1) - min * (min - 1)) / 2;
-      if (
-        options.ctx.arrayLength &&
-        (min !== 0 || max !== undefined) &&
-        estimateCodeSize < 30 // "30" is an arbitrary number but roughly around when TS starts to struggle with tuple inference in practice
-      ) {
-        if (min === max) {
-          const elements: ts.TypeNode[] = [];
-          for (let i = 0; i < min; i++) {
-            elements.push(itemType);
-          }
-          return tsUnion([ts.factory.createTupleTypeNode(elements)]);
-        } else if ((schemaObject.maxItems as number) > 0) {
-          // if maxItems is set, then return a union of all permutations of possible tuple types
-          const members: ts.TypeNode[] = [];
-          // populate 1 short of min …
-          for (let i = 0; i <= (max ?? 0) - min; i++) {
-            const elements: ts.TypeNode[] = [];
-            for (let j = min; j < i + min; j++) {
-              elements.push(itemType);
-            }
-            members.push(ts.factory.createTupleTypeNode(elements));
-          }
-          return tsUnion(members);
-        }
-        // if maxItems not set, then return a simple tuple type the length of `min`
-        else {
-          const elements: ts.TypeNode[] = [];
-          for (let i = 0; i < min; i++) {
-            elements.push(itemType);
-          }
-          elements.push(ts.factory.createRestTypeNode(ts.factory.createArrayTypeNode(itemType)));
-          return ts.factory.createTupleTypeNode(elements);
-        }
-      }
-
-      const finalType =
-        ts.isTupleTypeNode(itemType) || ts.isArrayTypeNode(itemType)
-          ? itemType
-          : ts.factory.createArrayTypeNode(itemType); // wrap itemType in array type, but only if not a tuple or array already
-
-      return options.ctx.immutable
-        ? ts.factory.createTypeOperatorNode(ts.SyntaxKind.ReadonlyKeyword, finalType)
-        : finalType;
+    if (isArraySchemaObject(schemaObject)) {
+      return transformArraySchemaObject(schemaObject, options);
     }
 
     // polymorphic, or 3.1 nullable

packages/openapi-typescript/test/cli.test.ts

@@ -89,24 +89,32 @@ describe("CLI", () => {
           expect(stdout).toBe(`${want}\n`);
         }
       },
-      ci?.timeout,
+      ci?.timeout
     );
   }
 
   test(
     "stdin",
     async () => {
-      const input = fs.readFileSync(new URL("./examples/stripe-api.yaml", root));
+      const input = fs.readFileSync(
+        new URL("./examples/stripe-api.yaml", root)
+      );
       const { stdout } = await execa(cmd, { input, cwd });
-      expect(stdout).toMatchFileSnapshot(fileURLToPath(new URL("./examples/stripe-api.ts", root)));
+      expect(stdout).toMatchFileSnapshot(
+        fileURLToPath(new URL("./examples/stripe-api.ts", root))
+      );
     },
-    TIMEOUT,
+    TIMEOUT
   );
 
   describe("flags", () => {
     test("--help", async () => {
       const { stdout } = await execa(cmd, ["--help"], { cwd });
-      expect(stdout).toEqual(expect.stringMatching(/^Usage\n\s+\$ openapi-typescript \[input\] \[options\]/));
+      expect(stdout).toEqual(
+        expect.stringMatching(
+          /^Usage\n\s+\$ openapi-typescript \[input\] \[options\]/
+        )
+      );
     });
 
     test("--version", async () => {
@@ -117,48 +125,70 @@ describe("CLI", () => {
     test(
       "--properties-required-by-default",
       async () => {
-        const { stdout } = await execa(cmd, ["--properties-required-by-default=true", "./examples/github-api.yaml"], {
-          cwd,
-        });
-        expect(stdout).toMatchFileSnapshot(fileURLToPath(new URL("./examples/github-api-required.ts", root)));
+        const { stdout } = await execa(
+          cmd,
+          [
+            "--properties-required-by-default=true",
+            "./examples/github-api.yaml",
+          ],
+          {
+            cwd,
+          }
+        );
+        expect(stdout).toMatchFileSnapshot(
+          fileURLToPath(new URL("./examples/github-api-required.ts", root))
+        );
       },
-      TIMEOUT,
+      TIMEOUT
     );
   });
 
-  describe("Redocly config", () => {
-    test.skipIf(os.platform() === "win32")("automatic config", async () => {
+  describe.only("Redocly config", () => {
+    describe.skipIf(os.platform() === "win32")("automatic config", () => {
       const cwd = new URL("./fixtures/redocly/", import.meta.url);
 
-      await execa("../../../bin/cli.js", {
-        cwd: fileURLToPath(cwd),
+      beforeAll(async () => {
+        await execa("../../../bin/cli.js", { cwd: fileURLToPath(cwd) });
       });
-      for (const schema of ["a", "b", "c"]) {
-        expect(fs.readFileSync(new URL(`./output/${schema}.ts`, cwd), "utf8")).toMatchFileSnapshot(
-          fileURLToPath(new URL("../../../examples/simple-example.ts", cwd)),
+
+      test.each(["a", "b", "c"])("test schema %s", (schema) => {
+        expect(
+          fs.readFileSync(new URL(`./output/${schema}.ts`, cwd), "utf8")
+        ).toMatchFileSnapshot(
+          fileURLToPath(new URL("../../../examples/simple-example.ts", cwd))
         );
-      }
+      });
     });
 
-    test("--redocly config", async () => {
-      await execa(cmd, ["--redocly", "test/fixtures/redocly-flag/redocly.yaml"], {
-        cwd,
+    describe("--redocly config", async () => {
+      beforeAll(async () => {
+        await execa(
+          cmd,
+          ["--redocly", "test/fixtures/redocly-flag/redocly.yaml"],
+          {
+            cwd,
+          }
+        );
+      });
+
+      test.each(["a", "b", "c"])("test schema %s", async (schema) => {
+        await expect(
+          fs.readFileSync(
+            new URL(`./test/fixtures/redocly-flag/output/${schema}.ts`, root),
+            "utf8"
+          )
+        ).toMatchFileSnapshot(
+          fileURLToPath(new URL("./examples/simple-example.ts", root))
+        );
       });
-      for (const schema of ["a", "b", "c"]) {
-        expect(
-          fs.readFileSync(new URL(`./test/fixtures/redocly-flag/output/${schema}.ts`, root), "utf8"),
-        ).toMatchFileSnapshot(fileURLToPath(new URL("./examples/simple-example.ts", root)));
-      }
     });
 
     test.skipIf(os.platform() === "win32")("lint error", async () => {
+      expect.assertions(1);
       const cwd = new URL("./fixtures/redocly-lint-error", import.meta.url);
 
       try {
-        await execa("../../../bin/cli.js", {
-          cwd: fileURLToPath(cwd),
-        });
-        throw new Error("Linting should have thrown an error");
+        await execa("../../../bin/cli.js", { cwd: fileURLToPath(cwd) });
       } catch (err) {
         expect(stripAnsi(String(err))).toMatch(/✘ {2}Servers must be present/);
       }

packages/openapi-typescript/test/node-api.test.ts

@@ -982,7 +982,7 @@ export type operations = Record<string, never>;`,
       async () => {
         const result = astToString(await openapiTS(given, options));
         if (want instanceof URL) {
-          expect(`${COMMENT_HEADER}${result}`).toMatchFileSnapshot(fileURLToPath(want));
+          await expect(`${COMMENT_HEADER}${result}`).toMatchFileSnapshot(fileURLToPath(want));
         } else {
           expect(result).toBe(`${want}\n`);
         }