fix(template): support printing exact arrays

rollup.config.mjs

@@ -37,6 +37,7 @@ const handlebarsPlugin = () => ({
                     escapeDescription: true,
                     escapeEnumName: true,
                     escapeNewline: true,
+                    exactArray: true,
                     ifdef: true,
                     ifOperationDataOptional: true,
                     intersection: true,

src/openApi/v3/parser/getModel.ts

@@ -92,7 +92,16 @@ export const getModel = (
             }
         }
 
-        const arrayItems = getModel(openApi, definition.items);
+        /**
+         * if items are a plain array, infer any-of composition
+         * {@link} https://github.com/ferdikoomen/openapi-typescript-codegen/issues/2062
+         */
+        const arrayItemsDefinition: OpenApiSchema = Array.isArray(definition.items)
+            ? {
+                  anyOf: definition.items,
+              }
+            : definition.items;
+        const arrayItems = getModel(openApi, arrayItemsDefinition);
         model.base = arrayItems.base;
         model.export = 'array';
         model.imports.push(...arrayItems.imports);

src/templates/partials/typeArray.hbs

@@ -1,5 +1,9 @@
+{{~#exactArray this}}
+[{{>type link filterProperties="exact"}}]{{>isNullable}}
+{{~else~}}
 {{~#if link~}}
 Array<{{>type link}}>{{>isNullable}}
 {{~else~}}
 Array<{{>base}}>{{>isNullable}}
 {{~/if~}}
+{{~/exactArray~}}

src/templates/partials/typeUnion.hbs

@@ -1 +1 @@
-{{#union properties parent}}{{this}}{{/union}}{{>isNullable}}
+{{#union properties parent filterProperties}}{{this}}{{/union}}{{>isNullable}}

src/utils/registerHandlebarHelpers.spec.ts → src/utils/__tests__/registerHandlebarHelpers.spec.ts

@@ -1,7 +1,7 @@
 import Handlebars from 'handlebars/runtime';
 
-import { HttpClient } from '../HttpClient';
-import { registerHandlebarHelpers } from './registerHandlebarHelpers';
+import { HttpClient } from '../../HttpClient';
+import { registerHandlebarHelpers } from '../registerHandlebarHelpers';
 
 describe('registerHandlebarHelpers', () => {
     it('should register the helpers', () => {
@@ -20,6 +20,7 @@ describe('registerHandlebarHelpers', () => {
         expect(helpers).toContain('escapeDescription');
         expect(helpers).toContain('escapeEnumName');
         expect(helpers).toContain('escapeNewline');
+        expect(helpers).toContain('exactArray');
         expect(helpers).toContain('ifdef');
         expect(helpers).toContain('ifOperationDataOptional');
         expect(helpers).toContain('intersection');

src/utils/registerHandlebarHelpers.ts

@@ -85,6 +85,13 @@ export const registerHandlebarHelpers = (
         return value.replace(/\n/g, '\\n');
     });
 
+    Handlebars.registerHelper('exactArray', function (this: any, model: Model, options: Handlebars.HelperOptions) {
+        if (model.export === 'array' && model.maxItems && model.minItems && model.maxItems === model.minItems) {
+            return options.fn(this);
+        }
+        return options.inverse(this);
+    });
+
     Handlebars.registerHelper('ifdef', function (this: any, ...args): string {
         const options = args.pop();
         if (!args.every(value => !value)) {
@@ -127,15 +134,22 @@ export const registerHandlebarHelpers = (
 
     Handlebars.registerHelper(
         'union',
-        function (this: any, properties: Model[], parent: string | undefined, options: Handlebars.HelperOptions) {
+        function (
+            this: any,
+            properties: Model[],
+            parent: string | undefined,
+            filterProperties: 'exact' | undefined,
+            options: Handlebars.HelperOptions
+        ) {
             const type = Handlebars.partials['type'];
-            const types = properties.map(property => type({ ...root, ...property, parent }));
-            const uniqueTypes = types.filter(unique);
-            let uniqueTypesString = uniqueTypes.join(' | ');
-            if (uniqueTypes.length > 1) {
-                uniqueTypesString = `(${uniqueTypesString})`;
+            const types = properties
+                .map(property => type({ ...root, ...property, parent }))
+                .filter((...args) => filterProperties === 'exact' || unique(...args));
+            let output = types.join(' | ');
+            if (types.length > 1 && types.length !== properties.length) {
+                output = `(${output})`;
             }
-            return options.fn(uniqueTypesString);
+            return options.fn(output);
         }
     );