Lint fixes

Author: Deadarius

src/DefinitionGenerator.ts

@@ -1,11 +1,11 @@
+import _ = require('lodash');
 // tslint:disable-next-line no-submodule-imports
 import { validateSync as openApiValidatorSync } from 'swagger2openapi/validate';
 import * as uuid from 'uuid';
 
+import { parseModels } from './parse';
 import { IDefinition, IDefinitionConfig, IOperation, IParameterConfig, IServerlessFunctionConfig } from './types';
 import { cleanSchema } from './utils';
-import { parseModels } from './parse';
-import _ = require('lodash');
 
 export class DefinitionGenerator {
   // The OpenAPI version we currently validate against

src/ServerlessOpenApiDocumentation.ts

@@ -1,54 +1,55 @@
-import * as chalk from 'chalk';
+import chalk from 'chalk';
 import * as fs from 'fs';
 import * as YAML from 'js-yaml';
+import _ = require('lodash');
+import * as Serverless from 'serverless';
 import { inspect } from 'util';
+
 import { DefinitionGenerator } from './DefinitionGenerator';
-import { IDefinitionType, ILog, Format, IDefinitionConfig } from './types';
-import * as Serverless from 'serverless';
-import _ = require('lodash');
+import { Format, IDefinitionConfig, IDefinitionType, ILog } from './types';
 
-interface Options {
-  indent: number,
-  format: Format,
-  output: string,
+interface IOptions {
+  indent: number;
+  format: Format;
+  output: string;
 }
 
-interface ProcessedInput {
-  options: Options;
+interface IProcessedInput {
+  options: IOptions;
 }
 
-interface CustomVars {
+interface ICustomVars {
   documentation: IDefinitionConfig;
 }
 
-interface Service {
-  custom: CustomVars;
+interface IService {
+  custom: ICustomVars;
 }
 
-interface Variables {
-  service: Service
+interface IVariables {
+  service: IService;
 }
 
-interface FullServerless extends Serverless {
-  variables: Variables;
-  processedInput: ProcessedInput;
+interface IFullServerless extends Serverless {
+  variables: IVariables;
+  processedInput: IProcessedInput;
 }
 
 export class ServerlessOpenApiDocumentation {
   public hooks;
   public commands;
   /** Serverless Instance */
-  private serverless: FullServerless;
+  private serverless: IFullServerless;
 
   /** Serverless Service Custom vars */
-  private customVars: CustomVars;
+  private customVars: ICustomVars;
 
   /**
    * Constructor
    * @param serverless
    * @param options
    */
-  constructor (serverless: FullServerless, options) {
+  constructor (serverless: IFullServerless, options) {
 
     // pull the serverless instance into our class vars
     this.serverless = serverless;
@@ -93,37 +94,6 @@ export class ServerlessOpenApiDocumentation {
     process.stdout.write(str.join(' '));
   }
 
-  /**
-   * Processes CLI input by reading the input from serverless
-   * @returns config IConfigType
-   */
-  private processCliInput (): IDefinitionType {
-    const config: IDefinitionType = {
-      format: Format.yaml,
-      file: 'openapi.yml',
-      indent: 2,
-    };
-
-    config.indent = this.serverless.processedInput.options.indent || 2;
-    config.format = this.serverless.processedInput.options.format || Format.yaml;
-
-    if ([Format.yaml, Format.json].indexOf(config.format) < 0) {
-      throw new Error('Invalid Output Format Specified - must be one of "yaml" or "json"');
-    }
-
-    config.file = this.serverless.processedInput.options.output ||
-      ((config.format === 'yaml') ? 'openapi.yml' : 'openapi.json');
-
-    this.log(
-      `${chalk.bold.green('[OPTIONS]')}`,
-      `format: "${chalk.bold.red(config.format)}",`,
-      `output file: "${chalk.bold.red(config.file)}",`,
-      `indentation: "${chalk.bold.red(String(config.indent))}"\n\n`,
-    );
-
-    return config;
-  }
-
   /**
    * Generates OpenAPI Documentation based on serverless configuration and functions
    */
@@ -188,4 +158,35 @@ export class ServerlessOpenApiDocumentation {
 
     this.log(`${chalk.bold.green('[OUTPUT]')} To "${chalk.bold.red(config.file)}"\n`);
   }
+
+  /**
+   * Processes CLI input by reading the input from serverless
+   * @returns config IConfigType
+   */
+  private processCliInput (): IDefinitionType {
+    const config: IDefinitionType = {
+      format: Format.yaml,
+      file: 'openapi.yml',
+      indent: 2,
+    };
+
+    config.indent = this.serverless.processedInput.options.indent || 2;
+    config.format = this.serverless.processedInput.options.format || Format.yaml;
+
+    if ([Format.yaml, Format.json].indexOf(config.format) < 0) {
+      throw new Error('Invalid Output Format Specified - must be one of "yaml" or "json"');
+    }
+
+    config.file = this.serverless.processedInput.options.output ||
+      ((config.format === 'yaml') ? 'openapi.yml' : 'openapi.json');
+
+    this.log(
+      `${chalk.bold.green('[OPTIONS]')}`,
+      `format: "${chalk.bold.red(config.format)}",`,
+      `output file: "${chalk.bold.red(config.file)}",`,
+      `indentation: "${chalk.bold.red(String(config.indent))}"\n\n`,
+    );
+
+    return config;
+  }
 }

src/__tests__/DefinitionGenerator.spec.ts

@@ -1,7 +1,7 @@
+import _ = require('lodash');
 import * as path from 'path';
 import * as Serverless from 'serverless';
 import { DefinitionGenerator } from '../DefinitionGenerator';
-import _ = require('lodash');
 
 class ServerlessInterface extends Serverless {
   public service: any = {};
@@ -45,7 +45,7 @@ describe('OpenAPI Documentation Generator', () => {
     const docGen = new DefinitionGenerator(sls.service.custom.documentation, servicePath);
 
     // implementation copied from ServerlessOpenApiDocumentation.ts
-    docGen.parse();
+    await docGen.parse();
 
     const funcConfigs = sls.service.getAllFunctions().map((functionName) => {
       const func = sls.service.getFunction(functionName);

src/parse.ts

@@ -1,13 +1,12 @@
-import * as path from 'path';
-import * as _ from 'lodash';
 import { JSONSchema7 } from 'json-schema';
-
 import * as $RefParser from 'json-schema-ref-parser';
+import * as _ from 'lodash';
+import * as path from 'path';
 
 import { IModel } from './types';
 import { cleanSchema } from './utils';
 
-export async function parseModels(models: IModel[], root: string): Promise<{}> {
+export async function parseModels (models: IModel[], root: string): Promise<{}> {
   const schemas = {};
 
   if (!_.isArrayLike(models)) {
@@ -23,25 +22,25 @@ export async function parseModels(models: IModel[], root: string): Promise<{}> {
       ? await $RefParser.bundle(path.resolve(root, model.schema))
       : model.schema) as JSONSchema7;
 
-      _.assign(schemas, updateReferences(schema.definitions), {
-        [model.name]: updateReferences(cleanSchema(schema)),
-      });
+    _.assign(schemas, updateReferences(schema.definitions), {
+      [model.name]: updateReferences(cleanSchema(schema)),
+    });
   }
 
   return schemas;
 }
 
 function updateReferences (schema: JSONSchema7): JSONSchema7 {
-  if(!schema) {
+  if (!schema) {
     return schema;
   }
 
-  const cloned = _.cloneDeep(schema) as JSONSchema7;
+  const cloned = _.cloneDeep(schema);
 
   if (cloned.$ref) {
     return {
       ...cloned,
-      $ref: cloned.$ref.replace('#/definitions', '#/components/schemas')
+      $ref: cloned.$ref.replace('#/definitions', '#/components/schemas'),
     };
   }
 

src/types.ts

@@ -1,8 +1,10 @@
+import { JSONSchema7 } from 'json-schema';
+
 export interface IModel {
   name: string;
   description: string;
   contentType: string;
-  schema: string | object;
+  schema: string | JSONSchema7;
   examples: any[];
   example: object;
 }
@@ -16,8 +18,8 @@ export interface IDefinitionConfig {
 
 export enum Format {
   yaml = 'yaml',
-  json = 'json'
-};
+  json = 'json',
+}
 
 export interface IDefinitionType {
   file: string;

src/utils.ts

@@ -1,4 +1,4 @@
 
 import _ = require('lodash');
 
-export const cleanSchema = schema => _.omit(schema, '$schema', 'definitions')
+export const cleanSchema = (schema) => _.omit(schema, '$schema', 'definitions');