Merge pull request #1759 from Gijsdeman/master

fix: spread assignments

Author: WoH

packages/cli/src/metadataGeneration/initializer-value.ts

@@ -4,6 +4,7 @@ import { Tsoa } from '@tsoa/runtime';
 const hasInitializer = (node: ts.Node): node is ts.HasInitializer => Object.prototype.hasOwnProperty.call(node, 'initializer');
 const extractInitializer = (decl?: ts.Declaration) => (decl && hasInitializer(decl) && (decl.initializer as ts.Expression)) || undefined;
 const extractImportSpecifier = (symbol?: ts.Symbol) => (symbol?.declarations && symbol.declarations.length > 0 && ts.isImportSpecifier(symbol.declarations[0]) && symbol.declarations[0]) || undefined;
+const isIterable = (obj: any): obj is Iterable<any> => obj != null && typeof obj[Symbol.iterator] === 'function';
 
 export type InitializerValue = string | number | boolean | undefined | null | InitializerValue[];
 export type DefinedInitializerValue = string | number | boolean | null | DefinedInitializerValue[];
@@ -23,7 +24,19 @@ export function getInitializerValue(initializer?: ts.Expression | ts.ImportSpeci
   switch (initializer.kind) {
     case ts.SyntaxKind.ArrayLiteralExpression: {
       const arrayLiteral = initializer as ts.ArrayLiteralExpression;
-      return arrayLiteral.elements.map(element => getInitializerValue(element, typeChecker));
+      return arrayLiteral.elements.reduce((acc, element) => {
+        if (ts.isSpreadElement(element)) {
+          const spreadValue = getInitializerValue(element.expression, typeChecker);
+          if (spreadValue && isIterable(spreadValue)) {
+            return acc.concat(...spreadValue);
+          } else {
+            throw new Error(`${typeof spreadValue} is not iterable`);
+          }
+        } else {
+          acc.push(getInitializerValue(element, typeChecker));
+        }
+        return acc;
+      }, [] as InitializerValue[]);
     }
     case ts.SyntaxKind.StringLiteral:
     case ts.SyntaxKind.NoSubstitutionTemplateLiteral:
@@ -73,7 +86,18 @@ export function getInitializerValue(initializer?: ts.Expression | ts.ImportSpeci
       const objectLiteral = initializer as ts.ObjectLiteralExpression;
       const nestedObject: any = {};
       objectLiteral.properties.forEach((p: any) => {
-        nestedObject[p.name.text] = getInitializerValue(p.initializer, typeChecker);
+        if (ts.isSpreadAssignment(p)) {
+          const spreadValue = getInitializerValue(p.expression, typeChecker);
+          if (spreadValue) {
+            if (typeof spreadValue === 'object') {
+              Object.assign(nestedObject, spreadValue);
+            } else {
+              throw new Error(`Spread types may only be created from object types.`);
+            }
+          }
+        } else {
+          nestedObject[p.name.text] = getInitializerValue(p.initializer, typeChecker);
+        }
       });
       return nestedObject;
     }

tests/fixtures/controllers/methodController.ts

@@ -169,6 +169,11 @@ export class MethodController extends Controller {
   @Extension('x-attKey7', { test: ['testVal', 123, true, null] })
   @Extension('x-attKey8', { test: { testArray: ['testVal1', true, null, ['testVal2', 'testVal3', 123, true, null]] } })
   @Extension(ATT_KEY9, 'identifierAttValue')
+  @Extension('x-attKey10', ['testVal1', ...['testVal2', 123, true, null]])
+  @Extension('x-attKey11', ['testVal1', ...'val'])
+  @Extension('x-attKey12', { ...[1, 2, 3, 4] })
+  @Extension('x-attKey13', { ...['testVal1', 123, true, null] })
+  @Extension('x-attKey14', { ...{ y0: 'yt0', y1: 'yt1', y2: 123, y3: true, y4: null } })
   @Get('Extension')
   public async extension(): Promise<TestModel> {
     return new ModelService().getModel();

tests/unit/swagger/definitionsGeneration/metadata.spec.ts

@@ -321,6 +321,11 @@ describe('Metadata generation', () => {
         { key: 'x-attKey7', value: { test: ['testVal', 123, true, null] } },
         { key: 'x-attKey8', value: { test: { testArray: ['testVal1', true, null, ['testVal2', 'testVal3', 123, true, null]] } } },
         { key: 'x-attKey9', value: 'identifierAttValue' },
+        { key: 'x-attKey10', value: ['testVal1', 'testVal2', 123, true, null] },
+        { key: 'x-attKey11', value: ['testVal1', 'v', 'a', 'l'] },
+        { key: 'x-attKey12', value: { '0': 1, '1': 2, '2': 3, '3': 4 } },
+        { key: 'x-attKey13', value: { '0': 'testVal1', '1': 123, '2': true, '3': null } },
+        { key: 'x-attKey14', value: { y0: 'yt0', y1: 'yt1', y2: 123, y3: true, y4: null } },
       ];
 
       expect(method.extensions).to.deep.equal(expectedExtensions);

tests/unit/swagger/schemaDetails.spec.ts

@@ -701,6 +701,11 @@ describe('Schema details generation', () => {
     expect(extensionPath).to.have.property('x-attKey6');
     expect(extensionPath).to.have.property('x-attKey7');
     expect(extensionPath).to.have.property('x-attKey8');
+    expect(extensionPath).to.have.property('x-attKey10');
+    expect(extensionPath).to.have.property('x-attKey11');
+    expect(extensionPath).to.have.property('x-attKey12');
+    expect(extensionPath).to.have.property('x-attKey13');
+    expect(extensionPath).to.have.property('x-attKey14');
 
     // Verify that extensions have correct values
     expect(extensionPath['x-attKey']).to.deep.equal('attValue');
@@ -712,6 +717,11 @@ describe('Schema details generation', () => {
     expect(extensionPath['x-attKey6']).to.deep.equal([{ y0: 'yt0', y1: 'yt1', y2: 123, y3: true, y4: null }, { y2: 'yt2' }]);
     expect(extensionPath['x-attKey7']).to.deep.equal({ test: ['testVal', 123, true, null] });
     expect(extensionPath['x-attKey8']).to.deep.equal({ test: { testArray: ['testVal1', true, null, ['testVal2', 'testVal3', 123, true, null]] } });
+    expect(extensionPath['x-attKey10']).to.deep.equal(['testVal1', 'testVal2', 123, true, null]);
+    expect(extensionPath['x-attKey11']).to.deep.equal(['testVal1', 'v', 'a', 'l']);
+    expect(extensionPath['x-attKey12']).to.deep.equal({ '0': 1, '1': 2, '2': 3, '3': 4 });
+    expect(extensionPath['x-attKey13']).to.deep.equal({ '0': 'testVal1', '1': 123, '2': true, '3': null });
+    expect(extensionPath['x-attKey14']).to.deep.equal({ y0: 'yt0', y1: 'yt1', y2: 123, y3: true, y4: null });
   });
 
   describe('@Res responses', () => {