@creator.co/wapi 1.7.9 → 1.7.10-alpha.1

package/tests/API/Utils.test.ts

@@ -1,117 +1,117 @@
-import { expect } from 'chai'
+import { expect as c_expect } from 'chai'
 
 import Utils from '../../src/Util/Utils.js'
 
 describe('isHybridlessContainer', () => {
   test('Simple isHybridlessContainer test', () => {
     const v = Utils.isHybridlessContainer()
-    expect(v).to.be.a('boolean')
+    c_expect(v).to.be.a('boolean')
     // this is done, so tests are reliable based on the testing .env
-    expect(v).to.be[process.env.HYBRIDLESS_RUNTIME ? 'true' : 'false']
+    c_expect(v).to.be[process.env.HYBRIDLESS_RUNTIME ? 'true' : 'false']
   })
 })
 
 describe('isValidString', () => {
   test('Empty string is not valid', () => {
     const v = Utils.isValidString('')
-    expect(v).to.be.a('boolean')
-    expect(v).to.be.false
+    c_expect(v).to.be.a('boolean')
+    c_expect(v).to.be.false
   })
 
   test('Number is not a valid string', () => {
     // @ts-ignore
     const v = Utils.isValidString(12)
-    expect(v).to.be.a('boolean')
-    expect(v).to.be.false
+    c_expect(v).to.be.a('boolean')
+    c_expect(v).to.be.false
   })
 
   test('Simple string is valid', () => {
     const v = Utils.isValidString('abc')
-    expect(v).to.be.a('boolean')
-    expect(v).to.be.true
+    c_expect(v).to.be.a('boolean')
+    c_expect(v).to.be.true
   })
 })
 
 describe('parseIntNullIfNaN', () => {
   test('Null if only chars', () => {
     const v = Utils.parseIntNullIfNaN('abc')
-    expect(v).to.be.null
+    c_expect(v).to.be.null
   })
 
   test('Null if chars with numbers', () => {
     const v = Utils.parseIntNullIfNaN('abc123')
-    expect(v).to.be.null
+    c_expect(v).to.be.null
   })
 
   test('Null if null', () => {
     // @ts-ignore
     const v = Utils.parseIntNullIfNaN(null)
-    expect(v).to.be.null
+    c_expect(v).to.be.null
   })
 
   test('Not null if starts with numbers (js behavior)', () => {
     const v = Utils.parseIntNullIfNaN('123abc')
-    expect(v).to.be.a('number')
-    expect(v).to.be.equals(123)
+    c_expect(v).to.be.a('number')
+    c_expect(v).to.be.equals(123)
   })
 
   test('Not null if numbers', () => {
     const v = Utils.parseIntNullIfNaN('123')
-    expect(v).to.be.a('number')
-    expect(v).to.be.equals(123)
+    c_expect(v).to.be.a('number')
+    c_expect(v).to.be.equals(123)
   })
 
   test('Not null if number type', () => {
     // @ts-ignore
     const v = Utils.parseIntNullIfNaN(123)
-    expect(v).to.be.a('number')
-    expect(v).to.be.equals(123)
+    c_expect(v).to.be.a('number')
+    c_expect(v).to.be.equals(123)
   })
 })
 
 describe('parseObjectNullIfEmpty', () => {
   test('Null if only chars', () => {
     const v = Utils.parseObjectNullIfEmpty('abc')
-    expect(v).to.be.null
+    c_expect(v).to.be.null
   })
 
   test('Null if chars with numbers', () => {
     const v = Utils.parseObjectNullIfEmpty('abc123')
-    expect(v).to.be.null
+    c_expect(v).to.be.null
   })
 
   test('Null if null', () => {
     // @ts-ignore
     const v = Utils.parseObjectNullIfEmpty(null)
-    expect(v).to.be.null
+    c_expect(v).to.be.null
   })
 
   test('Null if malformed object', () => {
     const v = Utils.parseObjectNullIfEmpty('{d: 123}')
-    expect(v).to.be.null
+    c_expect(v).to.be.null
   })
 
   test('Null if empty object', () => {
     const v = Utils.parseObjectNullIfEmpty('{}')
-    expect(v).to.be.null
+    c_expect(v).to.be.null
   })
 
   test('Not null if object with a key', () => {
     const v = Utils.parseObjectNullIfEmpty('{"d": 123}')
-    expect(v).to.be.a('object')
-    expect(v?.['d']).to.be.equals(123)
+    c_expect(v).to.be.a('object')
+    c_expect(v?.['d']).to.be.equals(123)
   })
 })
 
 describe('isValidNumber', () => {
   test('Not a valid number if only chars', () => {
     const v = Utils.isValidNumber('abc')
-    expect(v).to.be.false
+    c_expect(v).to.be.false
   })
 
   test('Not a valid number if only chars and numbers', () => {
     const v = Utils.isValidNumber('abc123')
-    expect(v).to.be.false
+    c_expect(v).to.be.false
   })
 
   test('Not a valid number if causes a crash on conversion', () => {
@@ -121,47 +121,109 @@ describe('isValidNumber', () => {
         throw new Error('Evil object')
       },
     })
-    expect(v).to.be.false
+    c_expect(v).to.be.false
   })
 
   test('Valid number if numbers and chars after', () => {
     const v = Utils.isValidNumber('123abc')
-    expect(v).to.be.true
+    c_expect(v).to.be.true
   })
 
   test('Valid number if numbers', () => {
     const v = Utils.isValidNumber('123')
-    expect(v).to.be.true
+    c_expect(v).to.be.true
   })
 })
 
 describe('caseInsensitiveObjectForKey', () => {
   test('Get a key that is lowercase, asking uppercase', () => {
     const v = Utils.caseInsensitiveObjectForKey({ abc: 123 }, 'ABC')
-    expect(v).to.be.a('number')
-    expect(v).to.be.equals(123)
+    c_expect(v).to.be.a('number')
+    c_expect(v).to.be.equals(123)
   })
 
   test('Get a key that is uppercase, asking lowercase', () => {
     const v = Utils.caseInsensitiveObjectForKey({ ABC: 123 }, 'abc')
-    expect(v).to.be.a('number')
-    expect(v).to.be.equals(123)
+    c_expect(v).to.be.a('number')
+    c_expect(v).to.be.equals(123)
   })
 
   test('Fails gracefully if key is not found', () => {
     const v = Utils.caseInsensitiveObjectForKey({ ABC: 123 }, 'asd')
-    expect(v).to.be.null
+    c_expect(v).to.be.null
   })
 
   test('Fails gracefully for null object', () => {
     const v = Utils.caseInsensitiveObjectForKey(null, 'abc')
-    expect(v).to.be.null
+    c_expect(v).to.be.null
   })
 
   test('Fails gracefully for invalid object', () => {
     const v = Utils.caseInsensitiveObjectForKey('', 'abc')
-    expect(v).to.be.null
+    c_expect(v).to.be.null
   })
 })
 
-export {}
+describe('ddbMarshall', () => {
+  test('Marshalling of a simple object', () => {
+    const input = { key: 'value' }
+    const output = Utils.ddbMarshall(input)
+    expect(output).toEqual({ key: { S: 'value' } })
+  })
+
+  test('Marshalling of an array', () => {
+    const input = [1, 2, 3]
+    const output = Utils.ddbMarshall(input)
+    expect(output).toEqual({ L: [{ N: '1' }, { N: '2' }, { N: '3' }] })
+  })
+
+  test('Marshalling of a nested object', () => {
+    const input = { key: { nestedKey: 'nestedValue' } }
+    const output = Utils.ddbMarshall(input)
+    expect(output).toEqual({ key: { M: { nestedKey: { S: 'nestedValue' } } } })
+  })
+
+  test('Marshalling of a complex object with undefined values', () => {
+    const input = { key1: 'value1', key2: undefined, key3: null }
+    const output = Utils.ddbMarshall(input)
+    expect(output).toEqual({ key1: { S: 'value1' }, key3: { NULL: true } })
+  })
+
+  test('Marshalling of a primitive value', () => {
+    const input = 42
+    const output = Utils.ddbMarshall(input)
+    expect(output).toEqual({ N: '42' })
+  })
+})
+
+describe('ddbUnmarshall', () => {
+  test('Unmarshalling of a simple DynamoDB object', () => {
+    const input = { key: { S: 'value' } }
+    const output = Utils.ddbUnmarshall(input)
+    expect(output).toEqual({ key: 'value' })
+  })
+
+  test('Unmarshalling of a DynamoDB array', () => {
+    const input = { array: { L: [{ N: '1' }, { N: '2' }, { N: '3' }] } }
+    const output = Utils.ddbUnmarshall(input)
+    expect(output.array).toEqual([1, 2, 3])
+  })
+
+  test('Unmarshalling of a nested DynamoDB object', () => {
+    const input = { key: { M: { nestedKey: { S: 'nestedValue' } } } }
+    const output = Utils.ddbUnmarshall(input)
+    expect(output).toEqual({ key: { nestedKey: 'nestedValue' } })
+  })
+
+  test('Unmarshalling of a complex DynamoDB object with null values', () => {
+    const input = { key1: { S: 'value1' }, key3: { NULL: true } }
+    const output = Utils.ddbUnmarshall(input)
+    expect(output).toEqual({ key1: 'value1', key3: null })
+  })
+
+  test('Unmarshalling of a primitive value', () => {
+    const input = { key: { N: '42' } }
+    const output = Utils.ddbUnmarshall(input)
+    expect(output.key).toEqual(42)
+  })
+})

package/tests/BaseEvent/DynamoTransaction.test.ts

@@ -0,0 +1,272 @@
+import { expect as c_expect } from 'chai'
+
+import Response from '../../src/API/Response.js'
+import DynamoTransaction from '../../src/BaseEvent/DynamoTransaction.js'
+import Globals from '../../src/Globals.js'
+import Utils from '../../src/Util/Utils.js'
+import { emptyDynamoDBEvent, observableContext } from '../Test.utils.js'
+
+const skipCleanTmp = {
+  skipCleanTmp: true,
+}
+
+describe('DynamoTransaction success invocation path', () => {
+  test('Simple success', async () => {
+    const record = { id: '123' }
+    const context = observableContext()
+    const transaction = new DynamoTransaction(
+      emptyDynamoDBEvent({
+        Records: [
+          { dynamodb: { NewImage: Utils.ddbMarshall(record) } },
+          { dynamodb: { NewImage: Utils.ddbMarshall(record) } },
+        ],
+      }),
+      context
+    )
+    let count = 0
+    const handlerResp = await transaction.processEvent(async (transaction, eventRecord) => {
+      c_expect(eventRecord.marshalled.NewImage).to.be.deep.equal(record)
+      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 record = { id: '123' }
+    const context = observableContext()
+    const transaction = new DynamoTransaction(
+      emptyDynamoDBEvent({
+        Records: [
+          { dynamodb: { NewImage: Utils.ddbMarshall(record) } },
+          { dynamodb: { NewImage: Utils.ddbMarshall(record) } },
+        ],
+      }),
+      context,
+      { ...skipCleanTmp }
+    )
+    let count = 0
+    const handlerResp = await transaction.processEvent(async (transaction, eventRecord) => {
+      c_expect(eventRecord.dynamodb?.NewImage).to.be.deep.equal(Utils.ddbMarshall(record))
+      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()
+  })
+})
+
+describe('DynamoTransaction failure invocation path', () => {
+  test('Simple failure', async () => {
+    const record = { id: '123' }
+    const context = observableContext()
+    const transaction = new DynamoTransaction(
+      emptyDynamoDBEvent({
+        Records: [
+          { dynamodb: { NewImage: Utils.ddbMarshall(record) } },
+          { eventID: '123', dynamodb: { NewImage: Utils.ddbMarshall(record) } },
+          { dynamodb: { NewImage: Utils.ddbMarshall(record) } },
+        ],
+      }),
+      context,
+      { ...skipCleanTmp }
+    )
+    let count = 0
+    let handlerResp: any = null,
+      err: any = null
+    try {
+      handlerResp = await transaction.processEvent(async (transaction, eventRecord) => {
+        c_expect(eventRecord.marshalled.NewImage).to.be.deep.equal(record)
+        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 record = { id: '123' }
+    const context = observableContext()
+    const transaction = new DynamoTransaction(
+      emptyDynamoDBEvent({
+        Records: [
+          { dynamodb: { NewImage: Utils.ddbMarshall(record) } },
+          { eventID: '123', dynamodb: { NewImage: Utils.ddbMarshall(record) } },
+          { dynamodb: { NewImage: Utils.ddbMarshall(record) } },
+        ],
+      }),
+      context,
+      { ...skipCleanTmp }
+    )
+    let count = 0
+    let handlerResp: any = null,
+      err: any = null
+    try {
+      handlerResp = await transaction.processEvent(
+        // @ts-ignore
+        async (transaction, eventRecord) => {
+          c_expect(eventRecord.marshalled.NewImage).to.be.deep.equal(record)
+          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 record = { id: '123' }
+    const context = observableContext()
+    const transaction = new DynamoTransaction(
+      emptyDynamoDBEvent({
+        Records: [
+          { dynamodb: { NewImage: Utils.ddbMarshall(record) } },
+          { eventID: '123', dynamodb: { NewImage: Utils.ddbMarshall(record) } },
+        ],
+      }),
+      context,
+      { ...skipCleanTmp },
+      true
+    )
+    let count = 0
+    const handlerResp = await transaction.processEvent(async (transaction, eventRecord) => {
+      c_expect(eventRecord.marshalled.NewImage).to.be.deep.equal(record)
+      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 record = { id: '123' }
+    const context = observableContext()
+    const transaction = new DynamoTransaction(
+      emptyDynamoDBEvent({
+        Records: [
+          { eventID: '456', dynamodb: { NewImage: Utils.ddbMarshall(record) } },
+          { eventID: '123', dynamodb: { NewImage: Utils.ddbMarshall(record) } },
+        ],
+      }),
+      context,
+      { ...skipCleanTmp },
+      true
+    )
+    let count = 0
+    const handlerResp = await transaction.processEvent(
+      // @ts-ignore
+      async (transaction, eventRecord) => {
+        c_expect(eventRecord.marshalled.NewImage).to.be.deep.equal(record)
+        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 DynamoTransaction(emptyDynamoDBEvent(), 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()
+  })
+})

package/tests/Logger/Logger.test.ts

@@ -154,7 +154,7 @@ function testLogs(isContainer: boolean, provider?: Logger) {
   test(`${type} - ${loggerType} Log - Circular reference (Error)`, async () => {
     setContainerFlag(isContainer)
     class SelfRefError extends Error {
-      self: SelfRefError
+      public self: SelfRefError
       constructor() {
         super()
         this.self = this

package/tests/Test.utils.ts

@@ -1,5 +1,5 @@
 import { jest } from '@jest/globals'
-import { APIGatewayEvent, Context, SQSEvent } from 'aws-lambda'
+import { APIGatewayEvent, Context, DynamoDBStreamEvent, SQSEvent } from 'aws-lambda'
 import { z } from 'zod'
 
 import Transaction from '../src/BaseEvent/Transaction.js'
@@ -67,6 +67,10 @@ export function emptyQueueEvent(data?: any) {
   return <SQSEvent>(<unknown>data || {})
 }
 
+export function emptyDynamoDBEvent(data?: any) {
+  return <DynamoDBStreamEvent>(<unknown>data || {})
+}
+
 export function observableTransaction() {
   const t = new Transaction(emptyEvent(), observableContext())
   t.responseProxy = jest.fn() as any