serverless-openapi-documenter 0.0.107 → 0.0.108

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "serverless-openapi-documenter",
-  "version": "0.0.107",
+  "version": "0.0.108",
   "description": "Generate OpenAPI v3 documentation and Postman Collections from your Serverless Config",
   "main": "index.js",
   "keywords": [
@@ -27,7 +27,8 @@
     "Api Gateway",
     "APIGateway",
     "AWSAPIGateway",
-    "Serverless OpenAPI"
+    "Serverless OpenAPI",
+    "serverless openapi"
   ],
   "scripts": {
     "test": "mocha --config './test/.mocharc.js'"

package/src/definitionGenerator.js

@@ -15,7 +15,9 @@ const SchemaHandler = require("./schemaHandler");
 const oWASP = require("./owasp");
 
 class DefinitionGenerator {
-  constructor(serverless, options = {}) {
+  constructor(serverless, logger) {
+    this.logger = logger;
+
     this.version =
       serverless?.processedInput?.options?.openApiVersion || "3.0.0";
 
@@ -70,6 +72,12 @@ class DefinitionGenerator {
     };
 
     try {
+      this.logger.verbose(
+        `Trying to resolve Redocly rules from: ${path.resolve(
+          "options",
+          "redocly.json"
+        )}`
+      );
       this.REDOCLY_RULES = require(path.resolve("options", "redocly.json"));
     } catch (err) {
       this.REDOCLY_RULES = {
@@ -83,6 +91,12 @@ class DefinitionGenerator {
     }
 
     try {
+      this.logger.verbose(
+        `Trying to resolve Ref-Parser options from: ${path.resolve(
+          "options",
+          "ref-parser.js"
+        )}`
+      );
       this.refParserOptions = require(path.resolve("options", "ref-parser.js"));
     } catch (err) {
       this.refParserOptions = {};

package/src/logger.js

@@ -0,0 +1,74 @@
+"use strict";
+
+class Logger {
+  constructor(serverless, log) {
+    this.serverless = serverless;
+    this.logOutput = log;
+
+    this.logTypes = {
+      NOTICE: "notice",
+      DEBUG: "debug",
+      ERROR: "error",
+      WARNING: "warning",
+      INFO: "info",
+      VERBOSE: "verbose",
+      SUCCESS: "success",
+    };
+
+    this.defaultLog = this.logTypes.NOTICE;
+  }
+
+  log(str, type = this.defaultLog) {
+    switch (this.serverless.version[0]) {
+      case "2":
+        let colouredString = str;
+        if (type === "error") {
+          colouredString = chalk.bold.red(`✖ ${str}`);
+        } else if (type === "success") {
+          colouredString = chalk.bold.green(`✓ ${str}`);
+        }
+
+        this.serverless.cli.log(colouredString);
+        break;
+
+      case "4":
+      case "3":
+        this.logOutput[type](str);
+        break;
+
+      default:
+        process.stdout.write(str.join(" "));
+        break;
+    }
+  }
+
+  debug(str) {
+    this.log(str, this.logTypes.DEBUG);
+  }
+
+  error(str) {
+    this.log(str, this.logTypes.ERROR);
+  }
+
+  info(str) {
+    this.log(str, this.logTypes.INFO);
+  }
+
+  notice(str) {
+    this.log(str, this.logTypes.NOTICE);
+  }
+
+  success(str) {
+    this.log(str, this.logTypes.SUCCESS);
+  }
+
+  verbose(str) {
+    this.log(str, this.logTypes.VERBOSE);
+  }
+
+  warning(str) {
+    this.log(str, this.logTypes.WARNING);
+  }
+}
+
+module.exports = Logger;

package/src/openAPIGenerator.js

@@ -5,6 +5,7 @@ const yaml = require("js-yaml");
 const chalk = require("chalk");
 
 const DefinitionGenerator = require("./definitionGenerator");
+const Logger = require("./logger");
 const PostmanGenerator = require("openapi-to-postmanv2");
 
 class OpenAPIGenerator {
@@ -12,18 +13,7 @@ class OpenAPIGenerator {
     this.logOutput = log;
     this.serverless = serverless;
     this.options = options;
-
-    this.logTypes = {
-      NOTICE: "notice",
-      DEBUG: "debug",
-      ERROR: "error",
-      WARNING: "warning",
-      INFO: "info",
-      VERBOSE: "verbose",
-      SUCCESS: "success",
-    };
-
-    this.defaultLog = this.logTypes.NOTICE;
+    this.logger = new Logger(this.serverless, this.logOutput);
 
     this.commands = {
       openapi: {
@@ -145,7 +135,9 @@ class OpenAPIGenerator {
   }
 
   async generate() {
-    this.log(chalk.bold.underline("OpenAPI v3 Description Generation"));
+    this.logger.notice(
+      chalk.bold.underline("OpenAPI v3 Description Generation")
+    );
     this.processCliInput();
 
     const validOpenAPI = await this.generationAndValidation().catch((err) => {
@@ -168,37 +160,31 @@ class OpenAPIGenerator {
     }
     try {
       fs.writeFileSync(this.config.file, output);
-      this.log(
-        "OpenAPI v3 Description Successfully Written",
-        this.logTypes.SUCCESS
-      );
+      this.logger.success("OpenAPI v3 Description Successfully Written");
     } catch (err) {
-      this.log(
-        `ERROR: An error was thrown whilst writing the OpenAPI Description`,
-        this.logTypes.ERROR
+      this.logger.error(
+        `ERROR: An error was thrown whilst writing the OpenAPI Description`
       );
       throw new this.serverless.classes.Error(err);
     }
   }
 
   async generationAndValidation() {
-    const generator = new DefinitionGenerator(this.serverless);
+    const generator = new DefinitionGenerator(this.serverless, this.logger);
 
-    this.log(`Generating OpenAPI Description`, this.logTypes.NOTICE);
+    this.logger.notice(`Generating OpenAPI Description`);
     await generator.parse().catch((err) => {
-      this.log(
-        `ERROR: An error was thrown generating the OpenAPI v3 Description`,
-        this.logTypes.ERROR
+      this.logger.error(
+        `ERROR: An error was thrown generating the OpenAPI v3 Description`
       );
       throw new this.serverless.classes.Error(err);
     });
 
-    this.log(`Validating generated OpenAPI Description`, this.logTypes.NOTICE);
+    this.logger.notice(`Validating generated OpenAPI Description`);
 
     const validationResults = await generator.validate().catch((err) => {
-      this.log(
-        `ERROR: An error was thrown validating the OpenAPI v3 Description`,
-        this.logTypes.ERROR
+      this.logger.error(
+        `ERROR: An error was thrown validating the OpenAPI v3 Description`
       );
 
       throw new this.serverless.classes.Error(err);
@@ -219,10 +205,7 @@ class OpenAPIGenerator {
       if (shouldThrow) throw new this.serverless.classes.Error(message);
     }
 
-    this.log(
-      "OpenAPI v3 Description Successfully Generated",
-      this.logTypes.SUCCESS
-    );
+    this.logger.success("OpenAPI v3 Description Successfully Generated");
 
     return generator.openAPI;
   }
@@ -230,31 +213,29 @@ class OpenAPIGenerator {
   createPostman(openAPI) {
     const postmanGeneration = (err, result) => {
       if (err) {
-        this.log(
-          `ERROR: An error was thrown when generating the postman collection`,
-          this.logTypes.ERROR
+        this.logger.error(
+          `ERROR: An error was thrown when generating the postman collection`
         );
         throw new this.serverless.classes.Error(err);
       }
 
-      this.log(
-        "postman collection v2 Documentation Successfully Generated",
-        this.logTypes.SUCCESS
+      this.logger.success(
+        "postman collection v2 Documentation Successfully Generated"
       );
+
       try {
         fs.writeFileSync(
           this.config.postmanCollection,
           JSON.stringify(result.output[0].data)
         );
-        this.log(
-          "postman collection v2 Documentation Successfully Written",
-          this.logTypes.SUCCESS
+        this.logger.success(
+          "postman collection v2 Documentation Successfully Written"
         );
       } catch (err) {
-        this.log(
-          `ERROR: An error was thrown whilst writing the postman collection`,
-          this.logTypes.ERROR
+        this.logger.error(
+          `ERROR: An error was thrown whilst writing the postman collection`
         );
+
         throw new this.serverless.classes.Error(err);
       }
     };
@@ -295,7 +276,7 @@ class OpenAPIGenerator {
       this.serverless.processedInput.options.output ||
       (config.format === "yaml" ? "openapi.yml" : "openapi.json");
 
-    this.log(
+    this.logger.notice(
       `${chalk.bold.green("[OPTIONS]")}
   openApiVersion: "${chalk.bold.green(String(config.openApiVersion))}"
   format: "${chalk.bold.green(config.format)}"
@@ -314,26 +295,18 @@ class OpenAPIGenerator {
 
   validationErrorDetails(validationErrors) {
     if (validationErrors.length) {
-      this.log(
+      this.logger.error(
         `${chalk.bold.yellow(
           "[VALIDATION]"
-        )} Validation errors found in OpenAPI Description: \n`,
-        this.logTypes.ERROR
+        )} Validation errors found in OpenAPI Description: \n`
       );
 
       for (const error of validationErrors) {
-        this.log(
-          `${chalk.bold.red("Severity:")} ${error.severity}`,
-          this.logTypes.ERROR
-        );
-        this.log(
-          `${chalk.bold.yellow("Message:")} ${error.message}`,
-          this.logTypes.ERROR
-        );
+        this.logger.error(`${chalk.bold.red("Severity:")} ${error.severity}`);
+        this.logger.error(`${chalk.bold.yellow("Message:")} ${error.message}`);
         for (const location of error.location) {
-          this.log(
-            `${chalk.bold.yellow("found at location:")} ${location.pointer}`,
-            this.logTypes.ERROR
+          this.logger.error(
+            `${chalk.bold.yellow("found at location:")} ${location.pointer}`
           );
         }
       }

package/test/unit/definitionGenerator.spec.js

@@ -26,7 +26,11 @@ describe("DefinitionGenerator", () => {
 
   describe("constructor", () => {
     it("should return a definitionGenerator", function () {
-      const expected = new DefinitionGenerator(mockServerless, {});
+      const expected = new DefinitionGenerator(mockServerless, {
+        verbose: (str) => {
+          console.log(str);
+        },
+      });
       expect(expected).to.be.an.instanceOf(DefinitionGenerator);
     });
 
@@ -35,48 +39,73 @@ describe("DefinitionGenerator", () => {
         JSON.stringify(mockServerless)
       );
       delete serverlessWithoutOpenAPIVersion.processedInput;
-      let expected = new DefinitionGenerator(
-        serverlessWithoutOpenAPIVersion,
-        {}
-      );
+      let expected = new DefinitionGenerator(serverlessWithoutOpenAPIVersion, {
+        verbose: (str) => {
+          console.log(str);
+        },
+      });
       expect(expected.version).to.be.equal("3.0.0");
 
       Object.assign(serverlessWithoutOpenAPIVersion, { processedInput: {} });
-      expected = new DefinitionGenerator(serverlessWithoutOpenAPIVersion, {});
+      expected = new DefinitionGenerator(serverlessWithoutOpenAPIVersion, {
+        verbose: (str) => {
+          console.log(str);
+        },
+      });
       expect(expected.version).to.be.equal("3.0.0");
 
       serverlessWithoutOpenAPIVersion.processedInput = {
         options: {},
       };
-      expected = new DefinitionGenerator(serverlessWithoutOpenAPIVersion, {});
+      expected = new DefinitionGenerator(serverlessWithoutOpenAPIVersion, {
+        verbose: (str) => {
+          console.log(str);
+        },
+      });
       expect(expected.version).to.be.equal("3.0.0");
 
       serverlessWithoutOpenAPIVersion.processedInput.options = {
         test: "abc",
       };
 
-      expected = new DefinitionGenerator(serverlessWithoutOpenAPIVersion, {});
+      expected = new DefinitionGenerator(serverlessWithoutOpenAPIVersion, {
+        verbose: (str) => {
+          console.log(str);
+        },
+      });
       expect(expected.version).to.be.equal("3.0.0");
 
       serverlessWithoutOpenAPIVersion.processedInput.options = {
         openApiVersion: null,
       };
 
-      expected = new DefinitionGenerator(serverlessWithoutOpenAPIVersion, {});
+      expected = new DefinitionGenerator(serverlessWithoutOpenAPIVersion, {
+        verbose: (str) => {
+          console.log(str);
+        },
+      });
       expect(expected.version).to.be.equal("3.0.0");
 
       serverlessWithoutOpenAPIVersion.processedInput.options = {
         openApiVersion: undefined,
       };
 
-      expected = new DefinitionGenerator(serverlessWithoutOpenAPIVersion, {});
+      expected = new DefinitionGenerator(serverlessWithoutOpenAPIVersion, {
+        verbose: (str) => {
+          console.log(str);
+        },
+      });
       expect(expected.version).to.be.equal("3.0.0");
 
       serverlessWithoutOpenAPIVersion.processedInput.options = {
         openapiVersion: undefined,
       };
 
-      expected = new DefinitionGenerator(serverlessWithoutOpenAPIVersion, {});
+      expected = new DefinitionGenerator(serverlessWithoutOpenAPIVersion, {
+        verbose: (str) => {
+          console.log(str);
+        },
+      });
       expect(expected.version).to.be.equal("3.0.0");
     });
 
@@ -86,12 +115,20 @@ describe("DefinitionGenerator", () => {
       );
       serverlessWithOpenAPIVersion.processedInput.options.openApiVersion =
         "3.0.2";
-      let expected = new DefinitionGenerator(serverlessWithOpenAPIVersion, {});
+      let expected = new DefinitionGenerator(serverlessWithOpenAPIVersion, {
+        verbose: (str) => {
+          console.log(str);
+        },
+      });
       expect(expected.version).to.be.equal("3.0.2");
 
       serverlessWithOpenAPIVersion.processedInput.options.openApiVersion =
         "3.0.1";
-      expected = new DefinitionGenerator(serverlessWithOpenAPIVersion, {});
+      expected = new DefinitionGenerator(serverlessWithOpenAPIVersion, {
+        verbose: (str) => {
+          console.log(str);
+        },
+      });
       expect(expected.version).to.be.equal("3.0.1");
     });
 
@@ -111,7 +148,11 @@ describe("DefinitionGenerator", () => {
           throw err;
         });
 
-      const expected = new DefinitionGenerator(mockServerless, {});
+      const expected = new DefinitionGenerator(mockServerless, {
+        verbose: (str) => {
+          console.log(str);
+        },
+      });
 
       expect(expected.REDOCLY_RULES).to.have.property(
         "operation-2xx-response",

package/test/unit/logger.spec.js

@@ -0,0 +1,160 @@
+"use strict";
+
+const expect = require("chai").expect;
+const sinon = require("sinon");
+
+const Logger = require("../../src/logger");
+
+describe(`Logger`, function () {
+  let sls, logOutput;
+
+  beforeEach(function () {
+    sls = {
+      service: {
+        service: "test-service",
+        provider: {
+          stage: "test",
+        },
+        getAllFunctions: () => {},
+        getFunction: () => {},
+      },
+      version: "3.0.0",
+      variables: {
+        service: {
+          custom: {},
+        },
+      },
+      configSchemaHandler: {
+        defineFunctionEventProperties: () => {},
+        defineFunctionProperties: () => {},
+        defineCustomProperties: () => {},
+      },
+      classes: {
+        Error: class ServerlessError {
+          constructor(err) {
+            return new Error(err);
+          }
+        },
+      },
+      processedInput: {
+        options: {
+          postmanCollection: "postman.json",
+        },
+      },
+    };
+
+    logOutput = {
+      log: {
+        debug: (str) => {},
+        error: (str) => {},
+        info: (str) => {},
+        notice: (str) => {},
+        success: (str) => {},
+        verbose: (str) => {},
+        warning: (str) => {},
+      },
+    };
+  });
+
+  describe(`debug`, function () {
+    it(`should log a debug log type when debug is called`, function () {
+      const logger = new Logger(sls, logOutput.log);
+      const spy = sinon.spy(logger, "log");
+
+      logger.debug("Testing");
+
+      expect(spy.called).to.be.true;
+
+      spy.restore();
+    });
+  });
+
+  describe(`error`, function () {
+    it(`should log a error log type when error is called`, function () {
+      const logger = new Logger(sls, logOutput.log);
+      const spy = sinon.spy(logger, "log");
+
+      logger.error("Testing");
+
+      expect(spy.called).to.be.true;
+
+      spy.restore();
+    });
+  });
+
+  describe(`info`, function () {
+    it(`should log a info log type when info is called`, function () {
+      const logger = new Logger(sls, logOutput.log);
+      const spy = sinon.spy(logger, "log");
+
+      logger.info("Testing");
+
+      expect(spy.called).to.be.true;
+
+      spy.restore();
+    });
+  });
+
+  describe(`notice`, function () {
+    it(`should log a notice log type when log is called without a log type`, function () {
+      const logger = new Logger(sls, logOutput.log);
+      const spy = sinon.spy(logger, "log");
+
+      logger.log("Testing");
+
+      expect(spy.called).to.be.true;
+
+      spy.restore();
+    });
+
+    it(`should log a notice log type when notice is called`, function () {
+      const logger = new Logger(sls, logOutput.log);
+      const spy = sinon.spy(logger, "log");
+
+      logger.notice("Testing");
+
+      expect(spy.called).to.be.true;
+
+      spy.restore();
+    });
+  });
+
+  describe(`success`, function () {
+    it(`should log a success log type when success is called`, function () {
+      const logger = new Logger(sls, logOutput.log);
+      const spy = sinon.spy(logger, "log");
+
+      logger.success("Testing");
+
+      expect(spy.called).to.be.true;
+
+      spy.restore();
+    });
+  });
+
+  describe(`verbose`, function () {
+    it(`should log a verbose log type when verbose is called`, function () {
+      const logger = new Logger(sls, logOutput.log);
+      const spy = sinon.spy(logger, "log");
+
+      logger.verbose("Testing");
+
+      expect(spy.called).to.be.true;
+
+      spy.restore();
+    });
+  });
+
+  describe(`warning`, function () {
+    it(`should log a warning log type when warning is called`, function () {
+      const logger = new Logger(sls, logOutput.log);
+      const spy = sinon.spy(logger, "log");
+
+      logger.warning("Testing");
+
+      expect(spy.called).to.be.true;
+
+      spy.restore();
+    });
+  });
+});