@creator.co/wapi 1.2.2 → 1.2.4

package/tests/API/Response.test.ts

@@ -1,20 +1,15 @@
-import { expect as j_expect } from "@jest/globals"
-import { APIGatewayEvent, Context } from "aws-lambda"
-import { expect } from "chai"
+import { expect as j_expect } from '@jest/globals'
+import { APIGatewayEvent, Context } from 'aws-lambda'
+import { expect } from 'chai'
 
-import Response from "../../src/API/Response"
-import Transaction from "../../src/BaseEvent/Transaction"
-import Globals from "../../src/Globals"
-import { observableTransaction, defaultHeaders } from "../Test.utils"
+import Response from '../../src/API/Response'
+import Transaction from '../../src/BaseEvent/Transaction'
+import Globals from '../../src/Globals'
+import { observableTransaction, defaultHeaders } from '../Test.utils'
 
-async function testResponse(
-  r: Response<any>,
-  body: any,
-  optCode?: number,
-  optHeaders?: any,
-) {
+async function testResponse(r: Response<any>, body: any, optCode?: number, optHeaders?: any) {
   const t = observableTransaction()
-  const context = t["context"]
+  const context = t['context']
   const buildR = await r.build(context, t, false)
   expect(buildR).to.be.undefined
   j_expect(t.responseProxy).toBeCalledTimes(1)
@@ -30,46 +25,46 @@ async function testResponse(
       ? {
           body: JSON.stringify({
             ...body,
-            transactionID: "unknown",
+            transactionID: 'unknown',
           }),
         }
       : {}),
   })
 }
 
-describe("Response basics", () => {
-  test("Null body", () => {
+describe('Response basics', () => {
+  test('Null body', () => {
     const r = new Response<null>(200, null)
     expect(r.getCode()).to.be.equals(200)
     expect(r.getBody()).to.be.null
   })
 
-  test("String body", () => {
-    const r = new Response<string>(200, "abc")
+  test('String body', () => {
+    const r = new Response<string>(200, 'abc')
     expect(r.getCode()).to.be.equals(200)
-    expect(r.getBody()).to.be.equals("abc")
+    expect(r.getBody()).to.be.equals('abc')
   })
 
-  test("Generic body", () => {
-    const r = new Response<any>(200, { name: "abc" })
-    r.appendIntoBody("name2", "123")
+  test('Generic body', () => {
+    const r = new Response<any>(200, { name: 'abc' })
+    r.appendIntoBody('name2', '123')
     expect(r.getCode()).to.be.equals(200)
-    expect(r.getBody().name).to.be.equals("abc")
-    expect(r.getBody().name2).to.be.equals("123")
+    expect(r.getBody().name).to.be.equals('abc')
+    expect(r.getBody().name2).to.be.equals('123')
   })
 
-  test("Append/validate header", () => {
+  test('Append/validate header', () => {
     const r = new Response<any>(200, {})
-    r.appendHeader("name2", "123")
-    expect(r["_headers"]["name2"]).to.be.equals("123")
+    r.appendHeader('name2', '123')
+    expect(r['_headers']['name2']).to.be.equals('123')
   })
 })
 
-describe("Response build", () => {
-  test("Succeeds to transaction context", async () => {
-    const b = { name: "abc" }
+describe('Response build', () => {
+  test('Succeeds to transaction context', async () => {
+    const b = { name: 'abc' }
     const r = new Response<any>(200, b)
-    r.appendHeader("abc", "123")
+    r.appendHeader('abc', '123')
     // do not use default, so we dont use proxy response for once
     const t = new Transaction(
       <APIGatewayEvent>(<unknown>{}),
@@ -77,9 +72,9 @@ describe("Response build", () => {
         done: jest.fn(),
         fail: jest.fn(),
         succeed: jest.fn(),
-      }),
+      })
     )
-    const context = t["context"]
+    const context = t['context']
     const buildR = await r.build(context, t, false)
     expect(buildR).to.be.undefined
     j_expect(context.fail).not.toBeCalled()
@@ -88,20 +83,20 @@ describe("Response build", () => {
       statusCode: 200,
       headers: {
         ...defaultHeaders,
-        abc: "123",
+        abc: '123',
       },
       body: JSON.stringify({
         ...b,
-        transactionID: "unknown",
+        transactionID: 'unknown',
       }),
     })
   })
 
-  test("Succeeds with no context call", async () => {
-    const b = { name: "abc" }
+  test('Succeeds with no context call', async () => {
+    const b = { name: 'abc' }
     const r = new Response<any>(200, b)
     const t = observableTransaction()
-    const context = t["context"]
+    const context = t['context']
     const buildR = await r.build(context, t, true)
     expect(buildR).to.be.undefined
     j_expect(context.fail).not.toBeCalled()
@@ -109,30 +104,30 @@ describe("Response build", () => {
     j_expect(context.succeed).not.toBeCalled()
   })
 
-  test("Succeeds to transaction context as RAW", async () => {
-    const b = { name: "abc" }
+  test('Succeeds to transaction context as RAW', async () => {
+    const b = { name: 'abc' }
     const r = new Response<any>(200, b, {
       rawBody: true,
     })
     const t = observableTransaction()
-    const context = t["context"]
+    const context = t['context']
     const buildR = await r.build(context, t, false)
     expect(buildR).to.be.undefined
     j_expect(context.fail).not.toBeCalled()
     j_expect(context.done).not.toBeCalled()
     j_expect(context.succeed).toHaveBeenCalledWith({
       ...b,
-      transactionID: "unknown",
+      transactionID: 'unknown',
     })
   })
 
-  test("Succeeds to transaction piping", async () => {
-    const b = { name: "abc" }
+  test('Succeeds to transaction piping', async () => {
+    const b = { name: 'abc' }
     const r = new Response<any>(200, b, {
       shouldStream: true,
     })
     const t = observableTransaction()
-    const context = t["context"]
+    const context = t['context']
     const buildR = await r.build(context, t, false)
     await r.build(context, t, false) //pipe twice, should not affect
     expect(buildR).to.be.undefined
@@ -150,13 +145,13 @@ describe("Response build", () => {
     })
   })
 
-  test("Failure to transaction context as RAW", async () => {
-    const b = { name: "abc" }
+  test('Failure to transaction context as RAW', async () => {
+    const b = { name: 'abc' }
     const r = new Response<any>(400, b, {
       rawBody: true,
     })
     const t = observableTransaction()
-    const context = t["context"]
+    const context = t['context']
     const buildR = await r.build(context, t, false)
     expect(buildR).to.be.undefined
     j_expect(context.done).not.toBeCalled()
@@ -164,14 +159,14 @@ describe("Response build", () => {
     j_expect(context.fail).toHaveBeenCalledTimes(1)
   })
 
-  test("Failure exception to transaction context as RAW", async () => {
-    const b = { name: "abc" }
+  test('Failure exception to transaction context as RAW', async () => {
+    const b = { name: 'abc' }
     const r = new Response<any>(400, b, {
       rawBody: true,
       throwOnErrors: true,
     })
     const t = observableTransaction()
-    const context = t["context"]
+    const context = t['context']
     let buildR: any = null,
       exception = null
     try {
@@ -186,14 +181,14 @@ describe("Response build", () => {
     j_expect(context.fail).not.toBeCalled()
   })
 
-  test("Failure exception to transaction context as RAW and null body", async () => {
+  test('Failure exception to transaction context as RAW and null body', async () => {
     const b = null
     const r = new Response<any>(400, b, {
       rawBody: true,
       throwOnErrors: true,
     })
     const t = observableTransaction()
-    const context = t["context"]
+    const context = t['context']
     let buildR: any = null,
       exception = null
     try {
@@ -208,14 +203,14 @@ describe("Response build", () => {
     j_expect(context.fail).not.toBeCalled()
   })
 
-  test("Failure exception to transaction context as RAW and custom ero", async () => {
-    const b = { message: "abc", error: "error 123" }
+  test('Failure exception to transaction context as RAW and custom ero', async () => {
+    const b = { message: 'abc', error: 'error 123' }
     const r = new Response<any>(400, b, {
       rawBody: true,
       throwOnErrors: true,
     })
     const t = observableTransaction()
-    const context = t["context"]
+    const context = t['context']
     let buildR: any = null,
       exception = null
     try {
@@ -231,9 +226,9 @@ describe("Response build", () => {
   })
 })
 
-describe("Response shortcuts", () => {
-  test("MissingParamResponse", async () => {
-    const pName = "abc"
+describe('Response shortcuts', () => {
+  test('MissingParamResponse', async () => {
+    const pName = 'abc'
     const r = Response.MissingParamResponse(pName)
     await testResponse(r, {
       err: `Invalid request. Path parameter ${pName} is missing.`,
@@ -241,8 +236,8 @@ describe("Response shortcuts", () => {
     })
   })
 
-  test("MissingQueryResponse", async () => {
-    const pName = "abc"
+  test('MissingQueryResponse', async () => {
+    const pName = 'abc'
     const r = Response.MissingQueryResponse(pName)
     await testResponse(r, {
       err: `Invalid request. Query parameter ${pName} is missing.`,
@@ -250,9 +245,9 @@ describe("Response shortcuts", () => {
     })
   })
 
-  test("BadRequestResponse", async () => {
-    const message = "abc"
-    const code = "CODE"
+  test('BadRequestResponse', async () => {
+    const message = 'abc'
+    const code = 'CODE'
     const optBody = { additional: 123 }
     const r = Response.BadRequestResponse(message, code, optBody)
     await testResponse(r, {
@@ -262,17 +257,17 @@ describe("Response shortcuts", () => {
     })
   })
 
-  test("BadRequestResponse no opts", async () => {
-    const message = "abc"
+  test('BadRequestResponse no opts', async () => {
+    const message = 'abc'
     const r = Response.BadRequestResponse(message)
     await testResponse(r, {
       err: message,
     })
   })
 
-  test("BadRequestResponseWithRollback", async () => {
-    const message = "abc"
-    const code = "CODE"
+  test('BadRequestResponseWithRollback', async () => {
+    const message = 'abc'
+    const code = 'CODE'
     const optBody = { additional: 123 }
     const r = Response.BadRequestResponseWithRollback(message, code, optBody)
     await testResponse(r, {
@@ -283,8 +278,8 @@ describe("Response shortcuts", () => {
     })
   })
 
-  test("BadRequestResponseWithRollback no opts", async () => {
-    const message = "abc"
+  test('BadRequestResponseWithRollback no opts', async () => {
+    const message = 'abc'
     const r = Response.BadRequestResponseWithRollback(message)
     await testResponse(r, {
       err: message,
@@ -292,9 +287,9 @@ describe("Response shortcuts", () => {
     })
   })
 
-  test("UnauthorizedResponse", async () => {
-    const message = "abc"
-    const code = "CODE"
+  test('UnauthorizedResponse', async () => {
+    const message = 'abc'
+    const code = 'CODE'
     const r = Response.UnauthorizedResponse(message, code)
     await testResponse(
       r,
@@ -302,53 +297,53 @@ describe("Response shortcuts", () => {
         err: message,
         errCode: code,
       },
-      401,
+      401
     )
   })
 
-  test("UnauthorizedResponse no code", async () => {
-    const message = "abc"
+  test('UnauthorizedResponse no code', async () => {
+    const message = 'abc'
     const r = Response.UnauthorizedResponse(message)
     await testResponse(r, { err: message }, 401)
   })
 
-  test("SuccessResponse", async () => {
+  test('SuccessResponse', async () => {
     const body = { additional: 123 }
     const r = Response.SuccessResponse(body)
     await testResponse(r, body, 200)
   })
 
-  test("SuccessResponse null body", async () => {
+  test('SuccessResponse null body', async () => {
     const r = Response.SuccessResponse(null)
     await testResponse(r, {}, 200)
   })
 
-  test("SuccessNoContentResponse", async () => {
+  test('SuccessNoContentResponse', async () => {
     const r = Response.SuccessNoContentResponse()
     await testResponse(r, null, 204)
   })
 
-  test("SimpleResponse", async () => {
+  test('SimpleResponse', async () => {
     const r = Response.SimpleResponse(null)
     await testResponse(r, null, 200)
   })
 
-  test("SimpleResponse override statuscode", async () => {
+  test('SimpleResponse override statuscode', async () => {
     const r = Response.SimpleResponse(null, 203)
     await testResponse(r, null, 203)
   })
 
-  test("RedirectResponse", async () => {
-    const url = "https://google.com"
+  test('RedirectResponse', async () => {
+    const url = 'https://google.com'
     const r = Response.RedirectResponse(url)
     await testResponse(r, null, 302, { Location: url })
   })
 
-  test("SuccessStreamResponse", async () => {
-    const b = { name: "abc" }
-    const r = Response.SuccessStreamResponse(b, "test-stream")
+  test('SuccessStreamResponse', async () => {
+    const b = { name: 'abc' }
+    const r = Response.SuccessStreamResponse(b, 'test-stream')
     const t = observableTransaction()
-    const context = t["context"]
+    const context = t['context']
     const buildR = await r.build(context, t, false)
     await r.build(context, t, false) //pipe twice, should not affect
     expect(buildR).to.be.undefined
@@ -359,8 +354,8 @@ describe("Response shortcuts", () => {
       statusCode: 200,
       headers: {
         ...defaultHeaders,
-        "Content-Type": "test-stream",
-        Connection: "keep-alive",
+        'Content-Type': 'test-stream',
+        Connection: 'keep-alive',
       },
       body: {
         ...b,

package/tests/API/Utils.test.ts

@@ -1,155 +1,155 @@
-import { expect } from "chai"
+import { expect } from 'chai'
 
-import Utils from "../../src/API/Utils"
+import Utils from '../../src/API/Utils'
 
-describe("isHybridlessContainer", () => {
-  test("Simple isHybridlessContainer test", () => {
+describe('isHybridlessContainer', () => {
+  test('Simple isHybridlessContainer test', () => {
     const v = Utils.isHybridlessContainer()
-    expect(v).to.be.a("boolean")
+    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"]
+    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")
+describe('isValidString', () => {
+  test('Empty string is not valid', () => {
+    const v = Utils.isValidString('')
+    expect(v).to.be.a('boolean')
     expect(v).to.be.false
   })
 
-  test("Number is not a valid string", () => {
+  test('Number is not a valid string', () => {
     // @ts-ignore
     const v = Utils.isValidString(12)
-    expect(v).to.be.a("boolean")
+    expect(v).to.be.a('boolean')
     expect(v).to.be.false
   })
 
-  test("Simple string is valid", () => {
-    const v = Utils.isValidString("abc")
-    expect(v).to.be.a("boolean")
+  test('Simple string is valid', () => {
+    const v = Utils.isValidString('abc')
+    expect(v).to.be.a('boolean')
     expect(v).to.be.true
   })
 })
 
-describe("parseIntNullIfNaN", () => {
-  test("Null if only chars", () => {
-    const v = Utils.parseIntNullIfNaN("abc")
+describe('parseIntNullIfNaN', () => {
+  test('Null if only chars', () => {
+    const v = Utils.parseIntNullIfNaN('abc')
     expect(v).to.be.null
   })
 
-  test("Null if chars with numbers", () => {
-    const v = Utils.parseIntNullIfNaN("abc123")
+  test('Null if chars with numbers', () => {
+    const v = Utils.parseIntNullIfNaN('abc123')
     expect(v).to.be.null
   })
 
-  test("Null if null", () => {
+  test('Null if null', () => {
     // @ts-ignore
     const v = Utils.parseIntNullIfNaN(null)
     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")
+  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)
   })
 
-  test("Not null if numbers", () => {
-    const v = Utils.parseIntNullIfNaN("123")
-    expect(v).to.be.a("number")
+  test('Not null if numbers', () => {
+    const v = Utils.parseIntNullIfNaN('123')
+    expect(v).to.be.a('number')
     expect(v).to.be.equals(123)
   })
 
-  test("Not null if number type", () => {
+  test('Not null if number type', () => {
     // @ts-ignore
     const v = Utils.parseIntNullIfNaN(123)
-    expect(v).to.be.a("number")
+    expect(v).to.be.a('number')
     expect(v).to.be.equals(123)
   })
 })
 
-describe("parseObjectNullIfEmpty", () => {
-  test("Null if only chars", () => {
-    const v = Utils.parseObjectNullIfEmpty("abc")
+describe('parseObjectNullIfEmpty', () => {
+  test('Null if only chars', () => {
+    const v = Utils.parseObjectNullIfEmpty('abc')
     expect(v).to.be.null
   })
 
-  test("Null if chars with numbers", () => {
-    const v = Utils.parseObjectNullIfEmpty("abc123")
+  test('Null if chars with numbers', () => {
+    const v = Utils.parseObjectNullIfEmpty('abc123')
     expect(v).to.be.null
   })
 
-  test("Null if null", () => {
+  test('Null if null', () => {
     // @ts-ignore
     const v = Utils.parseObjectNullIfEmpty(null)
     expect(v).to.be.null
   })
 
-  test("Null if malformed object", () => {
-    const v = Utils.parseObjectNullIfEmpty("{d: 123}")
+  test('Null if malformed object', () => {
+    const v = Utils.parseObjectNullIfEmpty('{d: 123}')
     expect(v).to.be.null
   })
 
-  test("Null if empty object", () => {
-    const v = Utils.parseObjectNullIfEmpty("{}")
+  test('Null if empty object', () => {
+    const v = Utils.parseObjectNullIfEmpty('{}')
     expect(v).to.be.null
   })
 
-  test("Not null if object with a key", () => {
+  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)
+    expect(v).to.be.a('object')
+    expect(v?.['d']).to.be.equals(123)
   })
 })
 
-describe("isValidNumber", () => {
-  test("Not a valid number if only chars", () => {
-    const v = Utils.isValidNumber("abc")
+describe('isValidNumber', () => {
+  test('Not a valid number if only chars', () => {
+    const v = Utils.isValidNumber('abc')
     expect(v).to.be.false
   })
 
-  test("Not a valid number if only chars and numbers", () => {
-    const v = Utils.isValidNumber("abc123")
+  test('Not a valid number if only chars and numbers', () => {
+    const v = Utils.isValidNumber('abc123')
     expect(v).to.be.false
   })
 
-  test("Valid number if numbers and chars after", () => {
-    const v = Utils.isValidNumber("123abc")
+  test('Valid number if numbers and chars after', () => {
+    const v = Utils.isValidNumber('123abc')
     expect(v).to.be.true
   })
 
-  test("Valid number if numbers", () => {
-    const v = Utils.isValidNumber("123")
+  test('Valid number if numbers', () => {
+    const v = Utils.isValidNumber('123')
     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")
+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)
   })
 
-  test("Get a key that is uppercase, asking lowercase", () => {
-    const v = Utils.caseInsensitiveObjectForKey({ ABC: 123 }, "abc")
-    expect(v).to.be.a("number")
+  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)
   })
 
-  test("Fails gracefully if key is not found", () => {
-    const v = Utils.caseInsensitiveObjectForKey({ ABC: 123 }, "asd")
+  test('Fails gracefully if key is not found', () => {
+    const v = Utils.caseInsensitiveObjectForKey({ ABC: 123 }, 'asd')
     expect(v).to.be.null
   })
 
-  test("Fails gracefully for null object", () => {
-    const v = Utils.caseInsensitiveObjectForKey(null, "abc")
+  test('Fails gracefully for null object', () => {
+    const v = Utils.caseInsensitiveObjectForKey(null, 'abc')
     expect(v).to.be.null
   })
 
-  test("Fails gracefully for invalid object", () => {
-    const v = Utils.caseInsensitiveObjectForKey("", "abc")
+  test('Fails gracefully for invalid object', () => {
+    const v = Utils.caseInsensitiveObjectForKey('', 'abc')
     expect(v).to.be.null
   })
 })