@creator.co/wapi 1.7.1-alpha4 → 1.7.1

package/tests/BaseEvent/EventProcessor.test.ts

@@ -0,0 +1,261 @@
+import { expect as c_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'
+
+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) => {
+      c_expect(eventRecord).to.be.deep.equal(b)
+      count++
+      return Response.SuccessResponse(null)
+    })
+    // check resp
+    c_expect(count).to.be.equals(2)
+    c_expect(handlerResp).to.be.an.instanceof(Response)
+    if (handlerResp instanceof Response) {
+      c_expect(handlerResp?.getBody()).to.be.deep.equal({
+        transactionID: 'unknown',
+      })
+      c_expect(handlerResp.getCode()).to.be.equal(200)
+    }
+    // ctx
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).not.toBeCalled()
+  })
+
+  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) => {
+      c_expect(eventRecord).to.be.deep.equal(JSON.stringify(b))
+      count++
+      return Response.SuccessResponse(null)
+    }, true)
+    // check resp
+    c_expect(count).to.be.equals(2)
+    c_expect(handlerResp).to.be.an.instanceof(Response)
+    if (handlerResp instanceof Response) {
+      c_expect(handlerResp?.getBody()).to.be.deep.equal({
+        transactionID: 'unknown',
+      })
+      c_expect(handlerResp.getCode()).to.be.equal(200)
+    }
+    // ctx
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).not.toBeCalled()
+  })
+})
+
+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) },
+          { body: JSON.stringify(b) },
+        ],
+      }),
+      context,
+      {}
+    )
+    let count = 0
+    let handlerResp: any = null,
+      err: any = null
+    try {
+      handlerResp = await transaction.processEvent(async (transaction, eventRecord) => {
+        c_expect(eventRecord).to.be.deep.equal(b)
+        count++
+        return count == 1 ? Response.SuccessResponse(null) : Response.BadRequestResponse('Failed!')
+      })
+    } catch (e) {
+      err = e
+    }
+    // check resp
+    c_expect(count).to.be.equals(2)
+    c_expect(handlerResp).to.be.null
+    c_expect(err).to.be.deep.equal(
+      new Error(
+        JSON.stringify({
+          err: 'Failed!',
+          transactionID: 'unknown',
+        })
+      )
+    )
+    // ctx
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).not.toBeCalled()
+  })
+
+  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) },
+          { body: JSON.stringify(b) },
+        ],
+      }),
+      context,
+      {}
+    )
+    let count = 0
+    let handlerResp: any = null,
+      err: any = null
+    try {
+      handlerResp = await transaction.processEvent(
+        // @ts-ignore
+        async (transaction, eventRecord) => {
+          c_expect(eventRecord).to.be.deep.equal(b)
+          count++
+          return null
+        }
+      )
+    } catch (e) {
+      err = e
+    }
+    // check resp
+    c_expect(count).to.be.equals(1)
+    c_expect(handlerResp).to.be.null
+    c_expect(err).to.be.deep.equal(
+      new Error(
+        JSON.stringify({
+          err: Globals.ErrorResponseInvalidServerResponse,
+          rollback: true,
+          errCode: Globals.ErrorCode_APIError,
+          transactionID: 'unknown',
+        })
+      )
+    )
+    // ctx
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).not.toBeCalled()
+  })
+
+  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) }],
+      }),
+      context,
+      {},
+      true
+    )
+    let count = 0
+    const handlerResp = await transaction.processEvent(async (transaction, eventRecord) => {
+      c_expect(eventRecord).to.be.deep.equal(b)
+      count++
+      return count == 1 ? Response.SuccessResponse(null) : Response.BadRequestResponse('Failed!')
+    })
+    // check resp
+    c_expect(count).to.be.equals(2)
+    c_expect(handlerResp).to.be.deep.equal({
+      batchItemFailures: [{ itemIdentifier: '123' }],
+    })
+    // ctx
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).not.toBeCalled()
+  })
+
+  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) },
+        ],
+      }),
+      context,
+      {},
+      true
+    )
+    let count = 0
+    const handlerResp = await transaction.processEvent(
+      // @ts-ignore
+      async (transaction, eventRecord) => {
+        c_expect(eventRecord).to.be.deep.equal(b)
+        count++
+        return null
+      }
+    )
+    // check resp
+    c_expect(count).to.be.equals(2)
+    c_expect(handlerResp).to.be.deep.equal({
+      batchItemFailures: [{ itemIdentifier: '456' }, { itemIdentifier: '123' }],
+    })
+    // ctx
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).not.toBeCalled()
+  })
+
+  test('Simple failure no records', async () => {
+    const context = observableContext()
+    const transaction = new EventProcessor(emptyQueueEvent(), context, {})
+    let count = 0
+    let handlerResp: any = null,
+      err: any = null
+    try {
+      handlerResp = await transaction.processEvent(
+        // @ts-ignore
+        async () => {
+          count++
+          return null
+        }
+      )
+    } catch (e) {
+      err = e
+    }
+    // check resp
+    c_expect(count).to.be.equals(0)
+    c_expect(handlerResp).to.be.null
+    c_expect(err).to.be.deep.equal(
+      new Error(
+        JSON.stringify({
+          err: Globals.ErrorResponseNoRecords,
+          errCode: Globals.ErrorCode_NoRecords,
+        })
+      )
+    )
+    // ctx
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).not.toBeCalled()
+  })
+})
+
+export {}

package/tests/BaseEvent/Process.test.ts

@@ -0,0 +1,49 @@
+import { expect } from 'chai'
+
+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' }
+    const proc = new Process({}, 100)
+    let count = 0
+    const handlerResp = await proc.execute(async () => {
+      count++
+      return Response.SuccessResponse(b)
+    })
+    // check resp
+    expect(handlerResp).to.be.undefined
+    // check iterations
+    return new Promise(resolve => {
+      setTimeout(() => {
+        expect(count).to.be.equals(2)
+        clearInterval(proc.timeout)
+        resolve(null)
+      }, 250)
+    })
+  })
+})
+
+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!')
+    })
+    // check resp
+    expect(handlerResp).to.be.undefined
+    // check iterations
+    return new Promise(resolve => {
+      setTimeout(() => {
+        expect(count).to.be.equals(2)
+        clearInterval(proc.timeout)
+        resolve(null)
+      }, 250)
+    })
+  })
+})
+
+export {}

package/tests/BaseEvent/Transaction.test.ts

@@ -0,0 +1,408 @@
+import { jest } from '@jest/globals'
+import { expect as c_expect } from 'chai'
+
+import Response from '../../src/API/Response'
+import Transaction from '../../src/BaseEvent/Transaction'
+import type { DbConfig } from '../../src/Database/types'
+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' }
+    const context = observableContext()
+    const transaction = new Transaction<null, typeof b>(emptyEvent(), context)
+    const handlerResp = await transaction.execute(async () => {
+      return Response.SuccessResponse(b)
+    })
+    // check resp
+    c_expect(handlerResp).to.be.null
+    // ctx
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).toBeCalledWith({
+      statusCode: 200,
+      body: JSON.stringify(b),
+      headers: defaultHeaders,
+    })
+  })
+
+  test('Simple success - sync return', async () => {
+    const b = { name: '123' }
+    const context = observableContext()
+    const transaction = new Transaction<null, typeof b>(emptyEvent(), context, {
+      syncReturn: true,
+    })
+    const handlerResp = await transaction.execute(async () => {
+      return Response.SuccessResponse(b)
+    })
+    // check resp
+    c_expect(handlerResp).to.be.an.instanceof(Response)
+    c_expect(handlerResp?.getBody()).to.be.deep.equals(b)
+    c_expect(handlerResp?.getCode()).to.be.equals(200)
+    // ctx
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).not.toBeCalled()
+  })
+})
+
+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',
+    }
+    const context = observableContext({ awsRequestId: '123' })
+    const transaction = new Transaction<null, typeof b>(emptyEvent(), context)
+    // @ts-expect-error
+    const handlerResp = await transaction.execute(async () => {
+      return null
+    })
+    // check resp
+    c_expect(handlerResp).to.be.null
+    // ctx
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).toBeCalledWith({
+      statusCode: 400,
+      body: JSON.stringify(b),
+      headers: defaultHeaders,
+    })
+  })
+
+  test('Not valid response returned success - sync return', async () => {
+    const b = {
+      err: Globals.ErrorResponseInvalidServerResponse,
+      rollback: true,
+      errCode: Globals.ErrorCode_APIError,
+      transactionID: '123',
+    }
+    const context = observableContext()
+    const transaction = new Transaction<null, typeof b>(
+      emptyEvent({
+        requestContext: { requestId: '123' },
+      }),
+      context,
+      {
+        syncReturn: true,
+      }
+    )
+    // @ts-expect-error
+    const handlerResp = await transaction.execute(async () => {
+      return null
+    })
+    // check resp
+    c_expect(handlerResp).to.be.an.instanceof(Response)
+    c_expect(handlerResp?.getBody()).to.be.deep.equals(b)
+    c_expect(handlerResp?.getCode()).to.be.equals(400)
+    // ctx
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).not.toBeCalled()
+  })
+})
+
+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',
+    }
+    const b2 = { name: 'abc' }
+    const context = observableContext()
+    const transaction = new Transaction<null, null, typeof b2>(emptyEvent(), context)
+    const handlerResp = await transaction.execute(async () => {
+      return b2
+    })
+    // check resp
+    c_expect(handlerResp).to.be.null
+    // ctx
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).toBeCalledWith({
+      statusCode: 400,
+      body: JSON.stringify(b),
+      headers: defaultHeaders,
+    })
+  })
+
+  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 handlerResp = await transaction.execute(async () => {
+      return b2
+    })
+    // check resp
+    c_expect(handlerResp).to.be.deep.equals(b2)
+    // ctx
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).not.toBeCalled()
+  })
+})
+
+describe('Transaction error invocation path with exception', () => {
+  test('Transaction exception', async () => {
+    const b = {
+      err: Globals.ErrorResponseUnhandledError,
+      rollback: true,
+      errCode: Globals.ErrorCode_APIError,
+      transactionID: 'unknown',
+    }
+    const context = observableContext()
+    const transaction = new Transaction<null, null, null>(emptyEvent(), context)
+    const handlerResp = await transaction.execute(async () => {
+      throw new Error('Failed!')
+    })
+    // check resp
+    c_expect(handlerResp).to.be.null
+    // ctx
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).toBeCalledWith({
+      statusCode: 400,
+      body: JSON.stringify(b),
+      headers: defaultHeaders,
+    })
+  })
+
+  test('Transaction exception - sync return', async () => {
+    const b = {
+      err: Globals.ErrorResponseUnhandledError,
+      rollback: true,
+      errCode: Globals.ErrorCode_APIError,
+      transactionID: 'unknown',
+    }
+    const context = observableContext()
+    const transaction = new Transaction<null, null, null>(emptyEvent(), context, {
+      syncReturn: true,
+    })
+    const handlerResp = await transaction.execute(async () => {
+      throw new Error('Failed!')
+    })
+    // check resp
+    c_expect(handlerResp?.getBody()).to.be.deep.equals(b)
+    c_expect(handlerResp?.getCode()).to.be.equals(400)
+    // ctx
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).not.toBeCalled()
+  })
+
+  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!')
+    let handlerResp: any = null,
+      err: any = null
+    try {
+      handlerResp = await transaction.execute(async () => {
+        throw error
+      })
+    } catch (e) {
+      err = e
+    }
+    // check resp
+    c_expect(handlerResp).to.be.null
+    c_expect(err).to.be.deep.equals(error)
+    // ctx
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).not.toBeCalled()
+  })
+})
+
+describe('Transaction - db integration', () => {
+  const testResources = () => {
+    const mockTrans = {
+      select: jest.fn(),
+      closeSuccess: jest.fn(),
+      closeFailure: jest.fn(),
+    }
+    const mockCreate = jest.fn(
+      () => ({ transaction: () => new Promise(resolve => resolve(mockTrans)) }) as any
+    )
+
+    const transaction = new Transaction(emptyEvent(), observableContext())
+    transaction['databaseManager'] = {
+      create: mockCreate,
+    } as any
+
+    return {
+      transaction,
+      mockCreate,
+      mockTrans,
+    }
+  }
+
+  const config = { username: 'test' } as DbConfig<'knex'>
+
+  test('Transaction provides dbTransaction and calls closeSuccess', async () => {
+    const { mockCreate, mockTrans, transaction } = testResources()
+
+    await transaction.execute(async () => {
+      const knexTransaction = await transaction.getDbTransaction(config)
+
+      knexTransaction.select('name')
+
+      return Response.SuccessResponse(null)
+    })
+    expect(mockCreate).toBeCalledWith(config)
+    expect(mockTrans.select).toBeCalledWith('name')
+    expect(mockTrans.closeSuccess).toBeCalled()
+  })
+
+  test('Errored transaction calls closeFailure', async () => {
+    const { mockCreate, transaction, mockTrans } = testResources()
+
+    const ss = await transaction.execute(async () => {
+      const _ii = await transaction.getDbTransaction(config)
+      console.log('ii', _ii)
+      throw new Error('Something went wrong!')
+
+      return Response.SuccessResponse(null)
+    })
+
+    console.log(ss)
+
+    expect(mockCreate).toBeCalledWith(config)
+    expect(mockTrans.closeFailure).toBeCalled()
+  })
+})
+
+describe('Transaction response types', () => {
+  test('Non-response return', async () => {
+    const b = { name: '123' }
+    const b2 = {
+      err: Globals.ErrorResponseInvalidServerResponse,
+      rollback: true,
+      errCode: Globals.ErrorCode_APIError,
+      transactionID: 'unknown',
+    }
+    const context = observableContext()
+    const transaction = new Transaction<null, typeof b>(emptyEvent(), context)
+    // @ts-expect-error
+    const handlerResp = await transaction.execute(async () => {
+      return { d: 1 }
+    })
+    // check resp
+    c_expect(handlerResp).to.be.null
+    // ctx
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).toBeCalledWith({
+      statusCode: 400,
+      body: JSON.stringify(b2),
+      headers: defaultHeaders,
+    })
+  })
+
+  test('Null return', async () => {
+    const b = { name: '123' }
+    const b2 = {
+      err: Globals.ErrorResponseInvalidServerResponse,
+      rollback: true,
+      errCode: Globals.ErrorCode_APIError,
+      transactionID: 'unknown',
+    }
+    const context = observableContext()
+    const transaction = new Transaction<null, typeof b>(emptyEvent(), context)
+    // @ts-expect-error
+    const handlerResp = await transaction.execute(async () => {
+      return null
+    })
+    // check resp
+    c_expect(handlerResp).to.be.null
+    // ctx
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).toBeCalledWith({
+      statusCode: 400,
+      body: JSON.stringify(b2),
+      headers: defaultHeaders,
+    })
+  })
+
+  test('Undefined return', async () => {
+    const b = { name: '123' }
+    const b2 = {
+      err: Globals.ErrorResponseInvalidServerResponse,
+      rollback: true,
+      errCode: Globals.ErrorCode_APIError,
+      transactionID: 'unknown',
+    }
+    const context = observableContext()
+    const transaction = new Transaction<null, typeof b>(emptyEvent(), context)
+    // @ts-expect-error
+    const handlerResp = await transaction.execute(async () => {
+      return
+    })
+    // check resp
+    c_expect(handlerResp).to.be.null
+    // ctx
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).toBeCalledWith({
+      statusCode: 400,
+      body: JSON.stringify(b2),
+      headers: defaultHeaders,
+    })
+  })
+
+  test('Null inner-response return', async () => {
+    const b = { name: '123' }
+    const b2 = { transactionID: 'unknown' }
+    const context = observableContext()
+    const transaction = new Transaction<null, typeof b>(emptyEvent(), context)
+    // @ts-expect-error
+    const handlerResp = await transaction.execute(async () => {
+      return Response.SuccessResponse(null)
+    })
+    // check resp
+    c_expect(handlerResp).to.be.null
+    // ctx
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).toBeCalledWith({
+      statusCode: 200,
+      body: JSON.stringify(b2),
+      headers: defaultHeaders,
+    })
+  })
+
+  test('Wrong keys inner-response return', async () => {
+    const b = { name: '123' }
+    const b2 = {
+      notName: '123',
+      transactionID: 'unknown',
+    }
+    const context = observableContext()
+    const transaction = new Transaction<null, typeof b>(emptyEvent(), context)
+    // @ts-expect-error
+    const handlerResp = await transaction.execute(async () => {
+      return Response.SuccessResponse({ notName: '123' })
+    })
+    // check resp
+    c_expect(handlerResp).to.be.null
+    // ctx
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).toBeCalledWith({
+      statusCode: 200,
+      body: JSON.stringify(b2),
+      headers: defaultHeaders,
+    })
+  })
+})
+
+export {}