@creator.co/wapi 1.2.2 → 1.2.3

package/tests/BaseEvent/EventProcessor.test.ts

@@ -1,36 +1,34 @@
-import { expect as j_expect } from "@jest/globals"
-import { expect } from "chai"
+import { expect as j_expect } from '@jest/globals'
+import { expect } from 'chai'
 
-import Response from "../../src/API/Response"
-import EventProcessor from "../../src/BaseEvent/EventProcessor"
-import Globals from "../../src/Globals"
-import { emptyQueueEvent, observableContext } from "../Test.utils"
+import Response from '../../src/API/Response'
+import EventProcessor from '../../src/BaseEvent/EventProcessor'
+import Globals from '../../src/Globals'
+import { emptyQueueEvent, observableContext } from '../Test.utils'
 
-describe("EventProcessor success invocation path", () => {
-  test("Simple success", async () => {
-    const b = { name: "123" }
+describe('EventProcessor success invocation path', () => {
+  test('Simple success', async () => {
+    const b = { name: '123' }
     const context = observableContext()
     const transaction = new EventProcessor(
       emptyQueueEvent({
         Records: [{ body: JSON.stringify(b) }, { body: JSON.stringify(b) }],
       }),
       context,
-      {},
+      {}
     )
     let count = 0
-    const handlerResp = await transaction.processEvent(
-      async (transaction, eventRecord) => {
-        expect(eventRecord).to.be.deep.equal(b)
-        count++
-        return Response.SuccessResponse(null)
-      },
-    )
+    const handlerResp = await transaction.processEvent(async (transaction, eventRecord) => {
+      expect(eventRecord).to.be.deep.equal(b)
+      count++
+      return Response.SuccessResponse(null)
+    })
     // check resp
     expect(count).to.be.equals(2)
     expect(handlerResp).to.be.an.instanceof(Response)
     if (handlerResp instanceof Response) {
       expect(handlerResp?.getBody()).to.be.deep.equal({
-        transactionID: "unknown",
+        transactionID: 'unknown',
       })
       expect(handlerResp.getCode()).to.be.equal(200)
     }
@@ -40,31 +38,28 @@ describe("EventProcessor success invocation path", () => {
     j_expect(context.succeed).not.toBeCalled()
   })
 
-  test("Simple success - do not decode", async () => {
-    const b = { name: "123" }
+  test('Simple success - do not decode', async () => {
+    const b = { name: '123' }
     const context = observableContext()
     const transaction = new EventProcessor(
       emptyQueueEvent({
         Records: [{ body: JSON.stringify(b) }, { body: JSON.stringify(b) }],
       }),
       context,
-      {},
+      {}
     )
     let count = 0
-    const handlerResp = await transaction.processEvent(
-      async (transaction, eventRecord) => {
-        expect(eventRecord).to.be.deep.equal(JSON.stringify(b))
-        count++
-        return Response.SuccessResponse(null)
-      },
-      true,
-    )
+    const handlerResp = await transaction.processEvent(async (transaction, eventRecord) => {
+      expect(eventRecord).to.be.deep.equal(JSON.stringify(b))
+      count++
+      return Response.SuccessResponse(null)
+    }, true)
     // check resp
     expect(count).to.be.equals(2)
     expect(handlerResp).to.be.an.instanceof(Response)
     if (handlerResp instanceof Response) {
       expect(handlerResp?.getBody()).to.be.deep.equal({
-        transactionID: "unknown",
+        transactionID: 'unknown',
       })
       expect(handlerResp.getCode()).to.be.equal(200)
     }
@@ -75,34 +70,30 @@ describe("EventProcessor success invocation path", () => {
   })
 })
 
-describe("EventProcessor failure invocation path", () => {
-  test("Simple failure", async () => {
-    const b = { name: "123" }
+describe('EventProcessor failure invocation path', () => {
+  test('Simple failure', async () => {
+    const b = { name: '123' }
     const context = observableContext()
     const transaction = new EventProcessor(
       emptyQueueEvent({
         Records: [
           { body: JSON.stringify(b) },
-          { messageId: "123", body: JSON.stringify(b) },
+          { messageId: '123', body: JSON.stringify(b) },
           { body: JSON.stringify(b) },
         ],
       }),
       context,
-      {},
+      {}
     )
     let count = 0
     let handlerResp: any = null,
       err: any = null
     try {
-      handlerResp = await transaction.processEvent(
-        async (transaction, eventRecord) => {
-          expect(eventRecord).to.be.deep.equal(b)
-          count++
-          return count == 1
-            ? Response.SuccessResponse(null)
-            : Response.BadRequestResponse("Failed!")
-        },
-      )
+      handlerResp = await transaction.processEvent(async (transaction, eventRecord) => {
+        expect(eventRecord).to.be.deep.equal(b)
+        count++
+        return count == 1 ? Response.SuccessResponse(null) : Response.BadRequestResponse('Failed!')
+      })
     } catch (e) {
       err = e
     }
@@ -112,10 +103,10 @@ describe("EventProcessor failure invocation path", () => {
     expect(err).to.be.deep.equal(
       new Error(
         JSON.stringify({
-          err: "Failed!",
-          transactionID: "unknown",
-        }),
-      ),
+          err: 'Failed!',
+          transactionID: 'unknown',
+        })
+      )
     )
     // ctx
     j_expect(context.fail).not.toBeCalled()
@@ -123,19 +114,19 @@ describe("EventProcessor failure invocation path", () => {
     j_expect(context.succeed).not.toBeCalled()
   })
 
-  test("Simple failure w/ null", async () => {
-    const b = { name: "123" }
+  test('Simple failure w/ null', async () => {
+    const b = { name: '123' }
     const context = observableContext()
     const transaction = new EventProcessor(
       emptyQueueEvent({
         Records: [
           { body: JSON.stringify(b) },
-          { messageId: "123", body: JSON.stringify(b) },
+          { messageId: '123', body: JSON.stringify(b) },
           { body: JSON.stringify(b) },
         ],
       }),
       context,
-      {},
+      {}
     )
     let count = 0
     let handlerResp: any = null,
@@ -147,7 +138,7 @@ describe("EventProcessor failure invocation path", () => {
           expect(eventRecord).to.be.deep.equal(b)
           count++
           return null
-        },
+        }
       )
     } catch (e) {
       err = e
@@ -161,9 +152,9 @@ describe("EventProcessor failure invocation path", () => {
           err: Globals.ErrorResponseInvalidServerResponse,
           rollback: true,
           errCode: Globals.ErrorCode_APIError,
-          transactionID: "unknown",
-        }),
-      ),
+          transactionID: 'unknown',
+        })
+      )
     )
     // ctx
     j_expect(context.fail).not.toBeCalled()
@@ -171,34 +162,27 @@ describe("EventProcessor failure invocation path", () => {
     j_expect(context.succeed).not.toBeCalled()
   })
 
-  test("Simple failure - allow failures", async () => {
-    const b = { name: "123" }
+  test('Simple failure - allow failures', async () => {
+    const b = { name: '123' }
     const context = observableContext()
     const transaction = new EventProcessor(
       emptyQueueEvent({
-        Records: [
-          { body: JSON.stringify(b) },
-          { messageId: "123", body: JSON.stringify(b) },
-        ],
+        Records: [{ body: JSON.stringify(b) }, { messageId: '123', body: JSON.stringify(b) }],
       }),
       context,
       {},
-      true,
+      true
     )
     let count = 0
-    const handlerResp = await transaction.processEvent(
-      async (transaction, eventRecord) => {
-        expect(eventRecord).to.be.deep.equal(b)
-        count++
-        return count == 1
-          ? Response.SuccessResponse(null)
-          : Response.BadRequestResponse("Failed!")
-      },
-    )
+    const handlerResp = await transaction.processEvent(async (transaction, eventRecord) => {
+      expect(eventRecord).to.be.deep.equal(b)
+      count++
+      return count == 1 ? Response.SuccessResponse(null) : Response.BadRequestResponse('Failed!')
+    })
     // check resp
     expect(count).to.be.equals(2)
     expect(handlerResp).to.be.deep.equal({
-      batchItemFailures: [{ itemIdentifier: "123" }],
+      batchItemFailures: [{ itemIdentifier: '123' }],
     })
     // ctx
     j_expect(context.fail).not.toBeCalled()
@@ -206,19 +190,19 @@ describe("EventProcessor failure invocation path", () => {
     j_expect(context.succeed).not.toBeCalled()
   })
 
-  test("Simple failure w/ null response - allow failures", async () => {
-    const b = { name: "123" }
+  test('Simple failure w/ null response - allow failures', async () => {
+    const b = { name: '123' }
     const context = observableContext()
     const transaction = new EventProcessor(
       emptyQueueEvent({
         Records: [
-          { messageId: "456", body: JSON.stringify(b) },
-          { messageId: "123", body: JSON.stringify(b) },
+          { messageId: '456', body: JSON.stringify(b) },
+          { messageId: '123', body: JSON.stringify(b) },
         ],
       }),
       context,
       {},
-      true,
+      true
     )
     let count = 0
     const handlerResp = await transaction.processEvent(
@@ -227,12 +211,12 @@ describe("EventProcessor failure invocation path", () => {
         expect(eventRecord).to.be.deep.equal(b)
         count++
         return null
-      },
+      }
     )
     // check resp
     expect(count).to.be.equals(2)
     expect(handlerResp).to.be.deep.equal({
-      batchItemFailures: [{ itemIdentifier: "456" }, { itemIdentifier: "123" }],
+      batchItemFailures: [{ itemIdentifier: '456' }, { itemIdentifier: '123' }],
     })
     // ctx
     j_expect(context.fail).not.toBeCalled()
@@ -240,7 +224,7 @@ describe("EventProcessor failure invocation path", () => {
     j_expect(context.succeed).not.toBeCalled()
   })
 
-  test("Simple failure no records", async () => {
+  test('Simple failure no records', async () => {
     const context = observableContext()
     const transaction = new EventProcessor(emptyQueueEvent(), context, {})
     let count = 0
@@ -252,7 +236,7 @@ describe("EventProcessor failure invocation path", () => {
         async () => {
           count++
           return null
-        },
+        }
       )
     } catch (e) {
       err = e
@@ -265,8 +249,8 @@ describe("EventProcessor failure invocation path", () => {
         JSON.stringify({
           err: Globals.ErrorResponseNoRecords,
           errCode: Globals.ErrorCode_NoRecords,
-        }),
-      ),
+        })
+      )
     )
     // ctx
     j_expect(context.fail).not.toBeCalled()

package/tests/BaseEvent/Process.test.ts

@@ -1,11 +1,11 @@
-import { expect } from "chai"
+import { expect } from 'chai'
 
-import Response from "../../src/API/Response"
-import Process from "../../src/BaseEvent/Process"
+import Response from '../../src/API/Response'
+import Process from '../../src/BaseEvent/Process'
 
-describe("Process success invocation path", () => {
-  test("Simple success", async () => {
-    const b = { name: "123" }
+describe('Process success invocation path', () => {
+  test('Simple success', async () => {
+    const b = { name: '123' }
     const proc = new Process({}, 100)
     let count = 0
     const handlerResp = await proc.execute(async () => {
@@ -15,7 +15,7 @@ describe("Process success invocation path", () => {
     // check resp
     expect(handlerResp).to.be.undefined
     // check iterations
-    return new Promise((resolve) => {
+    return new Promise(resolve => {
       setTimeout(() => {
         expect(count).to.be.equals(2)
         clearInterval(proc.interval)
@@ -25,18 +25,18 @@ describe("Process success invocation path", () => {
   })
 })
 
-describe("Process failure invocation path", () => {
-  test("Simple failure", async () => {
+describe('Process failure invocation path', () => {
+  test('Simple failure', async () => {
     const proc = new Process({}, 100)
     let count = 0
     const handlerResp = await proc.execute(async () => {
       count++
-      throw new Error("Failed!")
+      throw new Error('Failed!')
     })
     // check resp
     expect(handlerResp).to.be.undefined
     // check iterations
-    return new Promise((resolve) => {
+    return new Promise(resolve => {
       setTimeout(() => {
         expect(count).to.be.equals(2)
         clearInterval(proc.interval)

package/tests/BaseEvent/Transaction.test.ts

@@ -1,14 +1,14 @@
-import { expect as j_expect } from "@jest/globals"
-import { expect } from "chai"
+import { expect as j_expect } from '@jest/globals'
+import { expect } from 'chai'
 
-import Response from "../../src/API/Response"
-import Transaction from "../../src/BaseEvent/Transaction"
-import Globals from "../../src/Globals"
-import { defaultHeaders, emptyEvent, observableContext } from "../Test.utils"
+import Response from '../../src/API/Response'
+import Transaction from '../../src/BaseEvent/Transaction'
+import Globals from '../../src/Globals'
+import { defaultHeaders, emptyEvent, observableContext } from '../Test.utils'
 
-describe("Transaction success invocation path", () => {
-  test("Simple success", async () => {
-    const b = { name: "123" }
+describe('Transaction success invocation path', () => {
+  test('Simple success', async () => {
+    const b = { name: '123' }
     const context = observableContext()
     const transaction = new Transaction<null, typeof b>(emptyEvent(), context)
     const handlerResp = await transaction.execute(async () => {
@@ -26,8 +26,8 @@ describe("Transaction success invocation path", () => {
     })
   })
 
-  test("Simple success - sync return", async () => {
-    const b = { name: "123" }
+  test('Simple success - sync return', async () => {
+    const b = { name: '123' }
     const context = observableContext()
     const transaction = new Transaction<null, typeof b>(emptyEvent(), context, {
       syncReturn: true,
@@ -46,15 +46,15 @@ describe("Transaction success invocation path", () => {
   })
 })
 
-describe("Transaction error invocation path without response", () => {
-  test("Not valid response returned success", async () => {
+describe('Transaction error invocation path without response', () => {
+  test('Not valid response returned success', async () => {
     const b = {
       err: Globals.ErrorResponseInvalidServerResponse,
       rollback: true,
       errCode: Globals.ErrorCode_APIError,
-      transactionID: "123",
+      transactionID: '123',
     }
-    const context = observableContext({ awsRequestId: "123" })
+    const context = observableContext({ awsRequestId: '123' })
     const transaction = new Transaction<null, typeof b>(emptyEvent(), context)
     const handlerResp = await transaction.execute(async () => {
       return null
@@ -71,22 +71,22 @@ describe("Transaction error invocation path without response", () => {
     })
   })
 
-  test("Not valid response returned success - sync return", async () => {
+  test('Not valid response returned success - sync return', async () => {
     const b = {
       err: Globals.ErrorResponseInvalidServerResponse,
       rollback: true,
       errCode: Globals.ErrorCode_APIError,
-      transactionID: "123",
+      transactionID: '123',
     }
     const context = observableContext()
     const transaction = new Transaction<null, typeof b>(
       emptyEvent({
-        requestContext: { requestId: "123" },
+        requestContext: { requestId: '123' },
       }),
       context,
       {
         syncReturn: true,
-      },
+      }
     )
     const handlerResp = await transaction.execute(async () => {
       return null
@@ -102,20 +102,17 @@ describe("Transaction error invocation path without response", () => {
   })
 })
 
-describe("Transaction error invocation path with non-Response class response", () => {
-  test("Not a response-class response returned success", async () => {
+describe('Transaction error invocation path with non-Response class response', () => {
+  test('Not a response-class response returned success', async () => {
     const b = {
       err: Globals.ErrorResponseInvalidServerResponse,
       rollback: true,
       errCode: Globals.ErrorCode_APIError,
-      transactionID: "unknown",
+      transactionID: 'unknown',
     }
-    const b2 = { name: "abc" }
+    const b2 = { name: 'abc' }
     const context = observableContext()
-    const transaction = new Transaction<null, null, typeof b2>(
-      emptyEvent(),
-      context,
-    )
+    const transaction = new Transaction<null, null, typeof b2>(emptyEvent(), context)
     const handlerResp = await transaction.execute(async () => {
       return b2
     })
@@ -131,14 +128,12 @@ describe("Transaction error invocation path with non-Response class response", (
     })
   })
 
-  test("Not a response-class response returned success - sync return", async () => {
-    const b2 = { name: "abc" }
+  test('Not a response-class response returned success - sync return', async () => {
+    const b2 = { name: 'abc' }
     const context = observableContext()
-    const transaction = new Transaction<null, null, typeof b2>(
-      emptyEvent(),
-      context,
-      { syncReturn: true },
-    )
+    const transaction = new Transaction<null, null, typeof b2>(emptyEvent(), context, {
+      syncReturn: true,
+    })
     const handlerResp = await transaction.execute(async () => {
       return b2
     })
@@ -151,18 +146,18 @@ describe("Transaction error invocation path with non-Response class response", (
   })
 })
 
-describe("Transaction error invocation path with exception", () => {
-  test("Transaction exception", async () => {
+describe('Transaction error invocation path with exception', () => {
+  test('Transaction exception', async () => {
     const b = {
       err: Globals.ErrorResponseUnhandledError,
       rollback: true,
       errCode: Globals.ErrorCode_APIError,
-      transactionID: "unknown",
+      transactionID: 'unknown',
     }
     const context = observableContext()
     const transaction = new Transaction<null, null, null>(emptyEvent(), context)
     const handlerResp = await transaction.execute(async () => {
-      throw new Error("Failed!")
+      throw new Error('Failed!')
     })
     // check resp
     expect(handlerResp).to.be.null
@@ -176,21 +171,19 @@ describe("Transaction error invocation path with exception", () => {
     })
   })
 
-  test("Transaction exception - sync return", async () => {
+  test('Transaction exception - sync return', async () => {
     const b = {
       err: Globals.ErrorResponseUnhandledError,
       rollback: true,
       errCode: Globals.ErrorCode_APIError,
-      transactionID: "unknown",
+      transactionID: 'unknown',
     }
     const context = observableContext()
-    const transaction = new Transaction<null, null, null>(
-      emptyEvent(),
-      context,
-      { syncReturn: true },
-    )
+    const transaction = new Transaction<null, null, null>(emptyEvent(), context, {
+      syncReturn: true,
+    })
     const handlerResp = await transaction.execute(async () => {
-      throw new Error("Failed!")
+      throw new Error('Failed!')
     })
     // check resp
     expect(handlerResp?.getBody()).to.be.deep.equals(b)
@@ -201,14 +194,12 @@ describe("Transaction error invocation path with exception", () => {
     j_expect(context.succeed).not.toBeCalled()
   })
 
-  test("Transaction exception - sync return", async () => {
+  test('Transaction exception - sync return', async () => {
     const context = observableContext()
-    const transaction = new Transaction<null, null, null>(
-      emptyEvent(),
-      context,
-      { throwOnErrors: true },
-    )
-    const error = new Error("Failed!")
+    const transaction = new Transaction<null, null, null>(emptyEvent(), context, {
+      throwOnErrors: true,
+    })
+    const error = new Error('Failed!')
     let handlerResp: any = null,
       err: any = null
     try {