Updated document generation stuff

Abilio Henrique · Abilio Henrique · commit 60d9c29bff78 · 2017-04-04T15:16:22.000+10:00
diff --git a/.gitignore b/.gitignore
@@ -4,3 +4,4 @@ node_modules
 
 .directory
 .DS_STORE*
+*.log
diff --git a/package.json b/package.json
@@ -30,12 +30,14 @@
     "typescript": "^2.2.2"
   },
   "dependencies": {
+    "@jdw/jst": "^1.0.0-beta.10",
     "@types/bluebird": "^3.5.2",
     "@types/fs-promise": "^1.0.1",
     "@types/js-yaml": "^3.5.29",
     "bluebird": "^3.5.0",
     "fs-promise": "^2.0.2",
     "js-yaml": "^3.8.2",
-    "lutils": "^1.2.5"
+    "lutils": "^1.2.5",
+    "uuid": "^3.0.1"
   }
 }
diff --git a/src/generate.ts b/src/generate.ts
@@ -1,9 +1,11 @@
-import { merge } from 'lutils';
+import { dereference } from '@jdw/jst';
+import { clone, merge } from 'lutils';
+import uuid from 'uuid';
 
 type ServiceDescriptionType = {
+  title: string,
   description: string,
   version: string,
-  summary: string,
   termsOfService?: string,
   contact?: {
     name?: string,
@@ -14,68 +16,178 @@ type ServiceDescriptionType = {
     name: string,
     url: string,
   },
+  models?: any[],
 };
 
 export default class DocumentGenerator {
-  private config: ServiceDescriptionType = {
+  private config = {
     description: '',
     version: '0.0.0',
-    summary: '',
+    title: '',
+    paths: {},
+    components: {
+      schemas: {},
+    },
   };
 
   constructor(serviceDescriptor: ServiceDescriptionType) {
-    merge([this.config, serviceDescriptor], { depth: 32 });
+    this.config = this.process(clone(serviceDescriptor, { depth: 100 }));
+    // merge([this.config, serviceDescriptor], { depth: 32 });
+    // console.log(this.config);
   }
 
   public generate() {
-    return {
-      openapi: '3.0.0-RC0',
-      servers: this.getServers(),
-      info: {
-        description: this.getDescription(),
-        version: this.getVersion(),
-        title: this.getTitle(),
-        termsOfService: this.getTermsOfService(),
-      },
-      tags: this.getTags(),
-      paths: {},
-      components: {
-        schemas: this.getSchemas(),
-        requestBodies: {},
-        responses: {},
-        parameters: {},
-        examples: {},
-        securitySchemes: {},
-      },
-    };
+    return this.config;
   }
 
-  private getDescription() {
-    return this.config.description;
+  public addPathsFromFunctionConfig(config) {
+    // loop through function configurations
+    for (const funcConfig of config) {
+      // loop through http events
+      for (const httpEvent of this.getHttpEvents(funcConfig.events)) {
+        const httpEventConfig = httpEvent.http;
+        if (httpEventConfig.documentation) {
+          const documentationConfig = httpEventConfig.documentation;
+          // console.log(documentationConfig);
+          const pathConfig = {
+            [`/${httpEventConfig.path}`]: {
+              [httpEventConfig.method]: {
+                operationId: funcConfig._functionName,
+                summary: documentationConfig.summary || '',
+                description: documentationConfig.description || '',
+                responses: this.getResponsesFromConfig(documentationConfig),
+                parameters: this.getParametersFromConfig(documentationConfig),
+                requestBody: this.getRequestBodiesFromConfig(documentationConfig),
+              },
+            },
+          };
+          merge([this.config.paths, pathConfig], { depth: 100 });
+        }
+      }
+    }
+    // console.log(JSON.stringify(this.config.paths, null, 2));
   }
 
-  private getSchemas() {
-    return {};
-  }
+  private getParametersFromConfig(documentationConfig) {
+    const parameters = [];
+    // Path Parameters
+    if (documentationConfig.pathParams) {
+      for (const parameter of documentationConfig.pathParams) {
+        parameters.push({
+          name: parameter.name,
+          in: 'path',
+          description: parameter.description,
+          required: true, // Note: all path parameters must be required
+          schema: parameter.schema || {},
+          example: parameter.example || null,
+        });
+      }
+    }
+    // Query Parameters
+    if (documentationConfig.queryParams) {
+      for (const parameter of documentationConfig.queryParams) {
+        parameters.push({
+          name: parameter.name,
+          in: 'query',
+          description: parameter.description,
+          required: parameter.required || false, // Note: all path parameters must be required
+          schema: parameter.schema || {},
+          example: parameter.example || null,
+        });
+      }
+    }
+
+    // Request Header Parameters
+    if (documentationConfig.requestHeaders) {
+      for (const parameter of documentationConfig.requestHeaders) {
+        parameters.push({
+          name: parameter.name,
+          in: 'header',
+          description: parameter.description,
+          required: parameter.required || false, // Note: all path parameters must be required
+          schema: parameter.schema || {},
+          example: parameter.example || null,
+        });
+      }
+    }
 
-  private getServers() {
-    return [{ url: 'nothing' }];
+    return parameters;
   }
 
-  private getTermsOfService() {
-    return this.config.termsOfService;
+  private getRequestBodiesFromConfig(documentationConfig) {
+    const requestBodies = {};
+    if (documentationConfig.requestModels) {
+      for (const requestModelType of Object.keys(documentationConfig.requestModels)) {
+        merge([requestBodies, {
+          [requestModelType]: {
+            schema: {
+              $ref: `#/components/schemas/${documentationConfig.requestModels[requestModelType]}`,
+            },
+          },
+         }], { depth: 100 });
+      }
+    }
+
+    return requestBodies;
   }
 
-  private getTags() {
-    return [];
+  private getResponsesFromConfig(documentationConfig) {
+    const responses = {};
+    if (documentationConfig.methodResponses) {
+      for (const response of documentationConfig.methodResponses) {
+        merge([responses, {
+          [response.statusCode]: {
+            description: response.description || `Status ${response.statusCode} Response`,
+            content: this.getResponseContent(response.responseModels),
+          },
+         }], { depth: 100 });
+      }
+    }
+
+    return responses;
   }
 
-  private getTitle() {
-    return this.config.summary;
+  private getResponseContent(response) {
+    const content = {};
+    for (const responseKey of Object.keys(response)) {
+      merge(content, { [responseKey] : {
+        schema: {
+          $ref: `#/components/schemas/${response[responseKey]}`,
+        },
+      } });
+    }
+    // console.log(content);
+    return content;
   }
 
-  private getVersion() {
-    return this.config.version;
+  private getHttpEvents(funcConfig) {
+    return funcConfig.filter((event) => event.http ? true : false);
   }
 
+  private process(serviceDescriptor): any {
+    const configObject = {
+      openapi: '3.0.0-RC0',
+      servers: [],
+      info: {
+        title: serviceDescriptor.summary || '',
+        description: serviceDescriptor.description || '',
+        version: serviceDescriptor.version || uuid.v4(),
+      },
+      paths: {},
+      components: {
+        schemas: {},
+        requestBodies: {},
+        responses: {},
+        parameters: {},
+        examples: {},
+        securitySchemes: {},
+      },
+    };
+
+    for (const model of serviceDescriptor.models) {
+      configObject.components.schemas[model.name] = dereference(model.schema);
+    }
+
+    return configObject;
+  }
 }
diff --git a/src/index.ts b/src/index.ts
@@ -1,7 +1,11 @@
-import * as DocumentGenerator from './generate';
+import * as fs from 'fs';
+import * as YAML from 'js-yaml';
+import { merge } from 'lutils';
+import DocumentGenerator from './generate';
 
 class ServerlessOpenAPIDocumentation {
   public hooks;
+  public commands;
   private serverless;
   private options;
   private provider;
@@ -19,22 +23,79 @@ class ServerlessOpenAPIDocumentation {
     this.getMethodLogicalId = naming.getMethodLogicalId.bind(naming);
     this.normalizePath = naming.normalizePath.bind(naming);
 
+    this.commands = {
+      openapi: {
+        commands: {
+          generate: {
+            lifecycleEvents: [
+              'serverless',
+            ],
+            usage: 'Generate OpenAPI v3 Documentation',
+            options: {
+              output: {
+                usage: 'Output file location [default: openapi.yml|json]',
+                shortcut: 'o',
+              },
+              format: {
+                usage: 'OpenAPI file format (yml|json) [default: yml]',
+                shortcut: 'f',
+              },
+              indent: {
+                usage: 'File indentation in spaces[default: 2]',
+                shortcut: 'i',
+              },
+            },
+          },
+        },
+      },
+    };
+
     this.hooks = {
-      'before:deploy:deploy': this.beforeDeploy.bind(this),
-      'after:deploy:deploy': this.afterDeploy.bind(this),
+      // 'before:deploy:deploy': this.beforeDeploy.bind(this),
+      // 'after:deploy:deploy': this.afterDeploy.bind(this),
+      'openapi:generate:serverless': this.beforeDeploy.bind(this),
     };
   }
 
-  private beforeDeploy() {
+  private beforeDeploy(e) {
+    const indent = this.serverless.processedInput.options.indent || 2;
+    const outputFormat = this.serverless.processedInput.options.format || 'yaml';
+
+    if (['yaml', 'json'].indexOf(outputFormat.toLowerCase()) < 0) {
+      throw new Error('Invalid Output Format Specified - must be one of "yaml" or "json"');
+    }
+
+    let outputFile = this.serverless.processedInput.options.output;
+
     const dg = new DocumentGenerator(this.customVars.documentation);
 
     const funcConfigs = this.serverless.service.getAllFunctions().map((functionName) => {
       const func = this.serverless.service.getFunction(functionName);
-      console.log(func.events);
-      return func;
+      return merge([{ _functionName: functionName }, func], { depth: 100 });
     });
 
-    return Promise.reject(new Error('fuck'));
+    dg.addPathsFromFunctionConfig(funcConfigs);
+
+    const outputObject = dg.generate();
+
+    let outputContent = '';
+    switch (outputFormat.toLowerCase()) {
+      case 'json':
+        if (!outputFile) {
+          outputFile = 'openapi.json';
+        }
+        outputContent = JSON.stringify(outputObject, null, indent);
+        break;
+      case 'yaml':
+      default:
+        if (!outputFile) {
+          outputFile = 'openapi.yml';
+        }
+        outputContent = YAML.safeDump(outputObject, { indent });
+        break;
+    }
+
+    fs.writeFileSync(outputFile, outputContent);
   }
 
   private afterDeploy() {
diff --git a/yarn.lock b/yarn.lock

Original file line number	Diff line number	Diff line change
`@@ -4,3 +4,4 @@ node_modules`
`4`	`4`
`5`	`5`	`.directory`
`6`	`6`	`.DS_STORE*`
	`7`	`+*.log`