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

package/tests/Database/integrations/kysely/KyselyTransaction.test.ts

@@ -1,119 +0,0 @@
-import { jest } from '@jest/globals'
-import { Kysely, Transaction } from 'kysely'
-
-import type { DbConfig } from '../../../../src/Database'
-import { KyselyDatabase } from '../../../../src/Database/integrations/kysely/KyselyDatabase'
-import { KyselyTransactionImpl } from '../../../../src/Database/integrations/kysely/KyselyTransaction'
-
-const testResources = async (config: Partial<DbConfig<'kysely'>>) => {
-  type DB = {
-    view: {
-      id: number
-    }
-    secondView: {
-      title: string
-    }
-  }
-
-  const database = {
-    config: {
-      autoCommit: true,
-      ...config,
-    } as DbConfig<'kysely'>,
-  } as KyselyDatabase<DB>
-
-  const transaction = jest.fn().mockImplementation(() => {
-    return {
-      execute: jest.fn(async (cb: any) => {
-        try {
-          await cb(transaction)
-        } catch (e) {
-          /* empty */
-        }
-      }),
-      executeQuery: jest.fn(),
-    }
-  })() as any as Transaction<DB>
-
-  const writer = jest.fn().mockImplementation(() => {
-    return {
-      transaction: jest.fn(() => transaction),
-    }
-  })() as any as Kysely<DB>
-
-  return {
-    transaction,
-    writer,
-    underTest: await KyselyTransactionImpl.newTransaction(writer, database),
-  }
-}
-
-describe('KyselyTransaction', () => {
-  test('Transaction starts opened', async () => {
-    const { transaction, underTest } = await testResources({})
-    expect(underTest.isOpen()).toBe(true)
-    expect(transaction['execute']).toHaveBeenCalledTimes(1)
-
-    await expect(underTest.begin).rejects.toThrowError(
-      'Cannot begin, transaction is already opened!'
-    )
-  })
-
-  test('Can only commit once', async () => {
-    const { underTest } = await testResources({})
-    await underTest.commit()
-    expect(underTest.isOpen()).toBe(false)
-
-    await expect(underTest.commit).rejects.toThrowError(
-      'Cannot commit, transaction is already closed!'
-    )
-  })
-
-  test('Can only rollback once', async () => {
-    const { underTest } = await testResources({})
-    await underTest.rollback()
-    expect(underTest.isOpen()).toBe(false)
-    await expect(underTest.rollback).rejects.toThrowError(
-      'Cannot rollback, transaction is already closed!'
-    )
-  })
-
-  test("Can't open transaction twice", async () => {
-    const { underTest } = await testResources({})
-    expect(underTest.isOpen()).toBe(true)
-
-    await expect(underTest.begin).rejects.toThrowError(
-      'Cannot begin, transaction is already opened!'
-    )
-  })
-
-  test('Can commit, begin and commit again ', async () => {
-    const { underTest } = await testResources({})
-    await underTest.commit()
-    expect(underTest.isOpen()).toBe(false)
-    await underTest.begin()
-    expect(underTest.isOpen()).toBe(true)
-    await underTest.commit()
-    expect(underTest.isOpen()).toBe(false)
-  })
-
-  test('Can commit, begin and rollback ', async () => {
-    const { underTest } = await testResources({})
-    await underTest.commit()
-    expect(underTest.isOpen()).toBe(false)
-    await underTest.begin()
-    expect(underTest.isOpen()).toBe(true)
-    await underTest.rollback()
-    expect(underTest.isOpen()).toBe(false)
-  })
-
-  test('Can rollback, begin and commit ', async () => {
-    const { underTest } = await testResources({})
-    await underTest.rollback()
-    expect(underTest.isOpen()).toBe(false)
-    await underTest.begin()
-    expect(underTest.isOpen()).toBe(true)
-    await underTest.commit()
-    expect(underTest.isOpen()).toBe(false)
-  })
-})

package/tests/Database/integrations/pg/PostgresDatabase.test.ts

@@ -1,76 +0,0 @@
-import { jest } from '@jest/globals'
-import * as pg from 'pg'
-
-import type { DbConfig } from '../../../../src/Database'
-import { PostgresDatabase } from '../../../../src/Database/integrations/pgsql/PostgresDatabase'
-
-const config: DbConfig<'pg'> = {
-  type: 'pg',
-  username: 'username',
-  password: 'password',
-  host: 'host',
-  port: 1234,
-  database: 'database',
-  maxConnections: 1,
-  autoCommit: true,
-}
-
-const config2: DbConfig<'pg'> = {
-  ...config,
-  readReplica: config,
-}
-
-const expectedImplConfig = {
-  host: config.host,
-  port: config.port,
-  user: config.username,
-  password: config.password,
-  database: config.database,
-  max: config.maxConnections,
-}
-
-describe('PostgresDatabase', () => {
-  let mockTrans
-  let mockClient
-  beforeEach(() => {
-    mockTrans = {
-      query: jest.fn(() => {}),
-    } as any
-    mockClient = jest.fn(
-      () =>
-        ({
-          connect: async () => mockTrans,
-        }) as pg.PoolClient
-    )
-    PostgresDatabase['pgProvider'] = mockClient as any
-  })
-
-  test('PostgresDatabase', async () => {
-    const underTest = new PostgresDatabase(config)
-    expect(mockClient).toHaveBeenNthCalledWith(1, expectedImplConfig)
-
-    const trans = await underTest.transaction()
-
-    expect(mockTrans.query).toBeCalledWith('BEGIN')
-    expect(trans.reader).toBeUndefined()
-    expect(trans.writer).toBeInstanceOf(Object)
-    expect(trans.writer.connect).toBeInstanceOf(Function)
-    expect(trans).toBeInstanceOf(Function)
-    expect(trans['transaction']).toBe(mockTrans)
-  })
-
-  test('PostgresDatabase - read replica', async () => {
-    const underTest = new PostgresDatabase(config2)
-    expect(mockClient).toHaveBeenNthCalledWith(2, expectedImplConfig)
-
-    const trans = await underTest.transaction()
-
-    expect(mockTrans.query).toBeCalledWith('BEGIN')
-    expect(trans.reader).toBeInstanceOf(Object)
-    expect(trans.reader.connect).toBeInstanceOf(Function)
-    expect(trans.writer).toBeInstanceOf(Object)
-    expect(trans.writer.connect).toBeInstanceOf(Function)
-    expect(trans).toBeInstanceOf(Function)
-    expect(trans['transaction']).toBe(mockTrans)
-  })
-})

package/tests/Database/integrations/pg/PostgresTransaction.test.ts

@@ -1,118 +0,0 @@
-import { jest } from '@jest/globals'
-import * as pg from 'pg'
-
-import type { DbConfig } from '../../../../src/Database'
-import { PostgresDatabase } from '../../../../src/Database/integrations/pgsql/PostgresDatabase'
-import { PostgresTransactionImpl } from '../../../../src/Database/integrations/pgsql/PostgresTransaction'
-
-const testResources = async (config: Partial<DbConfig<'pg'>>) => {
-  const database = {
-    config: {
-      autoCommit: true,
-      ...config,
-    } as DbConfig<'pg'>,
-  } as PostgresDatabase
-
-  const transaction = jest.fn().mockImplementation(() => {
-    return {
-      commit: jest.fn(),
-      rollback: jest.fn(),
-      query: jest.fn(),
-    }
-  })() as any as pg.PoolClient
-
-  const writer = jest.fn().mockImplementation(() => {
-    return {
-      connect: jest.fn(() => transaction),
-    }
-  })() as any as pg.Pool
-
-  return {
-    transaction,
-    writer,
-    underTest: await PostgresTransactionImpl.newTransaction(writer, database),
-  }
-}
-
-describe('PostgresTransaction', () => {
-  test('Transaction starts opened', async () => {
-    const { transaction, underTest } = await testResources({})
-    expect(underTest.isOpen()).toBe(true)
-    expect(transaction.query).toHaveBeenNthCalledWith(1, 'BEGIN')
-
-    await expect(underTest.begin).rejects.toThrowError(
-      'Cannot begin, transaction is already opened!'
-    )
-  })
-
-  test('Can only commit once', async () => {
-    const { transaction, underTest } = await testResources({})
-    await underTest.commit()
-    expect(underTest.isOpen()).toBe(false)
-    expect(transaction.query).toBeCalledWith('COMMIT')
-
-    await expect(underTest.commit).rejects.toThrowError(
-      'Cannot commit, transaction is already closed!'
-    )
-  })
-
-  test('Can only rollback once', async () => {
-    const { transaction, underTest } = await testResources({})
-    await underTest.rollback()
-    expect(underTest.isOpen()).toBe(false)
-    expect(transaction.query).toBeCalledWith('ROLLBACK')
-
-    await expect(underTest.rollback).rejects.toThrowError(
-      'Cannot rollback, transaction is already closed!'
-    )
-  })
-
-  test("Can't open transaction twice", async () => {
-    const { transaction, underTest } = await testResources({})
-    expect(underTest.isOpen()).toBe(true)
-    expect(transaction.query).toHaveBeenNthCalledWith(1, 'BEGIN')
-
-    await expect(underTest.begin).rejects.toThrowError(
-      'Cannot begin, transaction is already opened!'
-    )
-  })
-
-  test('Can commit, begin and commit again ', async () => {
-    const { transaction, underTest } = await testResources({})
-    await underTest.commit()
-    expect(underTest.isOpen()).toBe(false)
-    expect(transaction.query).toBeCalledWith('COMMIT')
-    await underTest.begin()
-    expect(underTest.isOpen()).toBe(true)
-    expect(transaction.query).toHaveBeenNthCalledWith(3, 'BEGIN')
-    await underTest.commit()
-    expect(underTest.isOpen()).toBe(false)
-    expect(transaction.query).toHaveBeenNthCalledWith(4, 'COMMIT')
-  })
-
-  test('Can commit, begin and rollback ', async () => {
-    const { transaction, underTest } = await testResources({})
-    await underTest.commit()
-    expect(underTest.isOpen()).toBe(false)
-    expect(transaction.query).toBeCalledWith('COMMIT')
-    await underTest.begin()
-    expect(underTest.isOpen()).toBe(true)
-    expect(transaction.query).toHaveBeenNthCalledWith(3, 'BEGIN')
-    await underTest.rollback()
-    expect(underTest.isOpen()).toBe(false)
-    expect(transaction.query).toHaveBeenNthCalledWith(4, 'ROLLBACK')
-  })
-
-  test('Can rollback, begin and commit ', async () => {
-    const { transaction, underTest } = await testResources({})
-    await underTest.rollback()
-    expect(underTest.isOpen()).toBe(false)
-    expect(transaction.query).toBeCalledWith('ROLLBACK')
-    await underTest.begin()
-    expect(underTest.isOpen()).toBe(true)
-    expect(transaction.query).toHaveBeenNthCalledWith(3, 'BEGIN')
-    await underTest.commit()
-    expect(underTest.isOpen()).toBe(false)
-    expect(transaction.query).toHaveBeenNthCalledWith(4, 'COMMIT')
-  })
-})

package/tests/Logger/Logger.test.ts

@@ -1,219 +0,0 @@
-import { jest } from '@jest/globals'
-import { expect as c_expect } from 'chai'
-
-// get console ref and mock before logger import
-const consoleProxy = console
-const mock = jest.spyOn(consoleProxy, 'log')
-// import logger after first ref
-import Logger from '../../src/Logger/Logger'
-// get console reference after logger import
-const transactionID = '123-456'
-
-function setContainerFlag(isContainer: boolean) {
-  if (isContainer) {
-    process.env['HYBRIDLESS_RUNTIME'] = 'true'
-  } else {
-    process.env['HYBRIDLESS_RUNTIME'] = undefined
-  }
-}
-
-function fixLogTypePrefix(logType: string) {
-  if (logType == 'exception') return 'error'
-  if (logType == 'warning') return 'warn'
-  if (logType == 'log') return 'info'
-  return logType
-}
-
-function randomDeepObject(count, endKey) {
-  if (count <= 1) return { [endKey]: 'value' }
-  const object = {}
-  for (let i = 0; i < count; i++) {
-    const key = (+new Date() * Math.random()).toString(36).substring(0, 6)
-    object[key] = randomDeepObject(Math.floor(Math.random() * (count / 2)), endKey)
-  }
-  return object
-}
-
-function testLogs(isContainer: boolean, provider?: 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('my password is 123')
-    expect(consoleProxy.log).toHaveBeenNthCalledWith(
-      1,
-      expect.stringContaining((isContainer ? `${transactionID} ` : '') + '[INFO] [Logger.test.ts:')
-    )
-    expect(consoleProxy.log).toHaveBeenNthCalledWith(
-      1,
-      expect.stringContaining('] my password is 123')
-    )
-  })
-
-  test(`${type} - ${loggerType} Log - Suppress sensitive info (object)`, async () => {
-    setContainerFlag(isContainer)
-    const object = { password: '123' }
-    localProvider.log('TEST', object)
-    expect(consoleProxy.log).toHaveBeenNthCalledWith(
-      1,
-      expect.stringContaining((isContainer ? `${transactionID} ` : '') + '[INFO] [Logger.test.ts:')
-    )
-    expect(consoleProxy.log).toHaveBeenNthCalledWith(
-      1,
-      expect.stringContaining('] TEST {\n  "password": "**SUPPRESSED_SENSITIVE_DATA** (3 len)"\n}')
-    )
-    // test if object is not mutate
-    c_expect(object.password).to.be.equals('123')
-  })
-
-  test(`${type} - ${loggerType} Log - Suppress sensitive info (long-object)`, async () => {
-    setContainerFlag(isContainer)
-    const object = randomDeepObject(99, 'password')
-    localProvider.log('TEST', object)
-    expect(consoleProxy.log).toHaveBeenNthCalledWith(
-      1,
-      expect.stringContaining((isContainer ? `${transactionID} ` : '') + '[INFO] [Logger.test.ts:')
-    )
-    expect(consoleProxy.log).toHaveBeenNthCalledWith(1, expect.stringContaining('] TEST'))
-    expect(consoleProxy.log).toHaveBeenNthCalledWith(
-      1,
-      expect.stringContaining('"password": "**SUPPRESSED_SENSITIVE_DATA** (5 len)"')
-    )
-  })
-
-  test(`${type} - ${loggerType} Log - Suppress sensitive info (object with sensitive string)`, async () => {
-    setContainerFlag(isContainer)
-    localProvider.log({ object: JSON.stringify({ password: '123' }) })
-    expect(consoleProxy.log).toHaveBeenNthCalledWith(
-      1,
-      expect.stringContaining((isContainer ? `${transactionID} ` : '') + '[INFO] [Logger.test.ts:')
-    )
-    expect(consoleProxy.log).toHaveBeenNthCalledWith(
-      1,
-      expect.stringContaining(
-        '] {\n  "object": {\n    "password": "**SUPPRESSED_SENSITIVE_DATA** (3 len)"\n  }\n}'
-      )
-    )
-  })
-
-  test(`${type} - ${loggerType} Log - Suppress sensitive info (object with sensitive number)`, async () => {
-    setContainerFlag(isContainer)
-    localProvider.log({ object: JSON.stringify({ password: 123 }) })
-    expect(consoleProxy.log).toHaveBeenNthCalledWith(
-      1,
-      expect.stringContaining((isContainer ? `${transactionID} ` : '') + '[INFO] [Logger.test.ts:')
-    )
-    expect(consoleProxy.log).toHaveBeenNthCalledWith(
-      1,
-      expect.stringContaining(
-        '] {\n  "object": {\n    "password": "**SUPPRESSED_SENSITIVE_DATA** (3 len)"\n  }\n}'
-      )
-    )
-  })
-
-  test(`${type} - ${loggerType} Log - Suppress sensitive info (null key)`, async () => {
-    setContainerFlag(isContainer)
-    localProvider.log({ object: JSON.stringify({ password: null }) })
-    expect(consoleProxy.log).toHaveBeenNthCalledWith(
-      1,
-      expect.stringContaining((isContainer ? `${transactionID} ` : '') + '[INFO] [Logger.test.ts:')
-    )
-    expect(consoleProxy.log).toHaveBeenNthCalledWith(
-      1,
-      expect.stringContaining('] {\n  "object": {\n    "password": null\n  }\n}')
-    )
-  })
-
-  test(`${type} - ${loggerType} Log - Suppress sensitive info (null)`, async () => {
-    setContainerFlag(isContainer)
-    localProvider.log(null)
-    expect(consoleProxy.log).toHaveBeenNthCalledWith(
-      1,
-      expect.stringContaining((isContainer ? `${transactionID} ` : '') + '[INFO] [Logger.test.ts:')
-    )
-    expect(consoleProxy.log).toHaveBeenNthCalledWith(1, expect.stringContaining('] '))
-  })
-
-  test(`${type} - ${loggerType} Log - Suppress sensitive info (array)`, async () => {
-    setContainerFlag(isContainer)
-    localProvider.log('TEST2', [{ password: '1234' }])
-    expect(consoleProxy.log).toHaveBeenNthCalledWith(
-      1,
-      expect.stringContaining((isContainer ? `${transactionID} ` : '') + '[INFO] [Logger.test.ts:')
-    )
-    expect(consoleProxy.log).toHaveBeenNthCalledWith(
-      1,
-      expect.stringContaining(
-        '] TEST2 [\n  {\n    "password": "**SUPPRESSED_SENSITIVE_DATA** (4 len)"\n  }\n]'
-      )
-    )
-  })
-
-  test(`${type} - ${loggerType} Log - Circular reference (Error)`, async () => {
-    setContainerFlag(isContainer)
-    class SelfRefError extends Error {
-      self: SelfRefError
-      constructor() {
-        super()
-        this.self = this
-      }
-    }
-    localProvider.log(new SelfRefError())
-    expect(consoleProxy.log).toHaveBeenNthCalledWith(
-      1,
-      expect.stringContaining((isContainer ? `${transactionID} ` : '') + '[INFO] [Logger.test.ts:')
-    )
-    expect(consoleProxy.log).toHaveBeenNthCalledWith(
-      1,
-      expect.stringContaining('[INFO] [Logger.test.ts:')
-    )
-    expect(consoleProxy.log).toHaveBeenNthCalledWith(
-      1,
-      expect.stringContaining('] {\n' + '  "self": "[Circular ~]"\n' + '}')
-    )
-  })
-
-  for (const logType of ['log', 'debug', 'info', 'warn', 'warning', 'error', 'exception']) {
-    test(`${type} - ${loggerType} ${logType}`, async () => {
-      setContainerFlag(isContainer)
-      localProvider[logType](logType.toUpperCase())
-      // alias
-      const logTypePrefix = fixLogTypePrefix(logType)
-      expect(consoleProxy.log).toHaveBeenNthCalledWith(
-        1,
-        expect.stringContaining(
-          (isContainer ? `${transactionID} ` : '') +
-            `[${logTypePrefix.toUpperCase()}] [Logger.test.ts:`
-        )
-      )
-      expect(consoleProxy.log).toHaveBeenNthCalledWith(
-        1,
-        expect.stringContaining(`] ${logType.toUpperCase()}`)
-      )
-    })
-  }
-}
-
-describe('Logger', () => {
-  beforeEach(() => {
-    mock.mockClear()
-  })
-  const provider = new Logger(
-    {
-      logLevel: 'DEBUG',
-      sensitiveFilteringKeywords: true,
-    },
-    transactionID
-  )
-  provider.notGlobalLogger()
-  // Test serverless logs
-  testLogs(false, provider)
-  testLogs(false)
-  // Test container logs
-  testLogs(true, provider)
-  testLogs(true)
-})
-
-export {}

package/tests/Mailer/Mailer.test.ts

@@ -1,59 +0,0 @@
-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

@@ -1,94 +0,0 @@
-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('SNS Pub-Sub', () => {
-  // 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.undefined
-  })
-})
-
-describe('SNS SMS', () => {
-  // reset mock
-  beforeEach(() => {
-    SNSMock.reset()
-  })
-
-  const provider = new Publisher({
-    region: 'ca-central-1',
-  })
-
-  test('Publishes with success', async () => {
-    const msg = 'hello world'
-    const phoneNumber = '+16042001234'
-    const messageId = 'id-123'
-    SNSMock.on(PublishCommand, {
-      Message: msg,
-      PhoneNumber: phoneNumber,
-    }).resolves({
-      MessageId: messageId,
-    })
-    const res = await provider.publishSMS(msg, phoneNumber)
-    expect(res).is.not.null
-    expect(res?.MessageId).to.be.equals(messageId)
-  })
-
-  test('Publish failure', async () => {
-    const msg = 'hello world'
-    const phoneNumber = '+16042001234'
-    SNSMock.on(PublishCommand).rejects(new Error('failed!'))
-    const res = await provider.publishSMS(msg, phoneNumber)
-    expect(res).is.undefined
-  })
-})
-
-export {}