Merge pull request #73 from JaredCE/simplify-schema-convertor-code

Simplify schema convertor code

Author: JaredCE

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "serverless-openapi-documenter",
-  "version": "0.0.33",
+  "version": "0.0.40",
   "description": "Generate OpenAPI v3 documentation and Postman Collections from your Serverless Config",
   "main": "index.js",
   "keywords": [
@@ -32,6 +32,7 @@
     "chalk": "^4.1.2",
     "js-yaml": "^4.1.0",
     "json-schema-for-openapi": "^0.3.1",
+    "lodash.isequal": "^4.5.0",
     "oas-validator": "^5.0.8",
     "openapi-to-postmanv2": "^4.4.1",
     "swagger2openapi": "^7.0.8",

package.json

@@ -5,7 +5,8 @@ const path = require('path')
 const { v4: uuid } = require('uuid')
 const validator = require('oas-validator');
 const SchemaConvertor = require('json-schema-for-openapi')
-const $RefParser = require("@apidevtools/json-schema-ref-parser");
+const $RefParser = require("@apidevtools/json-schema-ref-parser")
+const isEqual = require('lodash.isequal')
 
 class DefinitionGenerator {
     constructor(serverless, options = {}) {
@@ -29,6 +30,11 @@ class DefinitionGenerator {
         this.operationIds = []
         this.schemaIDs = []
 
+        this.componentTypes = {
+            schemas: 'schemas',
+            securitySchemes: 'securitySchemes'
+        }
+
         try {
             this.refParserOptions = require(path.resolve('options', 'ref-parser.js'))
         } catch (err) {
@@ -455,42 +461,13 @@ class DefinitionGenerator {
     }
 
     async dereferenceSchema(schema) {
-        return await $RefParser.dereference(schema, this.refParserOptions)
+        let deReferencedSchema = await $RefParser.dereference(schema, this.refParserOptions)
             .catch(err => {
                 console.error(err)
                 throw err
             })
-    }
-
-    async schemaCreator(schema, name) {
-        const addToComponents = (schema, name) => {
-            const schemaObj = {
-                [name]: schema
-            }
-
-            if (this.openAPI?.components) {
-                if (this.openAPI.components?.schemas) {
-                    Object.assign(this.openAPI.components.schemas, schemaObj)
-                } else {
-                    Object.assign(this.openAPI.components, {schemas: schemaObj})
-                }
-            } else {
-                const components = {
-                    components: {
-                        schemas: schemaObj
-                    }
-                }
-
-                Object.assign(this.openAPI, components)
-            }
-        }
-
-        let deReferencedSchema = await this.dereferenceSchema(schema)
-            .catch((err) => {
-                throw err
-            })
 
-        // deal with schemas that have been de-referenced poorly
+        // deal with schemas that have been de-referenced poorly: naive
         if (deReferencedSchema.$ref === '#') {
             const oldRef = schema.$ref
             const path = oldRef.split('/')
@@ -505,35 +482,44 @@ class DefinitionGenerator {
                 })
         }
 
-        const convertedSchema = SchemaConvertor.convert(deReferencedSchema, name)
-        let schemaName = name
-        if (this.schemaIDs.includes(schemaName))
-            schemaName = `${name}-${uuid()}`
-
-        this.schemaIDs.push(schemaName)
+        return deReferencedSchema
+    }
 
-        for (const key of Object.keys(convertedSchema.schemas)) {
-            if (key === name || key.split('-')[0] === name) {
-                let ref = `#/components/schemas/`
+    async schemaCreator(schema, name) {
+        let schemaName = name
+        let finalName = schemaName
+        const dereferencedSchema = await this.dereferenceSchema(schema)
+            .catch(err => {
+                console.error(err)
+                throw err
+            })
 
-                if (this.openAPI?.components?.schemas?.[name]) {
-                    if (JSON.stringify(convertedSchema.schemas[key]) === JSON.stringify(this.openAPI.components.schemas[name])) {
-                        return `${ref}${name}`
-                    }
+        const convertedSchemas = SchemaConvertor.convert(dereferencedSchema, schemaName)
+
+        for (const convertedSchemaName of Object.keys(convertedSchemas.schemas)) {
+            const convertedSchema = convertedSchemas.schemas[convertedSchemaName]
+            if (this.existsInComponents(convertedSchemaName)) {
+                if (this.isTheSameSchema(convertedSchema, convertedSchemaName) === false) {
+                    if (convertedSchemaName === schemaName) {
+                        finalName = `${schemaName}-${uuid()}`
+                        this.addToComponents(this.componentTypes.schemas, convertedSchema, finalName)
+                    } else
+                        this.addToComponents(this.componentTypes.schemas, convertedSchema, convertedSchemaName)
                 }
-
-                addToComponents(convertedSchema.schemas[key], schemaName)
-                return `${ref}${schemaName}`
             } else {
-                if (this.openAPI?.components?.schemas?.[key]) {
-                    if (JSON.stringify(convertedSchema.schemas[key]) !== JSON.stringify(this.openAPI.components.schemas[key])) {
-                        addToComponents(convertedSchema.schemas[key], key)
-                    }
-                } else {
-                    addToComponents(convertedSchema.schemas[key], key)
-                }
+                this.addToComponents(this.componentTypes.schemas, convertedSchema, convertedSchemaName)
             }
         }
+
+        return `#/components/schemas/${finalName}`
+    }
+
+    existsInComponents(name) {
+        return Boolean(this.openAPI?.components?.schemas?.[name])
+    }
+
+    isTheSameSchema(schema, otherSchemaName) {
+        return isEqual(schema, this.openAPI.components.schemas[otherSchemaName])
     }
 
     addToComponents(type, schema, name) {
@@ -592,7 +578,7 @@ class DefinitionGenerator {
                 break;
             }
 
-            this.addToComponents('securitySchemes', schema, scheme)
+            this.addToComponents(this.componentTypes.securitySchemes, schema, scheme)
         }
     }