@creator.co/wapi 1.2.2 → 1.2.4

package/tests/Crypto/JWT.test.ts

@@ -1,91 +1,91 @@
-import { expect } from "chai"
+import { expect } from 'chai'
 
-import JWT from "../../src/Crypto/JWT"
-import { foreignToken, privateKey } from "../Test.utils"
+import JWT from '../../src/Crypto/JWT'
+import { foreignToken, privateKey } from '../Test.utils'
 
-describe("Creates token", () => {
-  const provider = new JWT(privateKey, "7d")
-  test("Creates token without explicity expiration", () => {
+describe('Creates token', () => {
+  const provider = new JWT(privateKey, '7d')
+  test('Creates token without explicity expiration', () => {
     const token = provider.createToken({ userID: 123 })
-    expect(token).to.be.a("string")
+    expect(token).to.be.a('string')
     expect(token).is.not.null
   })
 
-  test("Creates token with explicity expiration", () => {
-    const token = provider.createToken({ userID: 123 }, "7d")
-    expect(token).to.be.a("string")
+  test('Creates token with explicity expiration', () => {
+    const token = provider.createToken({ userID: 123 }, '7d')
+    expect(token).to.be.a('string')
     expect(token).is.not.null
   })
 
-  test("Creates token with explicity token override", () => {
-    const token = provider.createToken({ userID: 123 }, "7d", privateKey)
-    expect(token).to.be.a("string")
+  test('Creates token with explicity token override', () => {
+    const token = provider.createToken({ userID: 123 }, '7d', privateKey)
+    expect(token).to.be.a('string')
     expect(token).is.not.null
   })
 
-  test("Creates token with explicity token options", () => {
+  test('Creates token with explicity token options', () => {
     const token = provider.createToken({ userID: 123 }, undefined, undefined, {
-      expiresIn: "7d",
+      expiresIn: '7d',
     })
-    expect(token).to.be.a("string")
+    expect(token).to.be.a('string')
     expect(token).is.not.null
   })
 
-  test("Creates token with no expiration", () => {
+  test('Creates token with no expiration', () => {
     const localProvider = new JWT(privateKey)
     const token = localProvider.createToken({ userID: 123 })
-    expect(token).to.be.a("string")
+    expect(token).to.be.a('string')
     expect(token).is.not.null
   })
 })
 
-describe("Validates token", () => {
-  const provider = new JWT(privateKey, "7d")
-  test("Succeed to validate just created token", () => {
+describe('Validates token', () => {
+  const provider = new JWT(privateKey, '7d')
+  test('Succeed to validate just created token', () => {
     // Creates token
-    const token = provider.createToken({ userID: 123 }, "7d", privateKey)
-    expect(token).to.be.a("string")
+    const token = provider.createToken({ userID: 123 }, '7d', privateKey)
+    expect(token).to.be.a('string')
     expect(token).is.not.null
     // Validates token
     const validationResp = provider.validateToken(token)
     expect(validationResp).is.not.null
     expect(validationResp.isValid).is.true
-    expect(validationResp["isExpired"]).is.undefined
-    expect(validationResp["decodedToken"]).is.not.null
-    expect(validationResp["decodedToken"].userID).to.be.equals(123)
-    expect(validationResp["decodedToken"].exp).to.be.a("number")
-    expect(validationResp["decodedToken"].exp).to.be.above(Date.now() / 1000)
+    expect(validationResp['isExpired']).is.undefined
+    expect(validationResp['decodedToken']).is.not.null
+    expect(validationResp['decodedToken'].userID).to.be.equals(123)
+    expect(validationResp['decodedToken'].exp).to.be.a('number')
+    expect(validationResp['decodedToken'].exp).to.be.above(Date.now() / 1000)
   })
 
-  test("Fails to validate invalid token", () => {
+  test('Fails to validate invalid token', () => {
     // Creates token
-    const token = provider.createToken({ userID: 123 }, "7d", privateKey)
+    const token = provider.createToken({ userID: 123 }, '7d', privateKey)
     // Validates token
-    const validationResp = provider.validateToken(token + "123")
+    const validationResp = provider.validateToken(token + '123')
     expect(validationResp).is.not.null
     expect(validationResp.isValid).is.false
-    expect(validationResp["isExpired"]).is.undefined
-    expect(validationResp["decodedToken"]).to.undefined
+    expect(validationResp['isExpired']).is.undefined
+    expect(validationResp['decodedToken']).to.undefined
   })
 
-  test("Fails to validate expired token", () => {
+  test('Fails to validate expired token', () => {
     // Creates token
-    const token = provider.createToken({ userID: 123 }, "-7d", privateKey)
+    const token = provider.createToken({ userID: 123 }, '-7d', privateKey)
     // Validates token
     const validationResp = provider.validateToken(token)
     expect(validationResp).is.not.null
     expect(validationResp.isValid).is.false
-    expect(validationResp["isExpired"]).is.true
-    expect(validationResp["decodedToken"]).to.undefined
+    expect(validationResp['isExpired']).is.true
+    expect(validationResp['decodedToken']).to.undefined
   })
 
-  test("Fails to validate foreign token", () => {
+  test('Fails to validate foreign token', () => {
     // Validates token
     const validationResp = provider.validateToken(foreignToken)
     expect(validationResp).is.not.null
     expect(validationResp.isValid).is.false
-    expect(validationResp["isExpired"]).is.undefined
-    expect(validationResp["decodedToken"]).to.undefined
+    expect(validationResp['isExpired']).is.undefined
+    expect(validationResp['decodedToken']).to.undefined
   })
 })
 

package/tests/Logger/Logger.test.ts

@@ -1,70 +1,58 @@
 // get console ref and mock before logger import
 const consoleProxy = console
-const mock = jest.spyOn(consoleProxy, "log")
+const mock = jest.spyOn(consoleProxy, 'log')
 // import logger after first ref
-import Logger from "../../src/Logger/Logger"
+import Logger from '../../src/Logger/Logger'
 // get console reference after logger import
-const transactionID = "123-456"
+const transactionID = '123-456'
 
 function setContainerFlag(isContainer: boolean) {
   if (isContainer) {
-    process.env["HYBRIDLESS_RUNTIME"] = "true"
+    process.env['HYBRIDLESS_RUNTIME'] = 'true'
   } else {
-    process.env["HYBRIDLESS_RUNTIME"] = undefined
+    process.env['HYBRIDLESS_RUNTIME'] = undefined
   }
 }
 
 function fixLogTypePrefix(logType: string) {
-  if (logType == "exception") return "error"
-  if (logType == "warning") return "warn"
-  if (logType == "log") return "info"
+  if (logType == 'exception') return 'error'
+  if (logType == 'warning') return 'warn'
+  if (logType == 'log') return 'info'
   return logType
 }
 
 function testLogs(isContainer: boolean, provider?: Logger) {
-  const type = isContainer ? "container" : "serverless"
-  const loggerType = !provider ? "Console" : "Logger"
+  const type = isContainer ? 'container' : 'serverless'
+  const loggerType = !provider ? 'Console' : 'Logger'
   const localProvider = provider || console
 
   test(`${type} - ${loggerType} Log - Suppress sensitive info`, async () => {
     setContainerFlag(isContainer)
-    localProvider.log("TEST", { password: "123" })
+    localProvider.log('TEST', { password: '123' })
     expect(consoleProxy.log).toHaveBeenNthCalledWith(
       1,
-      expect.stringContaining(
-        (isContainer ? `${transactionID} ` : "") + "[INFO] [Logger.test.ts:",
-      ),
+      expect.stringContaining((isContainer ? `${transactionID} ` : '') + '[INFO] [Logger.test.ts:')
     )
     expect(consoleProxy.log).toHaveBeenNthCalledWith(
       1,
-      expect.stringContaining("] TEST **SUPPRESSED_SENSITIVE_DATA**"),
+      expect.stringContaining('] TEST **SUPPRESSED_SENSITIVE_DATA**')
     )
   })
 
   test(`${type} - ${loggerType} Log - Suppress sensitive info (array)`, async () => {
     setContainerFlag(isContainer)
-    localProvider.log("TEST2", [{ password: "123" }])
+    localProvider.log('TEST2', [{ password: '123' }])
     expect(consoleProxy.log).toHaveBeenNthCalledWith(
       1,
-      expect.stringContaining(
-        (isContainer ? `${transactionID} ` : "") + "[INFO] [Logger.test.ts:",
-      ),
+      expect.stringContaining((isContainer ? `${transactionID} ` : '') + '[INFO] [Logger.test.ts:')
     )
     expect(consoleProxy.log).toHaveBeenNthCalledWith(
       1,
-      expect.stringContaining("] TEST2 **SUPPRESSED_SENSITIVE_DATA**"),
+      expect.stringContaining('] TEST2 **SUPPRESSED_SENSITIVE_DATA**')
     )
   })
 
-  for (const logType of [
-    "log",
-    "debug",
-    "info",
-    "warn",
-    "warning",
-    "error",
-    "exception",
-  ]) {
+  for (const logType of ['log', 'debug', 'info', 'warn', 'warning', 'error', 'exception']) {
     test(`${type} - ${loggerType} ${logType}`, async () => {
       setContainerFlag(isContainer)
       localProvider[logType](logType.toUpperCase())
@@ -73,28 +61,28 @@ function testLogs(isContainer: boolean, provider?: Logger) {
       expect(consoleProxy.log).toHaveBeenNthCalledWith(
         1,
         expect.stringContaining(
-          (isContainer ? `${transactionID} ` : "") +
-            `[${logTypePrefix.toUpperCase()}] [Logger.test.ts:`,
-        ),
+          (isContainer ? `${transactionID} ` : '') +
+            `[${logTypePrefix.toUpperCase()}] [Logger.test.ts:`
+        )
       )
       expect(consoleProxy.log).toHaveBeenNthCalledWith(
         1,
-        expect.stringContaining(`] ${logType.toUpperCase()}`),
+        expect.stringContaining(`] ${logType.toUpperCase()}`)
       )
     })
   }
 }
 
-describe("Logger", () => {
+describe('Logger', () => {
   beforeEach(() => {
     mock.mockClear()
   })
   const provider = new Logger(
     {
-      logLevel: "DEBUG",
+      logLevel: 'DEBUG',
       sensitiveFilteringKeywords: true,
     },
-    transactionID,
+    transactionID
   )
   provider.notGlobalLogger()
   // Test serverless logs

package/tests/Mailer/Mailer.test.ts

@@ -1,41 +1,37 @@
-import { SESClient, SendRawEmailCommand } from "@aws-sdk/client-ses"
-import { mockClient } from "aws-sdk-client-mock"
-import { expect } from "chai"
+import { SESClient, SendRawEmailCommand } from '@aws-sdk/client-ses'
+import { mockClient } from 'aws-sdk-client-mock'
+import { expect } from 'chai'
 
-import Mailer from "../../src/Mailer/Mailer"
+import Mailer from '../../src/Mailer/Mailer'
 
 const SESMock = mockClient(SESClient)
 
-describe("SendRaw", () => {
+describe('SendRaw', () => {
   // reset mock
   beforeEach(() => {
     SESMock.reset()
   })
 
-  const provider = new Mailer("dev+tests@creator.co", "ca-central-1")
+  const provider = new Mailer('dev+tests@creator.co', 'ca-central-1')
 
-  test("Send raw with success", async () => {
-    const messageId = "id-123"
+  test('Send raw with success', async () => {
+    const messageId = 'id-123'
     SESMock.on(SendRawEmailCommand).resolves({
       MessageId: messageId,
     })
-    const res = await provider.sendRawEmail(
-      "test@test.com",
-      "My message",
-      "My subject",
-    )
+    const res = await provider.sendRawEmail('test@test.com', 'My message', 'My subject')
     expect(res).is.not.null
     console.log(res)
   })
 
-  test("Send raw with success", async () => {
-    const messageId = "id-123"
-    const from = "test@test.com"
-    const to = "test@test2.com"
-    const msg = "My message"
-    const subject = "My subject"
-    const cc = "test@test3.com"
-    const replyTo = "test@test4.com"
+  test('Send raw with success', async () => {
+    const messageId = 'id-123'
+    const from = 'test@test.com'
+    const to = 'test@test2.com'
+    const msg = 'My message'
+    const subject = 'My subject'
+    const cc = 'test@test3.com'
+    const replyTo = 'test@test4.com'
     SESMock.on(SendRawEmailCommand).resolves({
       MessageId: messageId,
     })
@@ -44,21 +40,17 @@ describe("SendRaw", () => {
     console.log(res)
   })
 
-  test("Send raw with failure", async () => {
-    SESMock.on(SendRawEmailCommand).rejects(new Error("failed!"))
+  test('Send raw with failure', async () => {
+    SESMock.on(SendRawEmailCommand).rejects(new Error('failed!'))
     let res: any = null,
       err: any = null
     try {
-      res = await provider.sendRawEmail(
-        "test@test.com",
-        "My message",
-        "My subject",
-      )
+      res = await provider.sendRawEmail('test@test.com', 'My message', 'My subject')
     } catch (e) {
       err = e
     }
     expect(res).is.null
-    expect(err?.message).to.be.equals("failed!")
+    expect(err?.message).to.be.equals('failed!')
     expect(res).is.null
     console.log(res)
   })

package/tests/Publisher/Publisher.test.ts

@@ -1,25 +1,25 @@
-import { SNSClient, PublishCommand } from "@aws-sdk/client-sns"
-import { mockClient } from "aws-sdk-client-mock"
-import { expect } from "chai"
+import { SNSClient, PublishCommand } from '@aws-sdk/client-sns'
+import { mockClient } from 'aws-sdk-client-mock'
+import { expect } from 'chai'
 
-import Publisher from "../../src/Publisher/Publisher"
+import Publisher from '../../src/Publisher/Publisher'
 
 const SNSMock = mockClient(SNSClient)
 
-describe("Encryption", () => {
+describe('Encryption', () => {
   // reset mock
   beforeEach(() => {
     SNSMock.reset()
   })
 
   const provider = new Publisher({
-    region: "ca-central-1",
+    region: 'ca-central-1',
   })
 
-  test("Publishes with success", async () => {
-    const msg = { text: "123" }
-    const topic = "123"
-    const messageId = "id-123"
+  test('Publishes with success', async () => {
+    const msg = { text: '123' }
+    const topic = '123'
+    const messageId = 'id-123'
     SNSMock.on(PublishCommand, {
       Message: JSON.stringify(msg),
       TopicArn: topic,
@@ -31,10 +31,10 @@ describe("Encryption", () => {
     expect(res.MessageId).to.be.equals(messageId)
   })
 
-  test("Publishes with success (additional props)", async () => {
-    const msg = { text: "123" }
-    const topic = "123"
-    const messageId = "id-123"
+  test('Publishes with success (additional props)', async () => {
+    const msg = { text: '123' }
+    const topic = '123'
+    const messageId = 'id-123'
     SNSMock.on(PublishCommand, {
       Message: JSON.stringify(msg),
       TopicArn: topic,
@@ -48,10 +48,10 @@ describe("Encryption", () => {
     expect(res.MessageId).to.be.equals(messageId)
   })
 
-  test("Publish failure", async () => {
-    const msg = { text: "123" }
-    const topic = "123"
-    SNSMock.on(PublishCommand).rejects(new Error("failed!"))
+  test('Publish failure', async () => {
+    const msg = { text: '123' }
+    const topic = '123'
+    SNSMock.on(PublishCommand).rejects(new Error('failed!'))
     const res = await provider.publishOnTopic(msg, topic)
     expect(res).is.null
   })

package/tests/Server/RouteResolver.test.ts

@@ -1,5 +1,5 @@
-import { Route } from "../../src/Server/Router"
-import RouteResolver from "../../src/Server/RouteResolver"
+import { Route } from '../../src/Server/Router'
+import RouteResolver from '../../src/Server/RouteResolver'
 
 const mockRoute = (method: Method, path: string) =>
   ({
@@ -8,99 +8,96 @@ const mockRoute = (method: Method, path: string) =>
   }) as any as Route
 
 type Method =
-  | Lowercase<"GET" | "POST" | "PUT" | "DELETE">
-  | Uppercase<"GET" | "POST" | "PUT" | "DELETE">
+  | Lowercase<'GET' | 'POST' | 'PUT' | 'DELETE'>
+  | Uppercase<'GET' | 'POST' | 'PUT' | 'DELETE'>
 
-describe("RouteResolver", () => {
-  test("no routes configured", () => {
+describe('RouteResolver', () => {
+  test('no routes configured', () => {
     parameterizedTest({}, () => [
-      ["GET", "/", undefined],
-      ["GET", "", undefined],
-      ["GET", "hjdah", undefined],
+      ['GET', '/', undefined],
+      ['GET', '', undefined],
+      ['GET', 'hjdah', undefined],
     ])
   })
 
-  test("one route, case insensitive", () => {
+  test('one route, case insensitive', () => {
     parameterizedTest(
       {
-        route: mockRoute("get", "/"),
+        route: mockRoute('get', '/'),
       },
-      (routes) => [
-        ["GET", "/", routes.route],
-        ["get", "/", routes.route],
-        ["GET", "", routes.route],
-        ["GET", "hjdah", undefined],
-        ["POST", "/", undefined],
-        ["DELETE", "/", undefined],
-      ],
+      routes => [
+        ['GET', '/', routes.route],
+        ['get', '/', routes.route],
+        ['GET', '', routes.route],
+        ['GET', 'hjdah', undefined],
+        ['POST', '/', undefined],
+        ['DELETE', '/', undefined],
+      ]
     )
   })
 
-  test("basic matching", () => {
+  test('basic matching', () => {
     parameterizedTest(
       {
-        getBase: mockRoute("GET", "/"),
-        getA: mockRoute("GET", "/a"),
-        getB: mockRoute("GET", "/b"),
-        postBase: mockRoute("POST", "/"),
-        postA: mockRoute("POST", "/a"),
-        variable: mockRoute("GET", "/:a"),
-        getAb: mockRoute("GET", "/a/b"),
+        getBase: mockRoute('GET', '/'),
+        getA: mockRoute('GET', '/a'),
+        getB: mockRoute('GET', '/b'),
+        postBase: mockRoute('POST', '/'),
+        postA: mockRoute('POST', '/a'),
+        variable: mockRoute('GET', '/:a'),
+        getAb: mockRoute('GET', '/a/b'),
       },
-      (routes) => [
-        ["GET", "/", routes.getBase],
-        ["GET", "/a", routes.getA],
-        ["GET", "/b", routes.getB],
-        ["POST", "/", routes.postBase],
-        ["POST", "/a", routes.postA],
-        ["GET", "/c", routes.variable],
-        ["GET", "/a/b", routes.getAb],
-      ],
+      routes => [
+        ['GET', '/', routes.getBase],
+        ['GET', '/a', routes.getA],
+        ['GET', '/b', routes.getB],
+        ['POST', '/', routes.postBase],
+        ['POST', '/a', routes.postA],
+        ['GET', '/c', routes.variable],
+        ['GET', '/a/b', routes.getAb],
+      ]
     )
   })
 
-  test("path variables", () => {
+  test('path variables', () => {
     parameterizedTest(
       {
-        path_vars: mockRoute("get", "/base/:a/:b/:c"),
-        abc: mockRoute("get", "/base/a/b/c"),
-        abcd: mockRoute("get", "/base/a/b/c/d"),
-        abc_path: mockRoute("get", "/base/a/b/c/:d"),
+        path_vars: mockRoute('get', '/base/:a/:b/:c'),
+        abc: mockRoute('get', '/base/a/b/c'),
+        abcd: mockRoute('get', '/base/a/b/c/d'),
+        abc_path: mockRoute('get', '/base/a/b/c/:d'),
       },
-      (routes) => [
-        ["GET", "/base/1/2/3", routes.path_vars],
-        ["GET", "/base/a/b/c", routes.abc],
-        ["GET", "/base/a/b/c/d", routes.abcd],
-        ["GET", "/base/a/b/c/u", routes.abc_path],
-        ["GET", "/base/a/b", undefined],
-        ["GET", "/base/a/b/c/d/e", undefined],
-        ["GET", "/base/a/b/c/d/e/f", undefined],
-      ],
+      routes => [
+        ['GET', '/base/1/2/3', routes.path_vars],
+        ['GET', '/base/a/b/c', routes.abc],
+        ['GET', '/base/a/b/c/d', routes.abcd],
+        ['GET', '/base/a/b/c/u', routes.abc_path],
+        ['GET', '/base/a/b', undefined],
+        ['GET', '/base/a/b/c/d/e', undefined],
+        ['GET', '/base/a/b/c/d/e/f', undefined],
+      ]
     )
   })
 
-  test("fails to construct with duplicate routes", () => {
+  test('fails to construct with duplicate routes', () => {
     expect(
       () =>
         new RouteResolver({
-          routes: [
-            mockRoute("GET", "/a/b/c/:d/:e/b"),
-            mockRoute("GET", "/a/b/c/:jshj/:e/b"),
-          ],
-        }),
-    ).toThrowError("Duplicate route: GET: /a/b/c/:jshj/:e/b")
+          routes: [mockRoute('GET', '/a/b/c/:d/:e/b'), mockRoute('GET', '/a/b/c/:jshj/:e/b')],
+        })
+    ).toThrowError('Duplicate route: GET: /a/b/c/:jshj/:e/b')
   })
 })
 
 const parameterizedTest = <T extends { [k: string]: Route }>(
   routes: T,
-  tests: (routes: T) => [Method, string, Route?][],
+  tests: (routes: T) => [Method, string, Route?][]
 ) => {
   const underTest = new RouteResolver({
     routes: Object.values(routes),
   })
 
   tests(routes).forEach(([method, path, expected]) =>
-    expect(underTest.resolveRoute(method, path)).toBe(expected),
+    expect(underTest.resolveRoute(method, path)).toBe(expected)
   )
 }

package/tests/Server/Router.test.ts

@@ -1,15 +1,15 @@
-import { expect } from "chai"
+import { expect } from 'chai'
 
-import ContainerServer from "../../src/Server/lib/ContainerServer"
-import Server from "../../src/Server/lib/Server"
-import Router from "../../src/Server/Router"
+import ContainerServer from '../../src/Server/lib/ContainerServer'
+import Server from '../../src/Server/lib/Server'
+import Router from '../../src/Server/Router'
 
-describe("Router basics", () => {
+describe('Router 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()
@@ -18,20 +18,20 @@ describe("Router basics", () => {
     mockExit.mockReset()
   })
 
-  test("Serverless server", async () => {
-    process.env["HYBRIDLESS_RUNTIME"] = undefined
+  test('Serverless server', async () => {
+    process.env['HYBRIDLESS_RUNTIME'] = undefined
     const router = new Router({ routes: [] })
     expect(router.getExport()).to.not.be.undefined
-    expect(router["server"]).to.be.an.instanceof(Server)
-    expect(router["server"]).to.not.be.an.instanceof(ContainerServer)
+    expect(router['server']).to.be.an.instanceof(Server)
+    expect(router['server']).to.not.be.an.instanceof(ContainerServer)
   })
-  test("Container server", async () => {
-    process.env["HYBRIDLESS_RUNTIME"] = "true"
+  test('Container server', async () => {
+    process.env['HYBRIDLESS_RUNTIME'] = 'true'
     const router = new Router({ routes: [] })
     expect(router.getExport()).to.not.be.undefined
-    expect(router["server"]).to.be.an.instanceof(Server)
-    expect(router["server"]).to.be.an.instanceof(ContainerServer)
-    await router["server"]["stop"]()
+    expect(router['server']).to.be.an.instanceof(Server)
+    expect(router['server']).to.be.an.instanceof(ContainerServer)
+    await router['server']['stop']()
   })
 })