Add an I/O type union generator

Author: jeskew

packages/service-types-generator/src/Components/Type/Union.spec.ts

@@ -0,0 +1,31 @@
+import {Union} from './Union';
+
+describe('Union', () => {
+    it('should import the shapes provided to the constructor', () => {
+        const union = new Union(
+            ['Foo', 'Bar', 'Baz', 'Quux'],
+            'MyUnion'
+        );
+
+        expect(union.toString()).toMatch(
+`import {Foo} from './Foo';
+import {Bar} from './Bar';
+import {Baz} from './Baz';
+import {Quux} from './Quux';`
+        );
+    });
+
+    it('should export a type union of all shapes provided to the constructor', () => {
+        const union = new Union(
+            ['Foo', 'Bar', 'Baz', 'Quux'],
+            'MyUnion'
+        );
+
+        expect(union.toString()).toMatch(
+`export type MyUnion = Foo |
+    Bar |
+    Baz |
+    Quux;`
+        );
+    });
+});

packages/service-types-generator/src/Components/Type/Union.ts

@@ -0,0 +1,21 @@
+import {Import} from '../Import';
+
+export class Union {
+    constructor(
+        private readonly constituentShapeNames: Array<string>,
+        private readonly typeName: string
+    ) {}
+
+    toString(): string {
+        return `${this.imports}
+
+export type ${this.typeName} = ${this.constituentShapeNames.join(' |\n    ')};
+`;
+    }
+
+    protected get imports(): string {
+        return this.constituentShapeNames
+            .map(shape => new Import(`./${shape}`, shape))
+            .join('\n');
+    }
+}

packages/service-types-generator/src/Components/Type/index.ts

@@ -5,4 +5,5 @@ export * from './getStringDeclaration';
 export * from './Input';
 export * from './ModeledStructure';
 export * from './Output';
-export * from './Structure';
+export * from './Structure';
+export * from './Union';

packages/service-types-generator/src/TypeGenerator.spec.ts

@@ -20,4 +20,28 @@ describe('TypeGenerator', () => {
                 .length
         ).toBe(0);
     });
+
+    it('should yield a union of the input types defined in the model', () => {
+        let found = false;
+        for (const [fileName, content] of new TypeGenerator(model)) {
+            if (fileName === 'InputTypesUnion') {
+                found = true;
+                expect(content).toMatch('export type InputTypesUnion = ');
+            }
+        }
+
+        expect(found).toBe(true);
+    });
+
+    it('should yield a union of the output types defined in the model', () => {
+        let found = false;
+        for (const [fileName, content] of new TypeGenerator(model)) {
+            if (fileName === 'OutputTypesUnion') {
+                found = true;
+                expect(content).toMatch('export type OutputTypesUnion = ');
+            }
+        }
+
+        expect(found).toBe(true);
+    });
 });

packages/service-types-generator/src/TypeGenerator.ts

@@ -3,23 +3,31 @@ import {
     Input,
     ModeledStructure,
     Output,
+    Union,
 } from "./Components/Type";
 import {TreeModel} from "@aws/build-types";
 
 export class TypeGenerator {
     constructor(private readonly model: TreeModel) {}
 
     *[Symbol.iterator](): Iterator<[string, string]> {
+        const ioShapes: {[key: string]: Array<string>} = {
+            InputTypesUnion: [],
+            OutputTypesUnion: [],
+        };
         const {shapes} = this.model;
+
         for (let shapeName of Object.keys(shapes)) {
             const shape = shapes[shapeName];
             if (shape.type === 'structure') {
                 if (shape.topLevel === 'input') {
+                    ioShapes.InputTypesUnion.push(shapeName);
                     yield [
                         shapeName,
                         new Input(shape).toString(),
                     ];
                 } else if (shape.topLevel === 'output') {
+                    ioShapes.OutputTypesUnion.push(shapeName);
                     yield [
                         shapeName,
                         new Output(shape).toString(),
@@ -37,5 +45,9 @@ export class TypeGenerator {
                 }
             }
         }
+
+        for (const name of Object.keys(ioShapes)) {
+            yield [name, new Union(ioShapes[name], name).toString()];
+        }
     }
 }