@creator.co/wapi 1.2.4 → 1.2.6

package/tests/Server/lib/container/GenericHandler.test.ts

@@ -1,6 +1,5 @@
-import { expect as j_expect } from '@jest/globals'
 import { APIGatewayProxyEvent, Context } from 'aws-lambda'
-import { expect } from 'chai'
+import { expect as c_expect } from 'chai'
 import { Request, Response } from 'express'
 
 import Globals from '../../../../src/Globals'
@@ -28,11 +27,11 @@ describe('GenericHandler success invocation path', () => {
     const resp = observableResponse()
     const handlerResp = await handler(<Request>(<unknown>{}), resp)
     //
-    expect(handlerResp).to.be.undefined
-    j_expect(resp.send).not.toBeCalled()
-    j_expect(resp.json).toBeCalledWith(JSON.parse(v.body))
-    j_expect(resp.status).toBeCalledWith(v.statusCode)
-    j_expect(resp.header).not.toBeCalled()
+    c_expect(handlerResp).to.be.undefined
+    expect(resp.send).not.toBeCalled()
+    expect(resp.json).toBeCalledWith(JSON.parse(v.body))
+    expect(resp.status).toBeCalledWith(v.statusCode)
+    expect(resp.header).not.toBeCalled()
   })
 
   test('Simple success w/ headers', async () => {
@@ -47,11 +46,11 @@ describe('GenericHandler success invocation path', () => {
     const resp = observableResponse()
     const handlerResp = await handler(<Request>(<unknown>{}), resp)
     //
-    expect(handlerResp).to.be.undefined
-    j_expect(resp.send).not.toBeCalled()
-    j_expect(resp.json).toBeCalledWith(JSON.parse(v.body))
-    j_expect(resp.status).toBeCalledWith(v.statusCode)
-    j_expect(resp.header).toBeCalledTimes(Object.keys(v.headers).length)
+    c_expect(handlerResp).to.be.undefined
+    expect(resp.send).not.toBeCalled()
+    expect(resp.json).toBeCalledWith(JSON.parse(v.body))
+    expect(resp.status).toBeCalledWith(v.statusCode)
+    expect(resp.header).toBeCalledTimes(Object.keys(v.headers).length)
   })
 
   test('Simple success w/ null body', async () => {
@@ -65,11 +64,11 @@ describe('GenericHandler success invocation path', () => {
     const resp = observableResponse()
     const handlerResp = await handler(<Request>(<unknown>{}), resp)
     //
-    expect(handlerResp).to.be.undefined
-    j_expect(resp.send).not.toBeCalled()
-    j_expect(resp.json).toBeCalledWith({})
-    j_expect(resp.status).toBeCalledWith(v.statusCode)
-    j_expect(resp.header).toBeCalledTimes(Object.keys(v.headers).length)
+    c_expect(handlerResp).to.be.undefined
+    expect(resp.send).not.toBeCalled()
+    expect(resp.json).toBeCalledWith({})
+    expect(resp.status).toBeCalledWith(v.statusCode)
+    expect(resp.header).toBeCalledTimes(Object.keys(v.headers).length)
   })
 })
 
@@ -81,14 +80,14 @@ describe('GenericHandler failure invocation path', () => {
     const resp = observableResponse()
     const handlerResp = await handler(<Request>(<unknown>{}), resp)
     //
-    expect(handlerResp).to.be.undefined
-    j_expect(resp.send).not.toBeCalled()
-    j_expect(resp.header).not.toBeCalled()
-    j_expect(resp.json).toBeCalledWith({
+    c_expect(handlerResp).to.be.undefined
+    expect(resp.send).not.toBeCalled()
+    expect(resp.header).not.toBeCalled()
+    expect(resp.json).toBeCalledWith({
       err: Globals.Resp_MSG_INVALIDRESP,
       errCode: Globals.Resp_CODE_INVALIDRESP,
     })
-    j_expect(resp.status).toBeCalledWith(Globals.Resp_STATUSCODE_INVALIDRESP)
+    expect(resp.status).toBeCalledWith(Globals.Resp_STATUSCODE_INVALIDRESP)
   })
 
   test('Error response', async () => {
@@ -99,13 +98,13 @@ describe('GenericHandler failure invocation path', () => {
     const resp = observableResponse()
     const handlerResp = await handler(<Request>(<unknown>{}), resp)
     //
-    expect(handlerResp).to.be.undefined
-    j_expect(resp.send).not.toBeCalled()
-    j_expect(resp.header).not.toBeCalled()
-    j_expect(resp.json).toBeCalledWith({
+    c_expect(handlerResp).to.be.undefined
+    expect(resp.send).not.toBeCalled()
+    expect(resp.header).not.toBeCalled()
+    expect(resp.json).toBeCalledWith({
       err,
     })
-    j_expect(resp.status).toBeCalledWith(400)
+    expect(resp.status).toBeCalledWith(400)
   })
 
   test('Exception response', async () => {
@@ -116,15 +115,15 @@ describe('GenericHandler failure invocation path', () => {
     const resp = observableResponse()
     const handlerResp = await handler(<Request>(<unknown>{}), resp)
     //
-    expect(handlerResp).to.be.undefined
-    j_expect(resp.send).not.toBeCalled()
-    j_expect(resp.header).not.toBeCalled()
-    j_expect(resp.json).toBeCalledWith({
+    c_expect(handlerResp).to.be.undefined
+    expect(resp.send).not.toBeCalled()
+    expect(resp.header).not.toBeCalled()
+    expect(resp.json).toBeCalledWith({
       ...err,
       err: Globals.Resp_MSG_EXCEPTION,
       errCode: Globals.Resp_CODE_EXCEPTION,
     })
-    j_expect(resp.status).toBeCalledWith(Globals.Resp_STATUSCODE_EXCEPTION)
+    expect(resp.status).toBeCalledWith(Globals.Resp_STATUSCODE_EXCEPTION)
   })
 })
 

package/tests/Server/lib/container/GenericHandlerEvent.test.ts

@@ -17,7 +17,7 @@ describe('GenericHandlerEvent invocation paths', () => {
     )
     const resp = await event.invoke()
     expect(resp).to.not.be.null
-    expect(resp.err).to.be.null
+    expect(resp.err).to.be.undefined
     expect(resp.data).to.be.equals('Success')
   })
 
@@ -94,7 +94,7 @@ describe('GenericHandlerEvent event test', () => {
     )
     const resp = await event.invoke()
     expect(resp).to.not.be.null
-    expect(resp.err).to.be.null
+    expect(resp.err).to.be.undefined
     expect(resp.data).to.be.equals('Success')
   })
 })

package/tests/Server/lib/container/HealthHandler.test.ts

@@ -1,5 +1,4 @@
-import { expect as j_expect } from '@jest/globals'
-import { expect } from 'chai'
+import { expect as c_expect } from 'chai'
 import { Request, Response } from 'express'
 
 import HealthHandler from '../../../../src/Server/lib/container/HealthHandler'
@@ -19,11 +18,11 @@ describe('HealthHandler invocation path', () => {
     const resp = observableResponse()
     const handlerResp = await HealthHandler(<Request>(<unknown>{}), resp)
     //
-    expect(handlerResp).to.be.undefined
-    j_expect(resp.send).toBeCalledWith('Healthy!')
-    j_expect(resp.json).not.toBeCalled()
-    j_expect(resp.status).not.toBeCalled()
-    j_expect(resp.header).not.toBeCalled()
+    c_expect(handlerResp).to.be.undefined
+    expect(resp.send).toBeCalledWith('Healthy!')
+    expect(resp.json).not.toBeCalled()
+    expect(resp.status).not.toBeCalled()
+    expect(resp.header).not.toBeCalled()
   })
 })
 

package/tests/Server/lib/container/Proxy.test.ts

@@ -1,6 +1,5 @@
-import { expect as j_expect } from '@jest/globals'
 import { APIGatewayProxyEvent, Context } from 'aws-lambda'
-import { expect } from 'chai'
+import { expect as c_expect } from 'chai'
 import * as request from 'supertest'
 
 import Globals from '../../../../src/Globals'
@@ -25,21 +24,21 @@ describe('Proxy configs', () => {
     const proxy = new Proxy({ routes: [] }, async () => {})
     await proxy.load()
     await proxy.unload('Error')
-    j_expect(mockExit).toBeCalledWith(1)
+    expect(mockExit).toBeCalledWith(1)
   })
 
   test('Simple port config', async () => {
     const proxy = new Proxy({ routes: [], port: 56562 }, async () => {})
     await proxy.load()
     await proxy.unload()
-    j_expect(mockExit).toBeCalledWith(0)
+    expect(mockExit).toBeCalledWith(0)
   })
 
   test('Simple timeout config', async () => {
     const proxy = new Proxy({ routes: [], timeout: 1000 }, async () => {})
     await proxy.load()
     await proxy.unload()
-    j_expect(mockExit).toBeCalledWith(0)
+    expect(mockExit).toBeCalledWith(0)
   })
 
   test('Simple cors config', async () => {
@@ -56,7 +55,7 @@ describe('Proxy configs', () => {
     )
     await proxy.load()
     await proxy.unload()
-    j_expect(mockExit).toBeCalledWith(0)
+    expect(mockExit).toBeCalledWith(0)
   })
 
   test('Empty cors config', async () => {
@@ -69,7 +68,7 @@ describe('Proxy configs', () => {
     )
     await proxy.load()
     await proxy.unload()
-    j_expect(mockExit).toBeCalledWith(0)
+    expect(mockExit).toBeCalledWith(0)
   })
 })
 
@@ -91,8 +90,8 @@ describe('Proxy behaviour', () => {
     const proxy = new Proxy({ routes: [] }, async () => {})
     await proxy.load()
     await Promise.all([proxy.unload('Error'), proxy.unload('Error')])
-    j_expect(mockExit).toHaveBeenCalledTimes(1)
-    j_expect(mockExit).toBeCalledWith(1)
+    expect(mockExit).toHaveBeenCalledTimes(1)
+    expect(mockExit).toBeCalledWith(1)
   })
 })
 
@@ -128,19 +127,19 @@ describe('Proxy routing', () => {
       .get(Globals.Listener_HTTP_DefaultHealthCheckRoute)
       .expect('Content-Type', 'text/html; charset=utf-8')
       .expect(200)
-    expect(res.text).to.be.equals('Healthy!')
+    c_expect(res.text).to.be.equals('Healthy!')
     // Generic handler
     const resG = await request(defaultUrl)
       .get(`/abc`)
       .expect('Content-Type', 'application/json; charset=utf-8')
       .expect(200)
-    expect(resG.body).to.be.deep.equals({ name: '123' })
+    c_expect(resG.body).to.be.deep.equals({ name: '123' })
     // Expected count
-    expect(count).to.be.equals(1)
+    c_expect(count).to.be.equals(1)
     // Unload
     await proxy.unload('Error')
-    j_expect(mockExit).toHaveBeenCalledTimes(1)
-    j_expect(mockExit).toBeCalledWith(1)
+    expect(mockExit).toHaveBeenCalledTimes(1)
+    expect(mockExit).toBeCalledWith(1)
   })
 
   test('Proxy on custom port', async () => {
@@ -163,19 +162,19 @@ describe('Proxy routing', () => {
       .get(Globals.Listener_HTTP_DefaultHealthCheckRoute)
       .expect('Content-Type', 'text/html; charset=utf-8')
       .expect(200)
-    expect(res.text).to.be.equals('Healthy!')
+    c_expect(res.text).to.be.equals('Healthy!')
     // Generic handler
     const resG = await request(url)
       .get(`/abc`)
       .expect('Content-Type', 'application/json; charset=utf-8')
       .expect(200)
-    expect(resG.body).to.be.deep.equals({ name: '123' })
+    c_expect(resG.body).to.be.deep.equals({ name: '123' })
     // Expected count
-    expect(count).to.be.equals(1)
+    c_expect(count).to.be.equals(1)
     // Unload
     await proxy.unload()
-    j_expect(mockExit).toHaveBeenCalledTimes(1)
-    j_expect(mockExit).toBeCalledWith(0)
+    expect(mockExit).toHaveBeenCalledTimes(1)
+    expect(mockExit).toBeCalledWith(0)
   })
 
   test('Proxy does timeout', async () => {
@@ -199,7 +198,7 @@ describe('Proxy routing', () => {
       .get(Globals.Listener_HTTP_DefaultHealthCheckRoute)
       .expect('Content-Type', 'text/html; charset=utf-8')
       .expect(200)
-    expect(res.text).to.be.equals('Healthy!')
+    c_expect(res.text).to.be.equals('Healthy!')
     // Generic handler
     let err: any = null
     try {
@@ -210,13 +209,13 @@ describe('Proxy routing', () => {
     } catch (e) {
       err = e
     }
-    expect(err?.message).to.be.equals('socket hang up')
+    c_expect(err?.message).to.be.equals('socket hang up')
     // Expected count
-    expect(count).to.be.equals(1)
+    c_expect(count).to.be.equals(1)
     // Unload
     await proxy.unload('Error')
-    j_expect(mockExit).toHaveBeenCalledTimes(1)
-    j_expect(mockExit).toBeCalledWith(1)
+    expect(mockExit).toHaveBeenCalledTimes(1)
+    expect(mockExit).toBeCalledWith(1)
     //
     return new Promise(resolve => {
       setTimeout(resolve, timeout * 2)
@@ -244,21 +243,24 @@ describe('Proxy routing', () => {
     )
     await proxy.load()
     // White-listed header is allowed
-    const resWH = await request(defaultUrl).options(`/abc`).set('Authorization', 123).expect(204)
-    expect(resWH.header['access-control-allow-origin']).to.equal('*')
-    expect(resWH.header['access-control-allow-credentials']).to.equal('true')
-    expect(resWH.header['access-control-allow-headers']).to.equal('Authorization')
+    const resWH = await request(defaultUrl).options(`/abc`).set('Authorization', '123').expect(204)
+    c_expect(resWH.header['access-control-allow-origin']).to.equal('*')
+    c_expect(resWH.header['access-control-allow-credentials']).to.equal('true')
+    c_expect(resWH.header['access-control-allow-headers']).to.equal('Authorization')
     // Non white-listed header is allowed
-    const resNWH = await request(defaultUrl).options(`/abc`).set('2Authorization2', 123).expect(204)
-    expect(resNWH.header['access-control-allow-origin']).to.equal('*')
-    expect(resNWH.header['access-control-allow-credentials']).to.equal('true')
-    expect(resNWH.header['access-control-allow-headers']).to.equal('Authorization')
+    const resNWH = await request(defaultUrl)
+      .options(`/abc`)
+      .set('2Authorization2', '123')
+      .expect(204)
+    c_expect(resNWH.header['access-control-allow-origin']).to.equal('*')
+    c_expect(resNWH.header['access-control-allow-credentials']).to.equal('true')
+    c_expect(resNWH.header['access-control-allow-headers']).to.equal('Authorization')
     // Expected count
-    expect(count).to.be.equals(0)
+    c_expect(count).to.be.equals(0)
     // Unload
     await proxy.unload()
-    j_expect(mockExit).toHaveBeenCalledTimes(1)
-    j_expect(mockExit).toBeCalledWith(0)
+    expect(mockExit).toHaveBeenCalledTimes(1)
+    expect(mockExit).toBeCalledWith(0)
   })
 })
 

package/tsconfig.json

@@ -1,6 +1,11 @@
 {
-  "exclude": ["**/*.test.*", "**/__mocks__/*", "**/__tests__/*", "**/tests/*"],
+  "exclude": ["**/*.test.*", "**/__mocks__/*", "**/__tests__/*", "**/tests/*", "./dist/**/*"],
   "compilerOptions": {
+    "lib": [
+      "es5",
+      "es6",
+      "dom"
+    ],
     "noImplicitAny": false,
     "noEmitOnError": true,
     "removeComments": false,