@creator.co/wapi 1.2.2 → 1.2.3

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

@@ -1,70 +1,69 @@
-import { APIGatewayProxyEvent, Context } from "aws-lambda"
-import { expect } from "chai"
-import { Request } from "express"
+import { APIGatewayProxyEvent, Context } from 'aws-lambda'
+import { expect } from 'chai'
+import { Request } from 'express'
 
-import GenericHandlerEvent from "../../../../src/Server/lib/container/GenericHandlerEvent"
+import GenericHandlerEvent from '../../../../src/Server/lib/container/GenericHandlerEvent'
 
-describe("GenericHandlerEvent invocation paths", () => {
-  test("Simple success", async () => {
+describe('GenericHandlerEvent invocation paths', () => {
+  test('Simple success', async () => {
     const event = new GenericHandlerEvent(
       <Request>(<unknown>{
-        socket: { remoteAddress: "127.0.0.1" },
+        socket: { remoteAddress: '127.0.0.1' },
       }),
       async (event: APIGatewayProxyEvent, context: Context) => {
         expect(context.getRemainingTimeInMillis()).to.not.be.null
-        context.succeed("Success")
-      },
+        context.succeed('Success')
+      }
     )
     const resp = await event.invoke()
     expect(resp).to.not.be.null
     expect(resp.err).to.be.null
-    expect(resp.data).to.be.equals("Success")
+    expect(resp.data).to.be.equals('Success')
   })
 
-  test("Simple failure", async () => {
+  test('Simple failure', async () => {
     const event = new GenericHandlerEvent(
       <Request>(<unknown>{}),
       async (event: APIGatewayProxyEvent, context: Context) => {
-        context.fail("Error!")
-      },
+        context.fail('Error!')
+      }
     )
     const resp = await event.invoke()
     expect(resp).to.not.be.null
     expect(resp.data).to.be.undefined
-    expect(resp.err).to.be.equals("Error!")
+    expect(resp.err).to.be.equals('Error!')
   })
 
-  test("Simple done (errored)", async () => {
+  test('Simple done (errored)', async () => {
     const event = new GenericHandlerEvent(
       <Request>(<unknown>{}),
       async (event: APIGatewayProxyEvent, context: Context) => {
-        context.done(new Error("Error!"))
-      },
+        context.done(new Error('Error!'))
+      }
     )
     const resp = await event.invoke()
     expect(resp).to.not.be.null
     expect(resp.data).to.be.undefined
-    expect(resp.err).to.be.an("Error")
-    if (resp.err instanceof Error)
-      expect(resp.err?.message).to.be.equals("Error!")
+    expect(resp.err).to.be.an('Error')
+    if (resp.err instanceof Error) expect(resp.err?.message).to.be.equals('Error!')
   })
 
-  test("Simple done (success)", async () => {
+  test('Simple done (success)', async () => {
     const event = new GenericHandlerEvent(
       <Request>(<unknown>{}),
       async (event: APIGatewayProxyEvent, context: Context) => {
-        context.done(undefined, "Success!")
-      },
+        context.done(undefined, 'Success!')
+      }
     )
     const resp = await event.invoke()
     expect(resp).to.not.be.null
     expect(resp.err).to.be.undefined
-    expect(resp.data).to.be.equals("Success!")
+    expect(resp.data).to.be.equals('Success!')
   })
 
-  test("Exception on execution", async () => {
+  test('Exception on execution', async () => {
     const event = new GenericHandlerEvent(<Request>(<unknown>{}), async () => {
-      throw new Error("Failed!")
+      throw new Error('Failed!')
     })
     let err: any = null,
       resp: any = null
@@ -75,28 +74,28 @@ describe("GenericHandlerEvent invocation paths", () => {
     }
     expect(resp).to.be.null
     expect(err).to.not.be.null
-    expect(err).to.be.an("Error")
-    expect(err.message).to.be.equals("Failed!")
+    expect(err).to.be.an('Error')
+    expect(err.message).to.be.equals('Failed!')
   })
 })
 
-describe("GenericHandlerEvent event test", () => {
-  test("Simple event test", async () => {
+describe('GenericHandlerEvent event test', () => {
+  test('Simple event test', async () => {
     const event = new GenericHandlerEvent(
       <Request>(<unknown>{
-        headers: { Authorization: "123", "x-forwarded-for": "127.0.0.1" },
-        method: "get",
-        query: "/status?name=ryan",
+        headers: { Authorization: '123', 'x-forwarded-for': '127.0.0.1' },
+        method: 'get',
+        query: '/status?name=ryan',
       }),
       async (event: APIGatewayProxyEvent, context: Context) => {
         expect(context.getRemainingTimeInMillis()).to.not.be.null
-        context.succeed("Success")
-      },
+        context.succeed('Success')
+      }
     )
     const resp = await event.invoke()
     expect(resp).to.not.be.null
     expect(resp.err).to.be.null
-    expect(resp.data).to.be.equals("Success")
+    expect(resp.data).to.be.equals('Success')
   })
 })
 

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

@@ -1,8 +1,8 @@
-import { expect as j_expect } from "@jest/globals"
-import { expect } from "chai"
-import { Request, Response } from "express"
+import { expect as j_expect } from '@jest/globals'
+import { expect } from 'chai'
+import { Request, Response } from 'express'
 
-import HealthHandler from "../../../../src/Server/lib/container/HealthHandler"
+import HealthHandler from '../../../../src/Server/lib/container/HealthHandler'
 
 function observableResponse(): Response {
   const resp = <Response>(<unknown>{
@@ -14,13 +14,13 @@ function observableResponse(): Response {
   return resp
 }
 
-describe("HealthHandler invocation path", () => {
-  test("Simple", async () => {
+describe('HealthHandler invocation path', () => {
+  test('Simple', async () => {
     const resp = observableResponse()
     const handlerResp = await HealthHandler(<Request>(<unknown>{}), resp)
     //
     expect(handlerResp).to.be.undefined
-    j_expect(resp.send).toBeCalledWith("Healthy!")
+    j_expect(resp.send).toBeCalledWith('Healthy!')
     j_expect(resp.json).not.toBeCalled()
     j_expect(resp.status).not.toBeCalled()
     j_expect(resp.header).not.toBeCalled()

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

@@ -1,18 +1,18 @@
-import { expect as j_expect } from "@jest/globals"
-import { APIGatewayProxyEvent, Context } from "aws-lambda"
-import { expect } from "chai"
-import * as request from "supertest"
+import { expect as j_expect } from '@jest/globals'
+import { APIGatewayProxyEvent, Context } from 'aws-lambda'
+import { expect } from 'chai'
+import * as request from 'supertest'
 
-import Globals from "../../../../src/Globals"
-import Proxy from "../../../../src/Server/lib/container/Proxy"
-import { defaultUrl } from "../../../Test.utils"
+import Globals from '../../../../src/Globals'
+import Proxy from '../../../../src/Server/lib/container/Proxy'
+import { defaultUrl } from '../../../Test.utils'
 
-describe("Proxy configs", () => {
+describe('Proxy configs', () => {
   // @ts-ignore
-  let mockExit = jest.spyOn(process, "exit").mockImplementation(() => {})
+  let mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {})
   beforeAll(() => {
     // @ts-ignore
-    mockExit = jest.spyOn(process, "exit").mockImplementation(() => {})
+    mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {})
   })
   afterAll(() => {
     mockExit.mockRestore()
@@ -21,51 +21,51 @@ describe("Proxy configs", () => {
     mockExit.mockReset()
   })
 
-  test("Empty config url & unload with error", async () => {
+  test('Empty config url & unload with error', async () => {
     const proxy = new Proxy({ routes: [] }, async () => {})
     await proxy.load()
-    await proxy.unload("Error")
+    await proxy.unload('Error')
     j_expect(mockExit).toBeCalledWith(1)
   })
 
-  test("Simple port config", async () => {
+  test('Simple port config', async () => {
     const proxy = new Proxy({ routes: [], port: 56562 }, async () => {})
     await proxy.load()
     await proxy.unload()
     j_expect(mockExit).toBeCalledWith(0)
   })
 
-  test("Simple timeout config", async () => {
+  test('Simple timeout config', async () => {
     const proxy = new Proxy({ routes: [], timeout: 1000 }, async () => {})
     await proxy.load()
     await proxy.unload()
     j_expect(mockExit).toBeCalledWith(0)
   })
 
-  test("Simple cors config", async () => {
+  test('Simple cors config', async () => {
     const proxy = new Proxy(
       {
         routes: [],
         cors: {
-          origin: "*",
-          headers: ["Authorization"],
+          origin: '*',
+          headers: ['Authorization'],
           allowCredentials: true,
         },
       },
-      async () => {},
+      async () => {}
     )
     await proxy.load()
     await proxy.unload()
     j_expect(mockExit).toBeCalledWith(0)
   })
 
-  test("Empty cors config", async () => {
+  test('Empty cors config', async () => {
     const proxy = new Proxy(
       {
         routes: [],
         cors: {},
       },
-      async () => {},
+      async () => {}
     )
     await proxy.load()
     await proxy.unload()
@@ -73,12 +73,12 @@ describe("Proxy configs", () => {
   })
 })
 
-describe("Proxy behaviour", () => {
+describe('Proxy behaviour', () => {
   // @ts-ignore
-  let mockExit = jest.spyOn(process, "exit").mockImplementation(() => {})
+  let mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {})
   beforeAll(() => {
     // @ts-ignore
-    mockExit = jest.spyOn(process, "exit").mockImplementation(() => {})
+    mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {})
   })
   afterAll(() => {
     mockExit.mockRestore()
@@ -87,21 +87,21 @@ describe("Proxy behaviour", () => {
     mockExit.mockReset()
   })
 
-  test("Stop twice", async () => {
+  test('Stop twice', async () => {
     const proxy = new Proxy({ routes: [] }, async () => {})
     await proxy.load()
-    await Promise.all([proxy.unload("Error"), proxy.unload("Error")])
+    await Promise.all([proxy.unload('Error'), proxy.unload('Error')])
     j_expect(mockExit).toHaveBeenCalledTimes(1)
     j_expect(mockExit).toBeCalledWith(1)
   })
 })
 
-describe("Proxy routing", () => {
+describe('Proxy routing', () => {
   // @ts-ignore
-  let mockExit = jest.spyOn(process, "exit").mockImplementation(() => {})
+  let mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {})
   beforeAll(() => {
     // @ts-ignore
-    mockExit = jest.spyOn(process, "exit").mockImplementation(() => {})
+    mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {})
   })
   afterAll(() => {
     mockExit.mockRestore()
@@ -110,69 +110,66 @@ describe("Proxy routing", () => {
     mockExit.mockReset()
   })
 
-  test("Health & Default handler", async () => {
+  test('Health & Default handler', async () => {
     let count = 0
     const proxy = new Proxy(
       { routes: [] },
       async (event: APIGatewayProxyEvent, context: Context) => {
         count++
         context.succeed({
-          body: JSON.stringify({ name: "123" }),
+          body: JSON.stringify({ name: '123' }),
           statusCode: 200,
         })
-      },
+      }
     )
     await proxy.load()
     // Health check
     const res = await request(defaultUrl)
       .get(Globals.Listener_HTTP_DefaultHealthCheckRoute)
-      .expect("Content-Type", "text/html; charset=utf-8")
+      .expect('Content-Type', 'text/html; charset=utf-8')
       .expect(200)
-    expect(res.text).to.be.equals("Healthy!")
+    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('Content-Type', 'application/json; charset=utf-8')
       .expect(200)
-    expect(resG.body).to.be.deep.equals({ name: "123" })
+    expect(resG.body).to.be.deep.equals({ name: '123' })
     // Expected count
     expect(count).to.be.equals(1)
     // Unload
-    await proxy.unload("Error")
+    await proxy.unload('Error')
     j_expect(mockExit).toHaveBeenCalledTimes(1)
     j_expect(mockExit).toBeCalledWith(1)
   })
 
-  test("Proxy on custom port", async () => {
+  test('Proxy on custom port', async () => {
     let count = 0
     const port = 56542
-    const url = defaultUrl.replace(
-      String(Globals.Listener_HTTP_DefaultPort),
-      String(port),
-    )
+    const url = defaultUrl.replace(String(Globals.Listener_HTTP_DefaultPort), String(port))
     const proxy = new Proxy(
       { routes: [], port },
       async (event: APIGatewayProxyEvent, context: Context) => {
         count++
         context.succeed({
-          body: JSON.stringify({ name: "123" }),
+          body: JSON.stringify({ name: '123' }),
           statusCode: 200,
         })
-      },
+      }
     )
     await proxy.load()
     // Health check
     const res = await request(url)
       .get(Globals.Listener_HTTP_DefaultHealthCheckRoute)
-      .expect("Content-Type", "text/html; charset=utf-8")
+      .expect('Content-Type', 'text/html; charset=utf-8')
       .expect(200)
-    expect(res.text).to.be.equals("Healthy!")
+    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('Content-Type', 'application/json; charset=utf-8')
       .expect(200)
-    expect(resG.body).to.be.deep.equals({ name: "123" })
+    expect(resG.body).to.be.deep.equals({ name: '123' })
     // Expected count
     expect(count).to.be.equals(1)
     // Unload
@@ -181,7 +178,7 @@ describe("Proxy routing", () => {
     j_expect(mockExit).toBeCalledWith(0)
   })
 
-  test("Proxy does timeout", async () => {
+  test('Proxy does timeout', async () => {
     let count = 0
     const timeout = 1000
     const proxy = new Proxy(
@@ -190,82 +187,72 @@ describe("Proxy routing", () => {
         count++
         setTimeout(() => {
           context.succeed({
-            body: JSON.stringify({ name: "123" }),
+            body: JSON.stringify({ name: '123' }),
             statusCode: 200,
           })
         }, timeout * 2)
-      },
+      }
     )
     await proxy.load()
     // Health check
     const res = await request(defaultUrl)
       .get(Globals.Listener_HTTP_DefaultHealthCheckRoute)
-      .expect("Content-Type", "text/html; charset=utf-8")
+      .expect('Content-Type', 'text/html; charset=utf-8')
       .expect(200)
-    expect(res.text).to.be.equals("Healthy!")
+    expect(res.text).to.be.equals('Healthy!')
     // Generic handler
     let err: any = null
     try {
       await request(defaultUrl)
         .get(`/abc`)
-        .expect("Content-Type", "application/json; charset=utf-8")
+        .expect('Content-Type', 'application/json; charset=utf-8')
         .expect(200)
     } catch (e) {
       err = e
     }
-    expect(err?.message).to.be.equals("socket hang up")
+    expect(err?.message).to.be.equals('socket hang up')
     // Expected count
     expect(count).to.be.equals(1)
     // Unload
-    await proxy.unload("Error")
+    await proxy.unload('Error')
     j_expect(mockExit).toHaveBeenCalledTimes(1)
     j_expect(mockExit).toBeCalledWith(1)
     //
-    return new Promise((resolve) => {
+    return new Promise(resolve => {
       setTimeout(resolve, timeout * 2)
     })
   })
 
-  test("Proxy respects cors", async () => {
+  test('Proxy respects cors', async () => {
     let count = 0
     const proxy = new Proxy(
       {
         routes: [],
         cors: {
-          origin: "*",
-          headers: ["Authorization"],
+          origin: '*',
+          headers: ['Authorization'],
           allowCredentials: true,
         },
       },
       async (event: APIGatewayProxyEvent, context: Context) => {
         count++
         context.succeed({
-          body: JSON.stringify({ name: "123" }),
+          body: JSON.stringify({ name: '123' }),
           statusCode: 200,
         })
-      },
+      }
     )
     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)
+    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')
     // 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)
+    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')
     // Expected count
     expect(count).to.be.equals(0)
     // Unload

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

@@ -1,46 +1,45 @@
-import { expect } from "chai"
+import { expect } from 'chai'
 
-import * as Utils from "../../../../src/Server/lib/container/Utils"
+import * as Utils from '../../../../src/Server/lib/container/Utils'
 
-describe("parseQueryStringParameters", () => {
-  test("Null url", () => {
+describe('parseQueryStringParameters', () => {
+  test('Null url', () => {
     // @ts-ignore
     const validationResult = Utils.parseQueryStringParameters(null)
     expect(validationResult).to.be.deep.equals(null)
   })
 
-  test("Empty url", () => {
-    const validationResult = Utils.parseQueryStringParameters("")
+  test('Empty url', () => {
+    const validationResult = Utils.parseQueryStringParameters('')
     expect(validationResult).to.be.deep.equals(null)
   })
 
-  test("Simple param", () => {
-    const validationResult =
-      Utils.parseQueryStringParameters("/status?name=ryan")
+  test('Simple param', () => {
+    const validationResult = Utils.parseQueryStringParameters('/status?name=ryan')
     expect(validationResult).to.be.deep.equals({
-      name: "ryan",
+      name: 'ryan',
     })
   })
 })
 
-describe("parseMultiValueQueryStringParameters", () => {
-  test("Null url", () => {
+describe('parseMultiValueQueryStringParameters', () => {
+  test('Null url', () => {
     // @ts-ignore
     const validationResult = Utils.parseMultiValueQueryStringParameters()
     expect(validationResult).to.be.deep.equals({})
   })
 
-  test("Empty url", () => {
-    const validationResult = Utils.parseMultiValueQueryStringParameters("")
+  test('Empty url', () => {
+    const validationResult = Utils.parseMultiValueQueryStringParameters('')
     expect(validationResult).to.be.deep.equals({})
   })
 
-  test("Simple multivalue param", () => {
+  test('Simple multivalue param', () => {
     const validationResult = Utils.parseMultiValueQueryStringParameters(
-      "/status?name=ryan&name=ryan2",
+      '/status?name=ryan&name=ryan2'
     )
     expect(validationResult).to.be.deep.equals({
-      name: ["ryan", "ryan2"],
+      name: ['ryan', 'ryan2'],
     })
   })
 })

package/tests/Test.utils.ts

@@ -1,13 +1,13 @@
-import { APIGatewayEvent, Context, SQSEvent } from "aws-lambda"
-import { z } from "zod"
+import { APIGatewayEvent, Context, SQSEvent } from 'aws-lambda'
+import { z } from 'zod'
 
-import Transaction from "../src/BaseEvent/Transaction"
-import Globals from "../src/Globals"
+import Transaction from '../src/BaseEvent/Transaction'
+import Globals from '../src/Globals'
 
 export const defaultHeaders = {
-  "Access-Control-Allow-Credentials": true,
-  "Access-Control-Allow-Origin": "*",
-  "Content-Type": "application/json",
+  'Access-Control-Allow-Credentials': true,
+  'Access-Control-Allow-Origin': '*',
+  'Content-Type': 'application/json',
 }
 
 export const defaultUrl = `localhost:${Globals.Listener_HTTP_DefaultPort}`
@@ -66,10 +66,10 @@ export function observableContext(data?: any) {
   })
 }
 
-export const privateKey = "tMHOuszBQmF6XtwgrUpvqpk07rh3RATX"
+export const privateKey = 'tMHOuszBQmF6XtwgrUpvqpk07rh3RATX'
 
 export const foreignToken =
-  "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c"
+  'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c'
 
 export const ViewSchema = z.object({
   id: z.string(),