@creator.co/wapi 1.7.1-alpha1 → 1.7.1-alpha3

package/tests/Server/lib/container/GenericHandler.test.ts

@@ -1,131 +0,0 @@
-import { jest } from '@jest/globals'
-import { APIGatewayProxyEvent, Context } from 'aws-lambda'
-import { expect as c_expect } from 'chai'
-import { Request, Response } from 'express'
-
-import Globals from '../../../../src/Globals'
-import GenericHandler from '../../../../src/Server/lib/container/GenericHandler'
-
-function observableResponse(): Response {
-  const resp = <Response>(<unknown>{
-    send: jest.fn(() => resp),
-    json: jest.fn(() => resp),
-    status: jest.fn(() => resp),
-    header: jest.fn(() => resp),
-  })
-  return resp
-}
-
-describe('GenericHandler success invocation path', () => {
-  test('Simple success', async () => {
-    const v = {
-      statusCode: 200,
-      body: JSON.stringify({ id: 123 }),
-    }
-    const handler = GenericHandler(async (event: APIGatewayProxyEvent, context: Context) => {
-      context.succeed(v)
-    })
-    const resp = observableResponse()
-    const handlerResp = await handler(<Request>(<unknown>{}), resp)
-    //
-    c_expect(handlerResp).to.be.undefined
-    expect(resp.send).not.toBeCalled()
-    expect(resp.json).toBeCalledWith(JSON.parse(v.body))
-    expect(resp.status).toBeCalledWith(v.statusCode)
-    expect(resp.header).not.toBeCalled()
-  })
-
-  test('Simple success w/ headers', async () => {
-    const v = {
-      statusCode: 200,
-      body: JSON.stringify({ id: 123 }),
-      headers: { Authorization: 123 },
-    }
-    const handler = GenericHandler(async (event: APIGatewayProxyEvent, context: Context) => {
-      context.succeed(v)
-    })
-    const resp = observableResponse()
-    const handlerResp = await handler(<Request>(<unknown>{}), resp)
-    //
-    c_expect(handlerResp).to.be.undefined
-    expect(resp.send).not.toBeCalled()
-    expect(resp.json).toBeCalledWith(JSON.parse(v.body))
-    expect(resp.status).toBeCalledWith(v.statusCode)
-    expect(resp.header).toBeCalledTimes(Object.keys(v.headers).length)
-  })
-
-  test('Simple success w/ null body', async () => {
-    const v = {
-      statusCode: 200,
-      headers: { Authorization: 123 },
-    }
-    const handler = GenericHandler(async (event: APIGatewayProxyEvent, context: Context) => {
-      context.succeed(v)
-    })
-    const resp = observableResponse()
-    const handlerResp = await handler(<Request>(<unknown>{}), resp)
-    //
-    c_expect(handlerResp).to.be.undefined
-    expect(resp.send).not.toBeCalled()
-    expect(resp.json).toBeCalledWith({})
-    expect(resp.status).toBeCalledWith(v.statusCode)
-    expect(resp.header).toBeCalledTimes(Object.keys(v.headers).length)
-  })
-})
-
-describe('GenericHandler failure invocation path', () => {
-  test('Invalid response', async () => {
-    const handler = GenericHandler(async (event: APIGatewayProxyEvent, context: Context) => {
-      context.succeed(null)
-    })
-    const resp = observableResponse()
-    const handlerResp = await handler(<Request>(<unknown>{}), resp)
-    //
-    c_expect(handlerResp).to.be.undefined
-    expect(resp.send).not.toBeCalled()
-    expect(resp.header).not.toBeCalled()
-    expect(resp.json).toBeCalledWith({
-      err: Globals.Resp_MSG_INVALIDRESP,
-      errCode: Globals.Resp_CODE_INVALIDRESP,
-    })
-    expect(resp.status).toBeCalledWith(Globals.Resp_STATUSCODE_INVALIDRESP)
-  })
-
-  test('Error response', async () => {
-    const err = new Error('Failed!')
-    const handler = GenericHandler(async (event: APIGatewayProxyEvent, context: Context) => {
-      context.fail(err)
-    })
-    const resp = observableResponse()
-    const handlerResp = await handler(<Request>(<unknown>{}), resp)
-    //
-    c_expect(handlerResp).to.be.undefined
-    expect(resp.send).not.toBeCalled()
-    expect(resp.header).not.toBeCalled()
-    expect(resp.json).toBeCalledWith({
-      err,
-    })
-    expect(resp.status).toBeCalledWith(400)
-  })
-
-  test('Exception response', async () => {
-    const err = new Error('Failed!')
-    const handler = GenericHandler(async () => {
-      throw err
-    })
-    const resp = observableResponse()
-    const handlerResp = await handler(<Request>(<unknown>{}), resp)
-    //
-    c_expect(handlerResp).to.be.undefined
-    expect(resp.send).not.toBeCalled()
-    expect(resp.header).not.toBeCalled()
-    expect(resp.json).toBeCalledWith({
-      ...err,
-      err: Globals.Resp_MSG_EXCEPTION,
-      errCode: Globals.Resp_CODE_EXCEPTION,
-    })
-    expect(resp.status).toBeCalledWith(Globals.Resp_STATUSCODE_EXCEPTION)
-  })
-})
-
-export {}

package/tests/Server/lib/container/GenericHandlerEvent.test.ts

@@ -1,103 +0,0 @@
-import { APIGatewayProxyEvent, Context } from 'aws-lambda'
-import { expect } from 'chai'
-import { Request } from 'express'
-
-import { HttpMethod } from '../../../../src/API/Request'
-import GenericHandlerEvent from '../../../../src/Server/lib/container/GenericHandlerEvent'
-
-describe('GenericHandlerEvent invocation paths', () => {
-  test('Simple success', async () => {
-    const event = new GenericHandlerEvent(
-      <Request>(<unknown>{
-        socket: { remoteAddress: '127.0.0.1' },
-      }),
-      async (event: APIGatewayProxyEvent, context: Context) => {
-        expect(context.getRemainingTimeInMillis()).to.not.be.null
-        context.succeed('Success')
-      }
-    )
-    const resp = await event.invoke()
-    expect(resp).to.not.be.null
-    expect(resp.err).to.be.undefined
-    expect(resp.data).to.be.equals('Success')
-  })
-
-  test('Simple failure', async () => {
-    const event = new GenericHandlerEvent(
-      <Request>(<unknown>{}),
-      async (event: APIGatewayProxyEvent, context: Context) => {
-        context.fail('Error!')
-      }
-    )
-    const resp = await event.invoke()
-    expect(resp).to.not.be.null
-    expect(resp.data).to.be.undefined
-    expect(resp.err).to.be.equals('Error!')
-  })
-
-  test('Simple done (errored)', async () => {
-    const event = new GenericHandlerEvent(
-      <Request>(<unknown>{}),
-      async (event: APIGatewayProxyEvent, context: Context) => {
-        context.done(new Error('Error!'))
-      }
-    )
-    const resp = await event.invoke()
-    expect(resp).to.not.be.null
-    expect(resp.data).to.be.undefined
-    expect(resp.err).to.be.an('Error')
-    if (resp.err instanceof Error) expect(resp.err?.message).to.be.equals('Error!')
-  })
-
-  test('Simple done (success)', async () => {
-    const event = new GenericHandlerEvent(
-      <Request>(<unknown>{}),
-      async (event: APIGatewayProxyEvent, context: Context) => {
-        context.done(undefined, 'Success!')
-      }
-    )
-    const resp = await event.invoke()
-    expect(resp).to.not.be.null
-    expect(resp.err).to.be.undefined
-    expect(resp.data).to.be.equals('Success!')
-  })
-
-  test('Exception on execution', async () => {
-    const event = new GenericHandlerEvent(<Request>(<unknown>{}), async () => {
-      throw new Error('Failed!')
-    })
-    let err: any = null,
-      resp: any = null
-    try {
-      resp = await event.invoke()
-    } catch (e) {
-      err = e
-    }
-    expect(resp).to.be.null
-    expect(err).to.not.be.null
-    expect(err).to.be.an('Error')
-    expect(err.message).to.be.equals('Failed!')
-  })
-})
-
-describe('GenericHandlerEvent event test', () => {
-  test('Simple event test', async () => {
-    const event = new GenericHandlerEvent(
-      <Request>(<unknown>{
-        headers: { Authorization: '123', 'x-forwarded-for': '127.0.0.1' },
-        method: HttpMethod.GET,
-        query: '/status?name=ryan',
-      }),
-      async (event: APIGatewayProxyEvent, context: Context) => {
-        expect(context.getRemainingTimeInMillis()).to.not.be.null
-        context.succeed('Success')
-      }
-    )
-    const resp = await event.invoke()
-    expect(resp).to.not.be.null
-    expect(resp.err).to.be.undefined
-    expect(resp.data).to.be.equals('Success')
-  })
-})
-
-export {}

package/tests/Server/lib/container/HealthHandler.test.ts

@@ -1,30 +0,0 @@
-import { jest } from '@jest/globals'
-import { expect as c_expect } from 'chai'
-import { Request, Response } from 'express'
-
-import HealthHandler from '../../../../src/Server/lib/container/HealthHandler'
-
-function observableResponse(): Response {
-  const resp = <Response>(<unknown>{
-    send: jest.fn(() => resp),
-    json: jest.fn(() => resp),
-    status: jest.fn(() => resp),
-    header: jest.fn(() => resp),
-  })
-  return resp
-}
-
-describe('HealthHandler invocation path', () => {
-  test('Simple', async () => {
-    const resp = observableResponse()
-    const handlerResp = await HealthHandler(<Request>(<unknown>{}), resp)
-    //
-    c_expect(handlerResp).to.be.undefined
-    expect(resp.send).toBeCalledWith('Healthy!')
-    expect(resp.json).not.toBeCalled()
-    expect(resp.status).not.toBeCalled()
-    expect(resp.header).not.toBeCalled()
-  })
-})
-
-export {}

package/tests/Server/lib/container/Proxy.test.ts

@@ -1,268 +0,0 @@
-import { jest } from '@jest/globals'
-import { APIGatewayProxyEvent, Context } from 'aws-lambda'
-import { expect as c_expect } from 'chai'
-import request from 'supertest'
-
-import Globals from '../../../../src/Globals'
-import Proxy from '../../../../src/Server/lib/container/Proxy'
-import { defaultUrl } from '../../../Test.utils'
-
-describe('Proxy configs', () => {
-  // @ts-ignore
-  let mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {})
-  beforeAll(() => {
-    // @ts-ignore
-    mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {})
-  })
-  afterAll(() => {
-    mockExit.mockRestore()
-  })
-  beforeEach(() => {
-    mockExit.mockReset()
-  })
-
-  test('Empty config url & unload with error', async () => {
-    const proxy = new Proxy({ routes: [] }, async () => {})
-    await proxy.load()
-    await proxy.unload('Error')
-    expect(mockExit).toBeCalledWith(1)
-  })
-
-  test('Simple port config', async () => {
-    const proxy = new Proxy({ routes: [], port: 56562 }, async () => {})
-    await proxy.load()
-    await proxy.unload()
-    expect(mockExit).toBeCalledWith(0)
-  })
-
-  test('Simple timeout config', async () => {
-    const proxy = new Proxy({ routes: [], timeout: 1000 }, async () => {})
-    await proxy.load()
-    await proxy.unload()
-    expect(mockExit).toBeCalledWith(0)
-  })
-
-  test('Simple cors config', async () => {
-    const proxy = new Proxy(
-      {
-        routes: [],
-        cors: {
-          origin: '*',
-          headers: ['Authorization'],
-          allowCredentials: true,
-        },
-      },
-      async () => {}
-    )
-    await proxy.load()
-    await proxy.unload()
-    expect(mockExit).toBeCalledWith(0)
-  })
-
-  test('Empty cors config', async () => {
-    const proxy = new Proxy(
-      {
-        routes: [],
-        cors: {},
-      },
-      async () => {}
-    )
-    await proxy.load()
-    await proxy.unload()
-    expect(mockExit).toBeCalledWith(0)
-  })
-})
-
-describe('Proxy behaviour', () => {
-  // @ts-ignore
-  let mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {})
-  beforeAll(() => {
-    // @ts-ignore
-    mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {})
-  })
-  afterAll(() => {
-    mockExit.mockRestore()
-  })
-  beforeEach(() => {
-    mockExit.mockReset()
-  })
-
-  test('Stop twice', async () => {
-    const proxy = new Proxy({ routes: [] }, async () => {})
-    await proxy.load()
-    await Promise.all([proxy.unload('Error'), proxy.unload('Error')])
-    expect(mockExit).toHaveBeenCalledTimes(1)
-    expect(mockExit).toBeCalledWith(1)
-  })
-})
-
-describe('Proxy routing', () => {
-  // @ts-ignore
-  let mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {})
-  beforeAll(() => {
-    // @ts-ignore
-    mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {})
-  })
-  afterAll(() => {
-    mockExit.mockRestore()
-  })
-  beforeEach(() => {
-    mockExit.mockReset()
-  })
-
-  test('Health & Default handler', async () => {
-    let count = 0
-    const proxy = new Proxy(
-      { routes: [] },
-      async (event: APIGatewayProxyEvent, context: Context) => {
-        count++
-        context.succeed({
-          body: JSON.stringify({ name: '123' }),
-          statusCode: 200,
-        })
-      }
-    )
-    await proxy.load()
-    // Health check
-    const res = await request(defaultUrl)
-      .get(Globals.Listener_HTTP_DefaultHealthCheckRoute)
-      .expect('Content-Type', 'text/html; charset=utf-8')
-      .expect(200)
-    c_expect(res.text).to.be.equals('Healthy!')
-    // Generic handler
-    const resG = await request(defaultUrl)
-      .get(`/abc`)
-      .expect('Content-Type', 'application/json; charset=utf-8')
-      .expect(200)
-    c_expect(resG.body).to.be.deep.equals({ name: '123' })
-    // Expected count
-    c_expect(count).to.be.equals(1)
-    // Unload
-    await proxy.unload('Error')
-    expect(mockExit).toHaveBeenCalledTimes(1)
-    expect(mockExit).toBeCalledWith(1)
-  })
-
-  test('Proxy on custom port', async () => {
-    let count = 0
-    const port = 56542
-    const url = defaultUrl.replace(String(Globals.Listener_HTTP_DefaultPort), String(port))
-    const proxy = new Proxy(
-      { routes: [], port },
-      async (event: APIGatewayProxyEvent, context: Context) => {
-        count++
-        context.succeed({
-          body: JSON.stringify({ name: '123' }),
-          statusCode: 200,
-        })
-      }
-    )
-    await proxy.load()
-    // Health check
-    const res = await request(url)
-      .get(Globals.Listener_HTTP_DefaultHealthCheckRoute)
-      .expect('Content-Type', 'text/html; charset=utf-8')
-      .expect(200)
-    c_expect(res.text).to.be.equals('Healthy!')
-    // Generic handler
-    const resG = await request(url)
-      .get(`/abc`)
-      .expect('Content-Type', 'application/json; charset=utf-8')
-      .expect(200)
-    c_expect(resG.body).to.be.deep.equals({ name: '123' })
-    // Expected count
-    c_expect(count).to.be.equals(1)
-    // Unload
-    await proxy.unload()
-    expect(mockExit).toHaveBeenCalledTimes(1)
-    expect(mockExit).toBeCalledWith(0)
-  })
-
-  test('Proxy does timeout', async () => {
-    let count = 0
-    const timeout = 1000
-    const proxy = new Proxy(
-      { routes: [], timeout },
-      async (event: APIGatewayProxyEvent, context: Context) => {
-        count++
-        setTimeout(() => {
-          context.succeed({
-            body: JSON.stringify({ name: '123' }),
-            statusCode: 200,
-          })
-        }, timeout * 2)
-      }
-    )
-    await proxy.load()
-    // Health check
-    const res = await request(defaultUrl)
-      .get(Globals.Listener_HTTP_DefaultHealthCheckRoute)
-      .expect('Content-Type', 'text/html; charset=utf-8')
-      .expect(200)
-    c_expect(res.text).to.be.equals('Healthy!')
-    // Generic handler
-    let err: any = null
-    try {
-      await request(defaultUrl)
-        .get(`/abc`)
-        .expect('Content-Type', 'application/json; charset=utf-8')
-        .expect(200)
-    } catch (e) {
-      err = e
-    }
-    c_expect(err?.message).to.be.equals('socket hang up')
-    // Expected count
-    c_expect(count).to.be.equals(1)
-    // Unload
-    await proxy.unload('Error')
-    expect(mockExit).toHaveBeenCalledTimes(1)
-    expect(mockExit).toBeCalledWith(1)
-    //
-    return new Promise(resolve => {
-      setTimeout(resolve, timeout * 2)
-    })
-  })
-
-  test('Proxy respects cors', async () => {
-    let count = 0
-    const proxy = new Proxy(
-      {
-        routes: [],
-        cors: {
-          origin: '*',
-          headers: ['Authorization'],
-          allowCredentials: true,
-        },
-      },
-      async (event: APIGatewayProxyEvent, context: Context) => {
-        count++
-        context.succeed({
-          body: JSON.stringify({ name: '123' }),
-          statusCode: 200,
-        })
-      }
-    )
-    await proxy.load()
-    // White-listed header is allowed
-    const resWH = await request(defaultUrl).options(`/abc`).set('Authorization', '123').expect(204)
-    c_expect(resWH.header['access-control-allow-origin']).to.equal('*')
-    c_expect(resWH.header['access-control-allow-credentials']).to.equal('true')
-    c_expect(resWH.header['access-control-allow-headers']).to.equal('Authorization')
-    // Non white-listed header is allowed
-    const resNWH = await request(defaultUrl)
-      .options(`/abc`)
-      .set('2Authorization2', '123')
-      .expect(204)
-    c_expect(resNWH.header['access-control-allow-origin']).to.equal('*')
-    c_expect(resNWH.header['access-control-allow-credentials']).to.equal('true')
-    c_expect(resNWH.header['access-control-allow-headers']).to.equal('Authorization')
-    // Expected count
-    c_expect(count).to.be.equals(0)
-    // Unload
-    await proxy.unload()
-    expect(mockExit).toHaveBeenCalledTimes(1)
-    expect(mockExit).toBeCalledWith(0)
-  })
-})
-
-export {}

package/tests/Server/lib/container/Utils.test.ts

@@ -1,47 +0,0 @@
-import { expect } from 'chai'
-
-import * as Utils from '../../../../src/Server/lib/container/Utils'
-
-describe('parseQueryStringParameters', () => {
-  test('Null url', () => {
-    // @ts-ignore
-    const validationResult = Utils.parseQueryStringParameters(null)
-    expect(validationResult).to.be.deep.equals({})
-  })
-
-  test('Empty url', () => {
-    const validationResult = Utils.parseQueryStringParameters('')
-    expect(validationResult).to.be.deep.equals({})
-  })
-
-  test('Simple param', () => {
-    const validationResult = Utils.parseQueryStringParameters('/status?name=ryan')
-    expect(validationResult).to.be.deep.equals({
-      name: 'ryan',
-    })
-  })
-})
-
-describe('parseMultiValueQueryStringParameters', () => {
-  test('Null url', () => {
-    // @ts-ignore
-    const validationResult = Utils.parseMultiValueQueryStringParameters()
-    expect(validationResult).to.be.deep.equals({})
-  })
-
-  test('Empty url', () => {
-    const validationResult = Utils.parseMultiValueQueryStringParameters('')
-    expect(validationResult).to.be.deep.equals({})
-  })
-
-  test('Simple multivalue param', () => {
-    const validationResult = Utils.parseMultiValueQueryStringParameters(
-      '/status?name=ryan&name=ryan2'
-    )
-    expect(validationResult).to.be.deep.equals({
-      name: ['ryan', 'ryan2'],
-    })
-  })
-})
-
-export {}

package/tests/Test.utils.ts

@@ -1,74 +0,0 @@
-import { jest } from '@jest/globals'
-import { APIGatewayEvent, Context, SQSEvent } from 'aws-lambda'
-import { z } from 'zod'
-
-import Transaction from '../src/BaseEvent/Transaction'
-import Globals from '../src/Globals'
-
-export const defaultHeaders = {
-  'Access-Control-Allow-Credentials': true,
-  'Access-Control-Allow-Origin': '*',
-  'Content-Type': 'application/json',
-}
-
-export const defaultUrl = `localhost:${Globals.Listener_HTTP_DefaultPort}`
-
-export const SampleConfig = {
-  PATH: {
-    isLocal: true,
-    required: true,
-  },
-  PATH_FALSY: {
-    isLocal: true,
-    required: true,
-  },
-  PATH123: {
-    isLocal: true,
-    required: false,
-  },
-  TOKEN_SECRET: {
-    isRemote: true,
-    required: true,
-  },
-  TOKEN_SECRET_FALSY: {
-    isRemote: true,
-    required: false,
-  },
-} as const
-
-export function observableContext(data?: any) {
-  return <Context>(<unknown>{
-    done: jest.fn(),
-    fail: jest.fn(),
-    succeed: jest.fn(),
-    ...(data || {}),
-  })
-}
-
-export const privateKey = 'tMHOuszBQmF6XtwgrUpvqpk07rh3RATX'
-
-export const foreignToken =
-  'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c'
-
-export const ViewSchema = z.object({
-  id: z.string(),
-  content: z.string(),
-  createdAt: z.date(),
-  updatedAt: z.date(),
-})
-
-export type View = z.infer<typeof ViewSchema>
-
-export function emptyEvent(data?: any) {
-  return <APIGatewayEvent>(<unknown>data || {})
-}
-
-export function emptyQueueEvent(data?: any) {
-  return <SQSEvent>(<unknown>data || {})
-}
-
-export function observableTransaction() {
-  const t = new Transaction(emptyEvent(), observableContext())
-  t.responseProxy = jest.fn() as any
-  return t
-}