ObjectTypeLiteral support

lukeautry · Aug 14, 2019 · ad751d8 · ad751d8
1 parent 200b887
commit ad751d8
Show file tree

Hide file tree

Showing 15 changed files with 133 additions and 8 deletions.
diff --git a/src/metadataGeneration/tsoa.ts b/src/metadataGeneration/tsoa.ts
@@ -68,7 +68,7 @@ export namespace Tsoa {
     validators: Validators;
   }
 
-  export type TypeStringLiteral = 'string' | 'boolean' | 'double' | 'float' | 'integer' | 'long' | 'enum' | 'array' | 'datetime' | 'date' | 'binary' | 'buffer' | 'byte' | 'void' | 'object' | 'any' | 'refEnum' | 'refObject';
+  export type TypeStringLiteral = 'string' | 'boolean' | 'double' | 'float' | 'integer' | 'long' | 'enum' | 'array' | 'datetime' | 'date' | 'binary' | 'buffer' | 'byte' | 'void' | 'object' | 'any' | 'refEnum' | 'refObject' | 'objectLiteral';
 
   export type RefTypeLiteral = 'refObject' | 'refEnum';
 
@@ -87,6 +87,11 @@ export namespace Tsoa {
     enums: string[];
   }
 
+  export interface ObjectLiteralType extends Type {
+    dataType: 'objectLiteral';
+    properties: Property[];
+  }
+
   export interface ArrayType extends Type {
     dataType: 'array';
     elementType: Type;

diff --git a/src/metadataGeneration/typeResolver.ts b/src/metadataGeneration/typeResolver.ts
@@ -67,7 +67,23 @@ export class TypeResolver {
     }
 
     if (this.typeNode.kind === ts.SyntaxKind.TypeLiteral) {
-      return { dataType: 'any' } as Tsoa.Type;
+      const properties = (this.typeNode as ts.TypeLiteralNode)
+        .members
+        .filter(member => member.kind === ts.SyntaxKind.PropertySignature)
+        .reduce((res, propertySignature: ts.PropertySignature) => {
+          const type = new TypeResolver(propertySignature.type as ts.TypeNode, this.current, this.typeNode).resolve();
+
+          return [
+            {
+              name: (propertySignature.name as ts.Identifier).text,
+              required: !propertySignature.questionToken,
+              type,
+            } as Tsoa.Property,
+            ...res,
+          ];
+        }, []);
+
+      return { dataType: 'objectLiteral', properties } as Tsoa.ObjectLiteralType;
     }
 
     if (this.typeNode.kind === ts.SyntaxKind.ObjectKeyword) {

diff --git a/src/swagger/specGenerator.ts b/src/swagger/specGenerator.ts
@@ -75,11 +75,36 @@ export class SpecGenerator {
         return this.getSwaggerTypeForArrayType(type as Tsoa.ArrayType);
     } else if (type.dataType === 'enum') {
         return this.getSwaggerTypeForEnumType(type as Tsoa.EnumerateType);
+    } else if (type.dataType === 'objectLiteral') {
+      return this.getSwaggerTypeForObjectLiteral(type as Tsoa.ObjectLiteralType);
     } else {
         return assertNever(type.dataType);
     }
   }
 
+  public getSwaggerTypeForObjectLiteral(objectLiteral: Tsoa.ObjectLiteralType): Swagger.Schema {
+    const properties = objectLiteral.properties.reduce((acc, property: Tsoa.Property) => {
+      return {
+        [property.name]: this.getSwaggerType(property.type),
+        ...acc,
+      };
+    }, {});
+
+    const required =
+      objectLiteral
+        .properties
+        .filter(prop => prop.required)
+        .map(prop => prop.name);
+
+    // An empty list required: [] is not valid.
+    // If all properties are optional, do not specify the required keyword.
+    return {
+      properties,
+      ...(required && required.length && {required}),
+      type: 'object',
+    };
+  }
+
   protected getSwaggerTypeForReferenceType(referenceType: Tsoa.ReferenceType): Swagger.BaseSchema {
     return {
         // Don't set additionalProperties value here since it will be set within the $ref's model when that $ref gets created

diff --git a/tests/fixtures/controllers/getController.ts b/tests/fixtures/controllers/getController.ts
@@ -40,6 +40,9 @@ export class GetTestController extends Controller {
     modelsArray: new Array<TestSubModel>(),
     numberArray: [1, 2, 3],
     numberValue: 1,
+    objLiteral: {
+      name: 'a string',
+    },
     object: {
         a: 'a',
     },

diff --git a/tests/fixtures/inversify/managedService.ts b/tests/fixtures/inversify/managedService.ts
@@ -15,6 +15,9 @@ export class ManagedService {
       modelsArray: new Array<TestSubModel>(),
       numberArray: [1, 2, 3],
       numberValue: 1,
+      objLiteral: {
+        name: 'hello',
+      },
       object: {
         a: 'a',
       },

diff --git a/tests/fixtures/services/modelService.ts b/tests/fixtures/services/modelService.ts
@@ -13,6 +13,9 @@ export class ModelService {
       modelsArray: new Array<TestSubModel>(),
       numberArray: [1, 2, 3],
       numberValue: 1,
+      objLiteral: {
+        name: 'hello',
+      },
       object: {
           a: 'a',
       },

diff --git a/tests/fixtures/testModel.ts b/tests/fixtures/testModel.ts
@@ -64,6 +64,18 @@ export interface TestModel extends Model {
   modelsEnumIndirect?: TestSubEnumModelContainer;
   typeAliasCase1?: TypeAliasModelCase1;
   TypeAliasCase2?: TypeAliasModelCase2;
+
+  objLiteral: {
+    name: string,
+    nested?: {
+      bool: boolean,
+      optional?: number,
+      allOptional: {
+        one?: string,
+        two?: string,
+      },
+    },
+  };
 }
 
 export interface TypeAliasModel1 {
@@ -316,12 +328,6 @@ export class TestClassModel extends TestClassBaseModel {
   stringProperty: string;
   protected protectedStringProperty: string;
 
-  public static typeLiterals = {
-    booleanTypeLiteral: { $type: Boolean },
-    numberTypeLiteral: { $type: Number },
-    stringTypeLiteral: { $type: String },
-  };
-
   /**
    * @param publicConstructorVar This is a description for publicConstructorVar
    */

diff --git a/tests/integration/dynamic-controllers-express-server.spec.ts b/tests/integration/dynamic-controllers-express-server.spec.ts
@@ -783,6 +783,9 @@ describe('Express Server', () => {
       },
       numberArray: [1, 2],
       numberValue: 5,
+      objLiteral: {
+        name: 'hello',
+      },
       object: { foo: 'bar' },
       objectArray: [{ foo1: 'bar1'}, { foo2: 'bar2'}],
       optionalString: 'test1234',

diff --git a/tests/integration/express-server.spec.ts b/tests/integration/express-server.spec.ts
@@ -783,6 +783,9 @@ describe('Express Server', () => {
       },
       numberArray: [1, 2],
       numberValue: 5,
+      objLiteral: {
+        name: 'hello',
+      },
       object: { foo: 'bar' },
       objectArray: [{ foo1: 'bar1'}, { foo2: 'bar2'}],
       optionalString: 'test1234',

diff --git a/tests/integration/hapi-server.spec.ts b/tests/integration/hapi-server.spec.ts
@@ -725,6 +725,9 @@ describe('Hapi Server', () => {
       },
       numberArray: [1, 2],
       numberValue: 5,
+      objLiteral: {
+        name: 'hello',
+      },
       object: { foo: 'bar' },
       objectArray: [{ foo1: 'bar1' }, { foo2: 'bar2' }],
       optionalString: 'test1234',

diff --git a/tests/integration/inversify-server.spec.ts b/tests/integration/inversify-server.spec.ts
@@ -40,6 +40,9 @@ describe('Inversify Express Server', () => {
         },
         numberArray: [1, 2, 3],
         numberValue: 1,
+        objLiteral: {
+          name: 'hello',
+        },
         object: {
             a: 'a',
         },

diff --git a/tests/integration/koa-server-no-additional-allowed.spec.ts b/tests/integration/koa-server-no-additional-allowed.spec.ts
@@ -293,6 +293,9 @@ describe('Koa Server (with noImplicitAdditionalProperties turned on)', () => {
       modelsArray: [{ email: '[email protected]', id: 1 }],
       numberArray: [1, 2],
       numberValue: 5,
+      objLiteral: {
+        name: 'hello',
+      },
       object: { foo: 'bar' },
       objectArray: [{ foo1: 'bar1' }, { foo2: 'bar2' }],
       optionalString: 'test1234',

diff --git a/tests/integration/koa-server.spec.ts b/tests/integration/koa-server.spec.ts
@@ -705,6 +705,9 @@ describe('Koa Server', () => {
       modelsArray: [{ email: '[email protected]', id: 1 }],
       numberArray: [1, 2],
       numberValue: 5,
+      objLiteral: {
+        name: 'hello',
+      },
       object: { foo: 'bar' },
       objectArray: [{ foo1: 'bar1' }, { foo2: 'bar2' }],
       optionalString: 'test1234',

diff --git a/tests/unit/swagger/definitionsGeneration/definitions.spec.ts b/tests/unit/swagger/definitionsGeneration/definitions.spec.ts
@@ -318,6 +318,29 @@ describe('Definition generation', () => {
                     expect(propertySchema).to.not.haveOwnProperty('additionalProperties', `for property ${propertyName}`);
                     expect(propertySchema['x-nullable']).to.eq(true, `for property ${propertyName}[x-nullable]`);
                 },
+                objLiteral: (propertyName, propertySchema) => {
+                    expect(propertySchema).to.deep.include({
+                      properties: {
+                        name: {
+                          type: 'string',
+                        },
+                        nested: {
+                          properties: {
+                            allOptional: {
+                              properties: { one: { type: 'string' }, two: { type: 'string' } },
+                              type: 'object',
+                            },
+                            bool: { type: 'boolean' },
+                            optional: { format: 'double', type: 'number'},
+                          },
+                          required: ['allOptional', 'bool'],
+                          type: 'object',
+                        },
+                      },
+                      required: ['name'],
+                      type: 'object',
+                    });
+                },
             };
 
             Object.keys(assertionsPerProperty).forEach(aPropertyName => {

diff --git a/tests/unit/swagger/schemaDetails3.spec.ts b/tests/unit/swagger/schemaDetails3.spec.ts
@@ -193,6 +193,29 @@ describe('Definition generation for OpenAPI 3.0.0', () => {
                     expect(propertySchema.description).to.eq(undefined, `for property ${propertyName}.description`);
                     expect(propertySchema).to.not.haveOwnProperty('additionalProperties', `for property ${propertyName}`);
                 },
+                objLiteral: (propertyName, propertySchema) => {
+                    expect(propertySchema).to.deep.include({
+                      properties: {
+                        name: {
+                          type: 'string',
+                        },
+                        nested: {
+                          properties: {
+                            allOptional: {
+                              properties: { one: { type: 'string' }, two: { type: 'string' } },
+                              type: 'object',
+                            },
+                            bool: { type: 'boolean' },
+                            optional: { format: 'double', type: 'number'},
+                          },
+                          required: ['allOptional', 'bool'],
+                          type: 'object',
+                        },
+                      },
+                      required: ['name'],
+                      type: 'object',
+                    });
+                },
                 object: (propertyName, propertySchema) => {
                     expect(propertySchema.type).to.eq('object', `for property ${propertyName}`);
                     if (currentSpec.specName === 'specWithNoImplicitExtras') {