@creator.co/wapi 1.2.2 → 1.2.3

package/tests/Server/lib/ContainerServer.test.ts

@@ -1,12 +1,12 @@
-import { expect as j_expect } from "@jest/globals"
-import { expect } from "chai"
-import * as request from "supertest"
-import { z } from "zod"
+import { expect as j_expect } from '@jest/globals'
+import { expect } from 'chai'
+import * as request from 'supertest'
+import { z } from 'zod'
 
-import Response from "../../../src/API/Response"
-import Globals from "../../../src/Globals"
-import ContainerServer from "../../../src/Server/lib/ContainerServer"
-import { defaultUrl } from "../../Test.utils"
+import Response from '../../../src/API/Response'
+import Globals from '../../../src/Globals'
+import ContainerServer from '../../../src/Server/lib/ContainerServer'
+import { defaultUrl } from '../../Test.utils'
 
 export const ViewSchema = z.object({
   id: z.string(),
@@ -15,12 +15,12 @@ export const ViewSchema = z.object({
   updatedAt: z.string(),
 })
 
-describe("Container server routing", () => {
+describe('Container server 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()
@@ -29,35 +29,35 @@ describe("Container server routing", () => {
     mockExit.mockReset()
   })
 
-  test("Health & 404 handler", async () => {
+  test('Health & 404 handler', async () => {
     const server = new ContainerServer({ routes: [] })
     await server.start()
     // 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!')
     // Not handled
     await request(defaultUrl)
       .get(`/abc`)
-      .expect("Content-Type", "application/json; charset=utf-8")
+      .expect('Content-Type', 'application/json; charset=utf-8')
       .expect(404)
 
     // Unload
-    await server.stop("Error")
+    await server.stop('Error')
     j_expect(mockExit).toHaveBeenCalledTimes(1)
     j_expect(mockExit).toBeCalledWith(1)
   })
 
-  test("Simple route", async () => {
+  test('Simple route', async () => {
     const server = new ContainerServer({
       routes: [
         {
-          path: "/abc",
-          method: "get",
+          path: '/abc',
+          method: 'get',
           handler: async () => {
-            return Response.SimpleResponse({ name: "abc" })
+            return Response.SimpleResponse({ name: 'abc' })
           },
         },
       ],
@@ -66,39 +66,39 @@ describe("Container server routing", () => {
     // 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!')
     // Found route
     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["name"]).to.be.deep.equals("abc")
-    expect(resG.body["transactionID"]).to.not.be.null
+    expect(resG.body['name']).to.be.deep.equals('abc')
+    expect(resG.body['transactionID']).to.not.be.null
     // Found route, but not method
     await request(defaultUrl)
       .post(`/abc`)
-      .expect("Content-Type", "application/json; charset=utf-8")
+      .expect('Content-Type', 'application/json; charset=utf-8')
       .expect(404)
     // Not found route
     await request(defaultUrl)
       .get(`/abc/123`)
-      .expect("Content-Type", "application/json; charset=utf-8")
+      .expect('Content-Type', 'application/json; charset=utf-8')
       .expect(404)
     // Unload
-    await server.stop("Error")
+    await server.stop('Error')
     j_expect(mockExit).toHaveBeenCalledTimes(1)
     j_expect(mockExit).toBeCalledWith(1)
   })
 })
 
-describe("Container server basics", () => {
+describe('Container server basics', () => {
   // @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()
@@ -107,17 +107,17 @@ describe("Container server basics", () => {
     mockExit.mockReset()
   })
 
-  test("Starts with exports", async () => {
+  test('Starts with exports', async () => {
     const server = new ContainerServer({ routes: [] })
     server.getExport()
-    return new Promise((resolve) => {
+    return new Promise(resolve => {
       setTimeout(async () => {
         // 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!')
         // Unload
         await server.stop()
         j_expect(mockExit).toHaveBeenCalledTimes(1)
@@ -127,11 +127,11 @@ describe("Container server basics", () => {
     })
   })
 
-  test("Stops if process sends message SIGINT", async () => {
+  test('Stops if process sends message SIGINT', async () => {
     const server = new ContainerServer({ routes: [] })
     await server.start()
-    process.emit("SIGINT")
-    return new Promise((resolve) => {
+    process.emit('SIGINT')
+    return new Promise(resolve => {
       setTimeout(async () => {
         j_expect(mockExit).toHaveBeenCalledTimes(1)
         j_expect(mockExit).toBeCalledWith(0)
@@ -140,12 +140,12 @@ describe("Container server basics", () => {
     })
   }, 10000)
 
-  test("Stops if process sends message unhandledRejection", async () => {
+  test('Stops if process sends message unhandledRejection', async () => {
     const server = new ContainerServer({ routes: [] })
     await server.start()
     // @ts-ignore
-    process.emit("unhandledRejection")
-    return new Promise((resolve) => {
+    process.emit('unhandledRejection')
+    return new Promise(resolve => {
       setTimeout(async () => {
         j_expect(mockExit).toHaveBeenCalledTimes(1)
         j_expect(mockExit).toBeCalledWith(0)
@@ -155,12 +155,12 @@ describe("Container server basics", () => {
   }, 10000)
 })
 
-describe("Container server validation", () => {
+describe('Container server validation', () => {
   // @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()
@@ -170,24 +170,22 @@ describe("Container server validation", () => {
   })
 
   function validateValidationFailure(res: any, failureCount?: number) {
-    expect(res.body["err"]).to.be.equals(Globals.ErrorResponseValidationFail)
-    expect(res.body["errCode"]).to.be.equals(Globals.ErrorCode_InvalidInput)
-    expect(res.body["transactionID"]).to.not.be.null
-    expect(res.body["transactionID"]).to.be.an("string")
-    expect(res.body["validationFailure"]?.length).to.be.equals(
-      failureCount || 4,
-    )
+    expect(res.body['err']).to.be.equals(Globals.ErrorResponseValidationFail)
+    expect(res.body['errCode']).to.be.equals(Globals.ErrorCode_InvalidInput)
+    expect(res.body['transactionID']).to.not.be.null
+    expect(res.body['transactionID']).to.be.an('string')
+    expect(res.body['validationFailure']?.length).to.be.equals(failureCount || 4)
   }
 
-  test("Validates empty body", async () => {
+  test('Validates empty body', async () => {
     const server = new ContainerServer({
       routes: [
         {
-          path: "/abc",
-          method: "post",
+          path: '/abc',
+          method: 'post',
           inputSchema: ViewSchema,
           handler: async () => {
-            return Response.SimpleResponse({ name: "abc" })
+            return Response.SimpleResponse({ name: 'abc' })
           },
         },
       ],
@@ -196,21 +194,21 @@ describe("Container server validation", () => {
     // Validation fails, empty body
     const resG = await request(defaultUrl)
       .post(`/abc`)
-      .expect("Content-Type", "application/json; charset=utf-8")
+      .expect('Content-Type', 'application/json; charset=utf-8')
       .expect(400)
     validateValidationFailure(resG)
     await server.stop()
   })
 
-  test("Validates empty string body", async () => {
+  test('Validates empty string body', async () => {
     const server = new ContainerServer({
       routes: [
         {
-          path: "/abc",
-          method: "post",
+          path: '/abc',
+          method: 'post',
           inputSchema: ViewSchema,
           handler: async () => {
-            return Response.SimpleResponse({ name: "abc" })
+            return Response.SimpleResponse({ name: 'abc' })
           },
         },
       ],
@@ -219,22 +217,22 @@ describe("Container server validation", () => {
     // Validation fails, empty body
     const resG = await request(defaultUrl)
       .post(`/abc`)
-      .send("")
-      .expect("Content-Type", "application/json; charset=utf-8")
+      .send('')
+      .expect('Content-Type', 'application/json; charset=utf-8')
       .expect(400)
     validateValidationFailure(resG)
     await server.stop()
   })
 
-  test("Validates empty object body", async () => {
+  test('Validates empty object body', async () => {
     const server = new ContainerServer({
       routes: [
         {
-          path: "/abc",
-          method: "post",
+          path: '/abc',
+          method: 'post',
           inputSchema: ViewSchema,
           handler: async () => {
-            return Response.SimpleResponse({ name: "abc" })
+            return Response.SimpleResponse({ name: 'abc' })
           },
         },
       ],
@@ -244,21 +242,21 @@ describe("Container server validation", () => {
     const resG = await request(defaultUrl)
       .post(`/abc`)
       .send({})
-      .expect("Content-Type", "application/json; charset=utf-8")
+      .expect('Content-Type', 'application/json; charset=utf-8')
       .expect(400)
     validateValidationFailure(resG)
     await server.stop()
   })
 
-  test("Validates missing props body", async () => {
+  test('Validates missing props body', async () => {
     const server = new ContainerServer({
       routes: [
         {
-          path: "/abc",
-          method: "post",
+          path: '/abc',
+          method: 'post',
           inputSchema: ViewSchema,
           handler: async () => {
-            return Response.SimpleResponse({ name: "abc" })
+            return Response.SimpleResponse({ name: 'abc' })
           },
         },
       ],
@@ -267,22 +265,22 @@ describe("Container server validation", () => {
     // Validation fails, empty body
     const resG = await request(defaultUrl)
       .post(`/abc`)
-      .send({ id: "123" })
-      .expect("Content-Type", "application/json; charset=utf-8")
+      .send({ id: '123' })
+      .expect('Content-Type', 'application/json; charset=utf-8')
       .expect(400)
     validateValidationFailure(resG, 3)
     await server.stop()
   })
 
-  test("Validates wrong type props body", async () => {
+  test('Validates wrong type props body', async () => {
     const server = new ContainerServer({
       routes: [
         {
-          path: "/abc",
-          method: "post",
+          path: '/abc',
+          method: 'post',
           inputSchema: ViewSchema,
           handler: async () => {
-            return Response.SimpleResponse({ name: "abc" })
+            return Response.SimpleResponse({ name: 'abc' })
           },
         },
       ],
@@ -292,21 +290,21 @@ describe("Container server validation", () => {
     const resG = await request(defaultUrl)
       .post(`/abc`)
       .send({ id: 123 })
-      .expect("Content-Type", "application/json; charset=utf-8")
+      .expect('Content-Type', 'application/json; charset=utf-8')
       .expect(400)
     validateValidationFailure(resG)
     await server.stop()
   })
 
-  test("Validates successfully", async () => {
+  test('Validates successfully', async () => {
     const server = new ContainerServer({
       routes: [
         {
-          path: "/abc",
-          method: "post",
+          path: '/abc',
+          method: 'post',
           inputSchema: ViewSchema,
           handler: async () => {
-            return Response.SimpleResponse({ name: "abc" })
+            return Response.SimpleResponse({ name: 'abc' })
           },
         },
       ],
@@ -316,12 +314,12 @@ describe("Container server validation", () => {
     await request(defaultUrl)
       .post(`/abc`)
       .send({
-        id: "123",
-        content: "123",
+        id: '123',
+        content: '123',
         createdAt: new Date(),
         updatedAt: new Date(),
       })
-      .expect("Content-Type", "application/json; charset=utf-8")
+      .expect('Content-Type', 'application/json; charset=utf-8')
       .expect(200)
     await server.stop()
   })

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

@@ -1,9 +1,9 @@
-import { expect } from "chai"
+import { expect } from 'chai'
 
-import Server from "../../../src/Server/lib/Server"
+import Server from '../../../src/Server/lib/Server'
 
-describe("Server basics", () => {
-  test("Works", async () => {
+describe('Server basics', () => {
+  test('Works', async () => {
     const server = new Server({ routes: [] })
     expect(server.getExport()).to.not.be.undefined
   })

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

@@ -1,10 +1,10 @@
-import { expect as j_expect } from "@jest/globals"
-import { APIGatewayProxyEvent, Context } from "aws-lambda"
-import { expect } from "chai"
-import { Request, Response } from "express"
+import { expect as j_expect } from '@jest/globals'
+import { APIGatewayProxyEvent, Context } from 'aws-lambda'
+import { expect } from 'chai'
+import { Request, Response } from 'express'
 
-import Globals from "../../../../src/Globals"
-import GenericHandler from "../../../../src/Server/lib/container/GenericHandler"
+import Globals from '../../../../src/Globals'
+import GenericHandler from '../../../../src/Server/lib/container/GenericHandler'
 
 function observableResponse(): Response {
   const resp = <Response>(<unknown>{
@@ -16,17 +16,15 @@ function observableResponse(): Response {
   return resp
 }
 
-describe("GenericHandler success invocation path", () => {
-  test("Simple success", async () => {
+describe('GenericHandler success invocation path', () => {
+  test('Simple success', async () => {
     const v = {
       statusCode: 200,
       body: JSON.stringify({ id: 123 }),
     }
-    const handler = GenericHandler(
-      async (event: APIGatewayProxyEvent, context: Context) => {
-        context.succeed(v)
-      },
-    )
+    const handler = GenericHandler(async (event: APIGatewayProxyEvent, context: Context) => {
+      context.succeed(v)
+    })
     const resp = observableResponse()
     const handlerResp = await handler(<Request>(<unknown>{}), resp)
     //
@@ -37,17 +35,15 @@ describe("GenericHandler success invocation path", () => {
     j_expect(resp.header).not.toBeCalled()
   })
 
-  test("Simple success w/ headers", async () => {
+  test('Simple success w/ headers', async () => {
     const v = {
       statusCode: 200,
       body: JSON.stringify({ id: 123 }),
       headers: { Authorization: 123 },
     }
-    const handler = GenericHandler(
-      async (event: APIGatewayProxyEvent, context: Context) => {
-        context.succeed(v)
-      },
-    )
+    const handler = GenericHandler(async (event: APIGatewayProxyEvent, context: Context) => {
+      context.succeed(v)
+    })
     const resp = observableResponse()
     const handlerResp = await handler(<Request>(<unknown>{}), resp)
     //
@@ -58,16 +54,14 @@ describe("GenericHandler success invocation path", () => {
     j_expect(resp.header).toBeCalledTimes(Object.keys(v.headers).length)
   })
 
-  test("Simple success w/ null body", async () => {
+  test('Simple success w/ null body', async () => {
     const v = {
       statusCode: 200,
       headers: { Authorization: 123 },
     }
-    const handler = GenericHandler(
-      async (event: APIGatewayProxyEvent, context: Context) => {
-        context.succeed(v)
-      },
-    )
+    const handler = GenericHandler(async (event: APIGatewayProxyEvent, context: Context) => {
+      context.succeed(v)
+    })
     const resp = observableResponse()
     const handlerResp = await handler(<Request>(<unknown>{}), resp)
     //
@@ -79,13 +73,11 @@ describe("GenericHandler success invocation path", () => {
   })
 })
 
-describe("GenericHandler failure invocation path", () => {
-  test("Invalid response", async () => {
-    const handler = GenericHandler(
-      async (event: APIGatewayProxyEvent, context: Context) => {
-        context.succeed(null)
-      },
-    )
+describe('GenericHandler failure invocation path', () => {
+  test('Invalid response', async () => {
+    const handler = GenericHandler(async (event: APIGatewayProxyEvent, context: Context) => {
+      context.succeed(null)
+    })
     const resp = observableResponse()
     const handlerResp = await handler(<Request>(<unknown>{}), resp)
     //
@@ -99,13 +91,11 @@ describe("GenericHandler failure invocation path", () => {
     j_expect(resp.status).toBeCalledWith(Globals.Resp_STATUSCODE_INVALIDRESP)
   })
 
-  test("Error response", async () => {
-    const err = new Error("Failed!")
-    const handler = GenericHandler(
-      async (event: APIGatewayProxyEvent, context: Context) => {
-        context.fail(err)
-      },
-    )
+  test('Error response', async () => {
+    const err = new Error('Failed!')
+    const handler = GenericHandler(async (event: APIGatewayProxyEvent, context: Context) => {
+      context.fail(err)
+    })
     const resp = observableResponse()
     const handlerResp = await handler(<Request>(<unknown>{}), resp)
     //
@@ -118,8 +108,8 @@ describe("GenericHandler failure invocation path", () => {
     j_expect(resp.status).toBeCalledWith(400)
   })
 
-  test("Exception response", async () => {
-    const err = new Error("Failed!")
+  test('Exception response', async () => {
+    const err = new Error('Failed!')
     const handler = GenericHandler(async () => {
       throw err
     })