serverless-openapi-documenter 0.0.27 → 0.0.31

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "serverless-openapi-documenter",
-  "version": "0.0.27",
+  "version": "0.0.31",
   "description": "Generate OpenAPI v3 documentation and Postman Collections from your Serverless Config",
   "main": "index.js",
   "keywords": [
@@ -28,21 +28,21 @@
   },
   "license": "MIT",
   "dependencies": {
-    "@apidevtools/json-schema-ref-parser": "^9.0.9",
+    "@apidevtools/json-schema-ref-parser": "^9.1.0",
     "chalk": "^4.1.2",
     "js-yaml": "^4.1.0",
-    "json-schema-for-openapi": "^0.2.1",
+    "json-schema-for-openapi": "^0.3.1",
     "oas-validator": "^5.0.8",
-    "openapi-to-postmanv2": "^4.1.0",
+    "openapi-to-postmanv2": "^4.4.1",
     "swagger2openapi": "^7.0.8",
-    "uuid": "^8.3.2"
+    "uuid": "^9.0.0"
   },
   "engines": {
     "node": ">=14"
   },
   "devDependencies": {
-    "chai": "^4.3.6",
-    "mocha": "^10.0.0",
-    "sinon": "^14.0.0"
+    "chai": "^4.3.7",
+    "mocha": "^10.1.0",
+    "sinon": "^15.0.0"
   }
 }

package/src/definitionGenerator.js

@@ -410,6 +410,14 @@ class DefinitionGenerator {
         return params;
     }
 
+    async dereferenceSchema(schema) {
+        return await $RefParser.dereference(schema, this.refParserOptions)
+            .catch(err => {
+                console.error(err)
+                throw err
+            })
+    }
+
     async schemaCreator(schema, name) {
         const addToComponents = (schema, name) => {
             const schemaObj = {
@@ -433,14 +441,27 @@ class DefinitionGenerator {
             }
         }
 
-        const deReferencedSchema = await $RefParser.dereference(schema, this.refParserOptions)
-            .catch(err => {
-                console.error(err)
+        let deReferencedSchema = await this.dereferenceSchema(schema)
+            .catch((err) => {
                 throw err
             })
 
+        // deal with schemas that have been de-referenced poorly
+        if (deReferencedSchema.$ref === '#') {
+            const oldRef = schema.$ref
+            const path = oldRef.split('/')
+
+            const pathTitle = path[path.length-1]
+            const property = deReferencedSchema.definitions[path[path.length-1]]
+            Object.assign(deReferencedSchema, {properties: {[pathTitle]: property}})
+            delete deReferencedSchema.$ref
+            deReferencedSchema = await this.dereferenceSchema(deReferencedSchema)
+                .catch((err) => {
+                    throw err
+                })
+        }
 
-        const convertedSchema = SchemaConvertor.convert(deReferencedSchema)
+        const convertedSchema = SchemaConvertor.convert(deReferencedSchema, name)
         let schemaName = name
         if (this.schemaIDs.includes(schemaName))
             schemaName = `${name}-${uuid()}`
@@ -448,7 +469,7 @@ class DefinitionGenerator {
         this.schemaIDs.push(schemaName)
 
         for (const key of Object.keys(convertedSchema.schemas)) {
-            if (key === 'main' || key.split('-')[0] === 'main') {
+            if (key === name || key.split('-')[0] === name) {
                 let ref = `#/components/schemas/`
 
                 if (this.openAPI?.components?.schemas?.[name]) {

package/test/unit/definitionGenerator.spec.js

@@ -458,6 +458,35 @@ describe('DefinitionGenerator', () => {
                 expect(definitionGenerator.openAPI.components.schemas).to.have.property('ContactPutRequest')
                 expect(expected).to.equal('#/components/schemas/ContactPutRequest')
             });
+
+            it('should handle a schema that has been improperly dereferenced', async function() {
+                const simpleSchema = {
+                    $schema: 'http://json-schema.org/draft-04/schema#',
+                    title: 'JSON API Schema',
+                    $ref: '#/definitions/Error',
+                    definitions: {
+                        Error: {
+                            type: 'string'
+                        }
+                    }
+                }
+                const definitionGenerator = new DefinitionGenerator(mockServerless)
+                const expected = await definitionGenerator.schemaCreator(simpleSchema, 'simpleSchema')
+                    .catch((err) => {
+                        console.error(err)
+                    })
+
+                expect(definitionGenerator.openAPI.components.schemas).to.have.property('simpleSchema')
+                expect(definitionGenerator.openAPI.components.schemas.simpleSchema).to.deep.equal({
+                    title: 'JSON API Schema',
+                    properties: {
+                        Error: {
+                            type: 'string'
+                        }
+                    }
+                })
+                expect(expected).to.equal('#/components/schemas/simpleSchema')
+            });
         });
 
         describe('schemas that are urls', () => {
@@ -473,9 +502,9 @@ describe('DefinitionGenerator', () => {
                     })
 
                 expect(definitionGenerator.openAPI.components.schemas).to.have.property('LicensedMember')
-                expect(definitionGenerator.openAPI.components.schemas).to.have.property('log')
-                expect(definitionGenerator.openAPI.components.schemas).to.have.property('template')
-                expect(definitionGenerator.openAPI.components.schemas).to.have.property('database')
+                expect(definitionGenerator.openAPI.components.schemas.LicensedMember.properties).to.have.property('log')
+                expect(definitionGenerator.openAPI.components.schemas.LicensedMember.properties).to.have.property('template')
+                expect(definitionGenerator.openAPI.components.schemas.LicensedMember.properties).to.have.property('database')
                 expect(expected).to.equal('#/components/schemas/LicensedMember')
 
                 stub.restore()
@@ -485,13 +514,27 @@ describe('DefinitionGenerator', () => {
                 const complexSchema = 'https:///google.com/build/LicensedMember.json'
                 const LicensedMemberJSON = require('../json/complex.json')
 
-                const stub = sinon.stub($RefParser, 'dereference').resolves(LicensedMemberJSON)
+                // const stub = sinon.stub($RefParser, 'dereference').resolves(LicensedMemberJSON)
+                const stub = sinon.stub($RefParser, 'dereference')
+                    .onFirstCall().resolves(LicensedMemberJSON)
+                    .onSecondCall().resolves({
+                        type: "object",
+                        properties: {
+                            UUID: {
+                                $ref: "#/definitions/log"
+                            },
+                            name: {
+                                type: "string"
+                            }
+                        }
+                    })
                 const definitionGenerator = new DefinitionGenerator(mockServerless)
                 let expected = await definitionGenerator.schemaCreator(complexSchema, 'LicensedMember')
                     .catch((err) => {
                         console.error(err)
                     })
 
+                // this will fail validation due to a missing definition
                 const simpleSchema = {
                     type: "object",
                     properties: {
@@ -511,10 +554,12 @@ describe('DefinitionGenerator', () => {
                     })
 
                 expect(definitionGenerator.openAPI.components.schemas).to.have.property('LicensedMember')
-                expect(definitionGenerator.openAPI.components.schemas).to.have.property('log')
-                expect(definitionGenerator.openAPI.components.schemas).to.have.property('template')
-                expect(definitionGenerator.openAPI.components.schemas).to.have.property('database')
+                expect(definitionGenerator.openAPI.components.schemas.LicensedMember.properties).to.have.property('log')
+                expect(definitionGenerator.openAPI.components.schemas.LicensedMember.properties).to.have.property('template')
+                expect(definitionGenerator.openAPI.components.schemas.LicensedMember.properties).to.have.property('database')
                 expect(definitionGenerator.openAPI.components.schemas).to.have.property('simpleSchema')
+                expect(definitionGenerator.openAPI.components.schemas.simpleSchema.properties).to.have.property('UUID')
+                expect(definitionGenerator.openAPI.components.schemas.simpleSchema.properties).to.have.property('name')
                 expect(expected).to.equal('#/components/schemas/simpleSchema')
 
                 stub.restore()
@@ -528,6 +573,7 @@ describe('DefinitionGenerator', () => {
                 const expected = await definitionGenerator.schemaCreator(simpleSchema, 'simpleSchema')
                     .catch((err) => {
                         console.error(err)
+                        expect(err).to.be.an('error')
                     })
 
                 expect(expected).to.be.undefined