@creator.co/wapi 1.2.1-beta6 → 1.2.3

package/tests/Mailer/Mailer.test.ts

@@ -0,0 +1,59 @@
+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'
+
+const SESMock = mockClient(SESClient)
+
+describe('SendRaw', () => {
+  // reset mock
+  beforeEach(() => {
+    SESMock.reset()
+  })
+
+  const provider = new Mailer('dev+tests@creator.co', 'ca-central-1')
+
+  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')
+    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'
+    SESMock.on(SendRawEmailCommand).resolves({
+      MessageId: messageId,
+    })
+    const res = await provider.sendRawEmail(to, msg, subject, cc, from, replyTo)
+    expect(res).is.not.null
+    console.log(res)
+  })
+
+  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')
+    } catch (e) {
+      err = e
+    }
+    expect(res).is.null
+    expect(err?.message).to.be.equals('failed!')
+    expect(res).is.null
+    console.log(res)
+  })
+})
+
+export {}

package/tests/Publisher/Publisher.test.ts

@@ -0,0 +1,60 @@
+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'
+
+const SNSMock = mockClient(SNSClient)
+
+describe('Encryption', () => {
+  // reset mock
+  beforeEach(() => {
+    SNSMock.reset()
+  })
+
+  const provider = new Publisher({
+    region: 'ca-central-1',
+  })
+
+  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,
+    }).resolves({
+      MessageId: messageId,
+    })
+    const res = await provider.publishOnTopic(msg, topic)
+    expect(res).is.not.null
+    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'
+    SNSMock.on(PublishCommand, {
+      Message: JSON.stringify(msg),
+      TopicArn: topic,
+    }).resolves({
+      MessageId: messageId,
+    })
+    const res = await provider.publishOnTopic(msg, topic, {
+      FifoGroup: 123,
+    })
+    expect(res).is.not.null
+    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!'))
+    const res = await provider.publishOnTopic(msg, topic)
+    expect(res).is.null
+  })
+})
+
+export {}

package/tests/Server/RouteResolver.test.ts

@@ -0,0 +1,103 @@
+import { Route } from '../../src/Server/Router'
+import RouteResolver from '../../src/Server/RouteResolver'
+
+const mockRoute = (method: Method, path: string) =>
+  ({
+    method: method,
+    path: path,
+  }) as any as Route
+
+type Method =
+  | Lowercase<'GET' | 'POST' | 'PUT' | 'DELETE'>
+  | Uppercase<'GET' | 'POST' | 'PUT' | 'DELETE'>
+
+describe('RouteResolver', () => {
+  test('no routes configured', () => {
+    parameterizedTest({}, () => [
+      ['GET', '/', undefined],
+      ['GET', '', undefined],
+      ['GET', 'hjdah', undefined],
+    ])
+  })
+
+  test('one route, case insensitive', () => {
+    parameterizedTest(
+      {
+        route: mockRoute('get', '/'),
+      },
+      routes => [
+        ['GET', '/', routes.route],
+        ['get', '/', routes.route],
+        ['GET', '', routes.route],
+        ['GET', 'hjdah', undefined],
+        ['POST', '/', undefined],
+        ['DELETE', '/', undefined],
+      ]
+    )
+  })
+
+  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'),
+      },
+      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', () => {
+    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'),
+      },
+      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', () => {
+    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')
+  })
+})
+
+const parameterizedTest = <T extends { [k: string]: Route }>(
+  routes: T,
+  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)
+  )
+}

package/tests/Server/Router.test.ts

@@ -0,0 +1,38 @@
+import { expect } from 'chai'
+
+import ContainerServer from '../../src/Server/lib/ContainerServer'
+import Server from '../../src/Server/lib/Server'
+import Router from '../../src/Server/Router'
+
+describe('Router basics', () => {
+  // @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('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)
+  })
+  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']()
+  })
+})
+
+export {}

package/tests/Server/lib/ContainerServer.test.ts

@@ -0,0 +1,327 @@
+import { expect as j_expect } from '@jest/globals'
+import { expect } from 'chai'
+import * as request from 'supertest'
+import { z } from 'zod'
+
+import Response from '../../../src/API/Response'
+import Globals from '../../../src/Globals'
+import ContainerServer from '../../../src/Server/lib/ContainerServer'
+import { defaultUrl } from '../../Test.utils'
+
+export const ViewSchema = z.object({
+  id: z.string(),
+  content: z.string(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+})
+
+describe('Container server 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 & 404 handler', async () => {
+    const server = new ContainerServer({ routes: [] })
+    await server.start()
+    // Health check
+    const res = await request(defaultUrl)
+      .get(Globals.Listener_HTTP_DefaultHealthCheckRoute)
+      .expect('Content-Type', 'text/html; charset=utf-8')
+      .expect(200)
+    expect(res.text).to.be.equals('Healthy!')
+    // Not handled
+    await request(defaultUrl)
+      .get(`/abc`)
+      .expect('Content-Type', 'application/json; charset=utf-8')
+      .expect(404)
+
+    // Unload
+    await server.stop('Error')
+    j_expect(mockExit).toHaveBeenCalledTimes(1)
+    j_expect(mockExit).toBeCalledWith(1)
+  })
+
+  test('Simple route', async () => {
+    const server = new ContainerServer({
+      routes: [
+        {
+          path: '/abc',
+          method: 'get',
+          handler: async () => {
+            return Response.SimpleResponse({ name: 'abc' })
+          },
+        },
+      ],
+    })
+    await server.start()
+    // Health check
+    const res = await request(defaultUrl)
+      .get(Globals.Listener_HTTP_DefaultHealthCheckRoute)
+      .expect('Content-Type', 'text/html; charset=utf-8')
+      .expect(200)
+    expect(res.text).to.be.equals('Healthy!')
+    // Found route
+    const resG = await request(defaultUrl)
+      .get(`/abc`)
+      .expect('Content-Type', 'application/json; charset=utf-8')
+      .expect(200)
+    expect(resG.body['name']).to.be.deep.equals('abc')
+    expect(resG.body['transactionID']).to.not.be.null
+    // Found route, but not method
+    await request(defaultUrl)
+      .post(`/abc`)
+      .expect('Content-Type', 'application/json; charset=utf-8')
+      .expect(404)
+    // Not found route
+    await request(defaultUrl)
+      .get(`/abc/123`)
+      .expect('Content-Type', 'application/json; charset=utf-8')
+      .expect(404)
+    // Unload
+    await server.stop('Error')
+    j_expect(mockExit).toHaveBeenCalledTimes(1)
+    j_expect(mockExit).toBeCalledWith(1)
+  })
+})
+
+describe('Container server basics', () => {
+  // @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('Starts with exports', async () => {
+    const server = new ContainerServer({ routes: [] })
+    server.getExport()
+    return new Promise(resolve => {
+      setTimeout(async () => {
+        // Health check
+        const res = await request(defaultUrl)
+          .get(Globals.Listener_HTTP_DefaultHealthCheckRoute)
+          .expect('Content-Type', 'text/html; charset=utf-8')
+          .expect(200)
+        expect(res.text).to.be.equals('Healthy!')
+        // Unload
+        await server.stop()
+        j_expect(mockExit).toHaveBeenCalledTimes(1)
+        j_expect(mockExit).toBeCalledWith(0)
+        resolve(null)
+      }, 2000)
+    })
+  })
+
+  test('Stops if process sends message SIGINT', async () => {
+    const server = new ContainerServer({ routes: [] })
+    await server.start()
+    process.emit('SIGINT')
+    return new Promise(resolve => {
+      setTimeout(async () => {
+        j_expect(mockExit).toHaveBeenCalledTimes(1)
+        j_expect(mockExit).toBeCalledWith(0)
+        resolve(null)
+      }, 2000)
+    })
+  }, 10000)
+
+  test('Stops if process sends message unhandledRejection', async () => {
+    const server = new ContainerServer({ routes: [] })
+    await server.start()
+    // @ts-ignore
+    process.emit('unhandledRejection')
+    return new Promise(resolve => {
+      setTimeout(async () => {
+        j_expect(mockExit).toHaveBeenCalledTimes(1)
+        j_expect(mockExit).toBeCalledWith(0)
+        resolve(null)
+      }, 2000)
+    })
+  }, 10000)
+})
+
+describe('Container server validation', () => {
+  // @ts-ignore
+  let mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {})
+  beforeAll(() => {
+    // @ts-ignore
+    mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {})
+  })
+  afterAll(() => {
+    mockExit.mockRestore()
+  })
+  beforeEach(() => {
+    mockExit.mockReset()
+  })
+
+  function validateValidationFailure(res: any, failureCount?: number) {
+    expect(res.body['err']).to.be.equals(Globals.ErrorResponseValidationFail)
+    expect(res.body['errCode']).to.be.equals(Globals.ErrorCode_InvalidInput)
+    expect(res.body['transactionID']).to.not.be.null
+    expect(res.body['transactionID']).to.be.an('string')
+    expect(res.body['validationFailure']?.length).to.be.equals(failureCount || 4)
+  }
+
+  test('Validates empty body', async () => {
+    const server = new ContainerServer({
+      routes: [
+        {
+          path: '/abc',
+          method: 'post',
+          inputSchema: ViewSchema,
+          handler: async () => {
+            return Response.SimpleResponse({ name: 'abc' })
+          },
+        },
+      ],
+    })
+    await server.start()
+    // Validation fails, empty body
+    const resG = await request(defaultUrl)
+      .post(`/abc`)
+      .expect('Content-Type', 'application/json; charset=utf-8')
+      .expect(400)
+    validateValidationFailure(resG)
+    await server.stop()
+  })
+
+  test('Validates empty string body', async () => {
+    const server = new ContainerServer({
+      routes: [
+        {
+          path: '/abc',
+          method: 'post',
+          inputSchema: ViewSchema,
+          handler: async () => {
+            return Response.SimpleResponse({ name: 'abc' })
+          },
+        },
+      ],
+    })
+    await server.start()
+    // Validation fails, empty body
+    const resG = await request(defaultUrl)
+      .post(`/abc`)
+      .send('')
+      .expect('Content-Type', 'application/json; charset=utf-8')
+      .expect(400)
+    validateValidationFailure(resG)
+    await server.stop()
+  })
+
+  test('Validates empty object body', async () => {
+    const server = new ContainerServer({
+      routes: [
+        {
+          path: '/abc',
+          method: 'post',
+          inputSchema: ViewSchema,
+          handler: async () => {
+            return Response.SimpleResponse({ name: 'abc' })
+          },
+        },
+      ],
+    })
+    await server.start()
+    // Validation fails, empty body
+    const resG = await request(defaultUrl)
+      .post(`/abc`)
+      .send({})
+      .expect('Content-Type', 'application/json; charset=utf-8')
+      .expect(400)
+    validateValidationFailure(resG)
+    await server.stop()
+  })
+
+  test('Validates missing props body', async () => {
+    const server = new ContainerServer({
+      routes: [
+        {
+          path: '/abc',
+          method: 'post',
+          inputSchema: ViewSchema,
+          handler: async () => {
+            return Response.SimpleResponse({ name: 'abc' })
+          },
+        },
+      ],
+    })
+    await server.start()
+    // Validation fails, empty body
+    const resG = await request(defaultUrl)
+      .post(`/abc`)
+      .send({ id: '123' })
+      .expect('Content-Type', 'application/json; charset=utf-8')
+      .expect(400)
+    validateValidationFailure(resG, 3)
+    await server.stop()
+  })
+
+  test('Validates wrong type props body', async () => {
+    const server = new ContainerServer({
+      routes: [
+        {
+          path: '/abc',
+          method: 'post',
+          inputSchema: ViewSchema,
+          handler: async () => {
+            return Response.SimpleResponse({ name: 'abc' })
+          },
+        },
+      ],
+    })
+    await server.start()
+    // Validation fails, empty body
+    const resG = await request(defaultUrl)
+      .post(`/abc`)
+      .send({ id: 123 })
+      .expect('Content-Type', 'application/json; charset=utf-8')
+      .expect(400)
+    validateValidationFailure(resG)
+    await server.stop()
+  })
+
+  test('Validates successfully', async () => {
+    const server = new ContainerServer({
+      routes: [
+        {
+          path: '/abc',
+          method: 'post',
+          inputSchema: ViewSchema,
+          handler: async () => {
+            return Response.SimpleResponse({ name: 'abc' })
+          },
+        },
+      ],
+    })
+    await server.start()
+    // Validation fails, empty body
+    await request(defaultUrl)
+      .post(`/abc`)
+      .send({
+        id: '123',
+        content: '123',
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      })
+      .expect('Content-Type', 'application/json; charset=utf-8')
+      .expect(200)
+    await server.stop()
+  })
+})
+export {}

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

@@ -0,0 +1,12 @@
+import { expect } from 'chai'
+
+import Server from '../../../src/Server/lib/Server'
+
+describe('Server basics', () => {
+  test('Works', async () => {
+    const server = new Server({ routes: [] })
+    expect(server.getExport()).to.not.be.undefined
+  })
+})
+
+export {}