@creator.co/wapi 1.7.1-alpha3 → 1.7.1

package/tests/Crypto/Crypto.test.ts

@@ -0,0 +1,88 @@
+import { DecryptCommand, EncryptCommand, KMSClient } from '@aws-sdk/client-kms'
+import { mockClient } from 'aws-sdk-client-mock'
+import { expect } from 'chai'
+
+import Crypto from '../../src/Crypto/Crypto'
+
+const KMSMock = mockClient(KMSClient)
+
+function fakeEncryption(v) {
+  const f = new TextEncoder().encode(v)
+  return Buffer.from(f as any, 'utf8').toString('hex')
+}
+function fakeDecryption(v) {
+  return new TextEncoder().encode(v)
+}
+
+describe('Encryption', () => {
+  // reset mock
+  beforeEach(() => {
+    KMSMock.reset()
+  })
+
+  const provider = new Crypto('ca-central-1', 'abc123')
+  test('Encrypts json object', async () => {
+    const encryptionObj = { userID: 123 }
+    KMSMock.on(EncryptCommand).resolves({
+      CiphertextBlob: new TextEncoder().encode(JSON.stringify(encryptionObj)),
+    })
+    const token = await provider.encryptData(encryptionObj)
+    expect(token).is.not.null
+    expect(token).to.be.equals(fakeEncryption(JSON.stringify(encryptionObj)))
+  })
+
+  test('Encrypts string', async () => {
+    const encryptionText = 'Hello encryption!'
+    KMSMock.on(EncryptCommand).resolves({
+      CiphertextBlob: new TextEncoder().encode(encryptionText),
+    })
+    const token = await provider.encryptData(encryptionText)
+    expect(token).is.not.null
+    expect(token).to.be.equals(fakeEncryption(encryptionText))
+  })
+
+  test('Fails to encrypt a number', async () => {
+    const encryptionText = 123
+    KMSMock.on(EncryptCommand).rejects(new Error('failed'))
+    const token = await provider.encryptData(encryptionText)
+    expect(token).is.null
+  })
+})
+
+describe('Decryption', () => {
+  // reset mock
+  beforeEach(() => {
+    KMSMock.reset()
+  })
+
+  const provider = new Crypto('ca-central-1', 'abc123')
+  test('Decrypts json object', async () => {
+    const encryptionObj = { userID: 123 }
+    KMSMock.on(DecryptCommand).resolves({
+      Plaintext: fakeDecryption(JSON.stringify(encryptionObj)),
+    })
+    const token = await provider.decryptData(fakeEncryption(JSON.stringify(encryptionObj)))
+    expect(token).is.not.null
+    expect(token).to.be.equals(JSON.stringify(encryptionObj))
+  })
+
+  test('Decrypts string', async () => {
+    const encryptionText = 'abc123'
+    KMSMock.on(DecryptCommand).resolves({
+      Plaintext: fakeDecryption(encryptionText),
+    })
+    const token = await provider.decryptData(fakeEncryption(encryptionText))
+    expect(token).is.not.null
+    expect(token).to.be.equals(encryptionText)
+  })
+
+  test('Fails to decrypt a number', async () => {
+    const encryptionText = 123
+    KMSMock.on(DecryptCommand).rejects(new Error('failed'))
+    // @ts-ignore
+    const token = await provider.decryptData(encryptionText)
+    expect(token).is.null
+  })
+})
+
+export {}

package/tests/Crypto/JWT.test.ts

@@ -0,0 +1,92 @@
+import { expect } from 'chai'
+
+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', () => {
+    const token = provider.createToken({ userID: 123 })
+    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')
+    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')
+    expect(token).is.not.null
+  })
+
+  test('Creates token with explicity token options', () => {
+    const token = provider.createToken({ userID: 123 }, undefined, undefined, {
+      expiresIn: '7d',
+    })
+    expect(token).to.be.a('string')
+    expect(token).is.not.null
+  })
+
+  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).is.not.null
+  })
+})
+
+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')
+    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)
+  })
+
+  test('Fails to validate invalid token', () => {
+    // Creates token
+    const token = provider.createToken({ userID: 123 }, '7d', privateKey)
+    // Validates token
+    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
+  })
+
+  test('Fails to validate expired token', () => {
+    // Creates token
+    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
+  })
+
+  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
+  })
+})
+
+export {}

package/tests/Database/DatabaseManager.test.ts

@@ -0,0 +1,71 @@
+import { jest } from '@jest/globals'
+import { expect } from 'chai'
+
+import { DatabaseManager } from '../../src/Database'
+import type { DatabaseType, DbConfig } from '../../src/Database/types'
+
+type FakeDatabase = { host: string; type: 'knex' | 'pg' | 'kysely' }
+
+const fakeConfig = (host: string, type: DatabaseType) => {
+  return {
+    type,
+    host,
+  } as DbConfig<typeof type>
+}
+
+describe('Database Manager', () => {
+  test('should correctly create and cache database instances', () => {
+    const underTest = new DatabaseManager()
+
+    underTest['databases'] = {
+      knex: jest.fn((config: any) => {
+        return { host: config.host, type: 'knex' } as any
+      }) as any,
+      pg: jest.fn((config: any) => {
+        return { host: config.host, type: 'pg' } as any
+      }) as any,
+      kysely: jest.fn((config: any) => {
+        return { host: config.host, type: 'kysely' } as any
+      }) as any,
+    }
+
+    const create = config => underTest.create({ ...config }) as unknown as FakeDatabase
+
+    const knexConfig1 = fakeConfig('localhost', 'knex')
+    const knexConfig2 = fakeConfig('other', 'knex')
+    const pgConfig1 = fakeConfig('localhost', 'pg')
+    const pgConfig2 = fakeConfig('other', 'pg')
+    const kyselyConfig1 = fakeConfig('localhost', 'pg')
+    const kyselyConfig2 = fakeConfig('other', 'pg')
+
+    const knex1 = create(knexConfig1)
+    const knex2 = create(knexConfig1)
+    const knex3 = create(knexConfig2)
+
+    const pg1 = create(pgConfig1)
+    const pg2 = create(pgConfig1)
+    const pg3 = create(pgConfig2)
+
+    const kysely1 = create(kyselyConfig1)
+    const kysely2 = create(kyselyConfig1)
+    const kysely3 = create(kyselyConfig2)
+
+    expect(knex1).to.equal(knex2).to.not.equal(knex3).to.not.equal(pg1)
+
+    expect(knexConfig1).to.be.deep.equal(knex1).to.be.deep.equal(knex2)
+
+    expect(knex3).to.be.deep.equal(knexConfig2)
+
+    expect(pg1).to.equal(pg2).to.not.equal(pg3)
+
+    expect(pgConfig1).to.be.deep.equal(pg1).to.be.deep.equal(pg2)
+
+    expect(pg3).to.be.deep.equal(pgConfig2)
+
+    expect(kysely1).to.equal(kysely2).to.not.equal(kysely3)
+
+    expect(kyselyConfig1).to.be.deep.equal(kysely1).to.be.deep.equal(kysely2)
+
+    expect(kysely3).to.be.deep.equal(kyselyConfig2)
+  })
+})

package/tests/Database/integrations/knex/KnexDatabase.test.ts

@@ -0,0 +1,76 @@
+import { jest } from '@jest/globals'
+import { Knex } from 'knex'
+
+import type { DbConfig } from '../../../../src/Database'
+import { KnexDatabase } from '../../../../src/Database/integrations/knex/KnexDatabase'
+
+const config: DbConfig<'knex'> = {
+  type: 'knex',
+  username: 'username',
+  password: 'password',
+  host: 'host',
+  port: 1234,
+  database: 'database',
+  driver: 'driver',
+  maxConnections: 1,
+  autoCommit: true,
+}
+
+const expectedImplConfig = {
+  client: config.driver,
+  connection: {
+    host: config.host,
+    port: config.port,
+    user: config.username,
+    password: config.password,
+    database: config.database,
+  },
+  pool: {
+    min: 1,
+    max: config.maxConnections,
+  },
+}
+
+describe('KnexDatabase', () => {
+  test('KnexDatabase', async () => {
+    const mockTrans = { a: 'b' } as any
+    const mockClient = jest.fn(
+      () =>
+        ({
+          transaction: async () => mockTrans,
+        }) as Knex
+    )
+    KnexDatabase['knexProvider'] = mockClient
+
+    const underTest = new KnexDatabase(config)
+    expect(mockClient).toBeCalledWith(expectedImplConfig)
+
+    const trans = await underTest.transaction()
+
+    expect(trans).toBeInstanceOf(Function)
+    expect(trans.transaction).toBe(mockTrans)
+  })
+
+  test('KnexDatabase - convert camel to snake', async () => {
+    const mockTrans = { a: 'b' } as any
+    const mockClient = jest.fn(
+      () =>
+        ({
+          transaction: async () => mockTrans,
+        }) as Knex
+    )
+    KnexDatabase['knexProvider'] = mockClient
+
+    const underTest = new KnexDatabase({ ...config, convertCamelToSnake: true })
+    expect(mockClient).toBeCalledWith({
+      ...expectedImplConfig,
+      postProcessResponse: expect.any(Function),
+      wrapIdentifier: expect.any(Function),
+    })
+
+    const trans = await underTest.transaction()
+
+    expect(trans).toBeInstanceOf(Function)
+    expect(trans.transaction).toBe(mockTrans)
+  })
+})

package/tests/Database/integrations/knex/KnexTransaction.test.ts

@@ -0,0 +1,149 @@
+import { jest } from '@jest/globals'
+import { Knex } from 'knex'
+
+import { DbConfig } from '../../../../src/Database'
+import { KnexDatabase } from '../../../../src/Database/integrations/knex/KnexDatabase'
+import { KnexTransactionImpl } from '../../../../src/Database/integrations/knex/KnexTransaction'
+
+const testResources = async (config: Partial<DbConfig<'knex'>>) => {
+  const database = {
+    config: {
+      autoCommit: true,
+      ...config,
+    } as DbConfig<'knex'>,
+  } as KnexDatabase
+
+  const txMock = jest.fn() as any
+  txMock.commit = jest.fn()
+  txMock.rollback = jest.fn()
+  txMock.select = jest.fn()
+
+  const wMock = jest.fn() as any
+  wMock.transaction = jest.fn(() => txMock)
+
+  const writer = wMock as Knex
+  const transaction = txMock as Knex.Transaction
+
+  return {
+    transaction,
+    writer,
+    underTest: await KnexTransactionImpl.newTransaction(writer, database),
+  }
+}
+
+describe('KnexTransaction', () => {
+  test('Can only commit once', async () => {
+    const { writer, transaction, underTest } = await testResources({})
+    await underTest.commit()
+    expect(underTest.isOpen()).toBe(false)
+    expect(writer.transaction).toBeCalled()
+    expect(transaction.commit).toBeCalled()
+
+    await expect(underTest.commit).rejects.toThrowError(
+      'Cannot commit, transaction is already closed!'
+    )
+  })
+
+  test("Can't commit after rollback", async () => {
+    const { writer, transaction, underTest } = await testResources({})
+    await underTest.rollback()
+    expect(underTest.isOpen()).toBe(false)
+    expect(writer.transaction).toBeCalled()
+    expect(transaction.rollback).toBeCalled()
+
+    await expect(underTest.commit).rejects.toThrowError(
+      'Cannot commit, transaction is already closed!'
+    )
+  })
+
+  test('Forwards calls to transaction', async () => {
+    const { transaction, underTest } = await testResources({})
+    await underTest.select('name')
+    expect(transaction.select).toBeCalledWith('name')
+  })
+
+  test('Blocks transaction calls after commit', async () => {
+    const { transaction, underTest } = await testResources({})
+    expect(underTest.select).toBeDefined()
+
+    await underTest.commit()
+    expect(transaction.commit).toBeCalled()
+    expect(underTest.isOpen()).toBe(false)
+
+    expect(underTest.select).toBeUndefined()
+  })
+})
+
+describe('KnexTransaction - closeSuccess', () => {
+  test('Close success commits', async () => {
+    const { transaction, underTest } = await testResources({})
+    await underTest.closeSuccess()
+    expect(transaction.commit).toBeCalled()
+  })
+
+  test("Close success, doesn't commit again if already committed", async () => {
+    const { transaction, underTest } = await testResources({})
+    await underTest.commit()
+    expect(transaction.commit).toBeCalledTimes(1)
+    await underTest.closeSuccess()
+    expect(transaction.commit).toBeCalledTimes(1)
+  })
+
+  test('Close success, rolls back if not autocommit', async () => {
+    const { transaction, underTest } = await testResources({ autoCommit: false })
+    await underTest.closeSuccess()
+    expect(transaction.rollback).toBeCalled()
+  })
+
+  test("Close success, doesn't rollback if already committed", async () => {
+    const { transaction, underTest } = await testResources({ autoCommit: false })
+    await underTest.commit()
+    expect(transaction.commit).toBeCalledTimes(1)
+    await underTest.closeSuccess()
+    expect(transaction.rollback).not.toBeCalled()
+    expect(transaction.commit).toBeCalledTimes(1)
+  })
+
+  test("Close success, doesn't rollback if already rolled back", async () => {
+    const { transaction, underTest } = await testResources({ autoCommit: false })
+    await underTest.rollback()
+    expect(transaction.rollback).toBeCalledTimes(1)
+    await underTest.closeSuccess()
+    expect(transaction.rollback).toBeCalledTimes(1)
+    expect(transaction.commit).not.toBeCalled()
+  })
+})
+
+describe('KnexTransaction - closeFailure', () => {
+  test('Close failure rolls back', async () => {
+    const { transaction, underTest } = await testResources({})
+    await underTest.closeFailure()
+    expect(transaction.rollback).toBeCalled()
+  })
+
+  test("Close failure, doesn't rollback again if already rolled back", async () => {
+    const { transaction, underTest } = await testResources({})
+    await underTest.rollback()
+    expect(transaction.rollback).toBeCalledTimes(1)
+    await underTest.closeFailure()
+    expect(transaction.rollback).toBeCalledTimes(1)
+  })
+
+  test("Close failure, doesn't rollback if already committed", async () => {
+    const { transaction, underTest } = await testResources({ autoCommit: false })
+    await underTest.commit()
+    expect(transaction.commit).toBeCalledTimes(1)
+    await underTest.closeFailure()
+    expect(transaction.rollback).not.toBeCalled()
+    expect(transaction.commit).toBeCalledTimes(1)
+  })
+})
+
+describe('KnexTransaction - call direct', () => {
+  test('Calls transaction', async () => {
+    const { transaction, underTest } = await testResources({ autoCommit: false })
+
+    underTest('test')
+    expect(transaction).toBeCalledWith('test')
+  })
+})

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

@@ -0,0 +1,113 @@
+import { jest } from '@jest/globals'
+import { PostgresDialect } from 'kysely'
+import * as pg from 'pg'
+
+import type { DbConfig } from '../../../../src/Database'
+import { KyselyDatabase } from '../../../../src/Database/integrations/kysely/KyselyDatabase'
+
+const config: DbConfig<'kysely'> = {
+  type: 'kysely',
+  username: 'username',
+  password: 'password',
+  host: 'host',
+  port: 1234,
+  database: 'database',
+  maxConnections: 1,
+  autoCommit: true,
+}
+
+const config2: DbConfig<'kysely'> = {
+  ...config,
+  readReplica: config,
+}
+
+const expectedImplConfig = {
+  host: config.host,
+  port: config.port,
+  user: config.username,
+  password: config.password,
+  database: config.database,
+  max: config.maxConnections,
+}
+
+describe('KyselyDatabase', () => {
+  let mockTrans
+  let mockClient
+  let mockDriver
+  let mockDialect
+  let mockPgTrans
+  let mockPgClient
+  beforeEach(() => {
+    mockTrans = {
+      execute: jest.fn(async (cb: any) => {
+        cb(mockTrans)
+      }),
+    } as any
+    mockClient = jest.fn(
+      () =>
+        ({
+          transaction: () => mockTrans,
+        }) as any as PostgresDialect
+    )
+    KyselyDatabase['kyselyProvider'] = mockClient as any
+
+    mockDriver = {
+      execute: jest.fn(async () => {}),
+    } as any
+    mockDialect = jest.fn(
+      () =>
+        ({
+          createDriver: () => mockDriver,
+        }) as any as PostgresDialect
+    )
+    KyselyDatabase['kyselyPgProvider'] = mockDialect as any
+
+    mockPgTrans = {
+      query: jest.fn(() => {}),
+    } as any
+    mockPgClient = jest.fn(
+      () =>
+        ({
+          connect: async () => mockPgTrans,
+        }) as pg.PoolClient
+    )
+    KyselyDatabase['pgProvider'] = mockPgClient as any
+  })
+
+  test('KyselyDatabase', async () => {
+    const underTest = new KyselyDatabase(config)
+    expect(mockPgClient).toHaveBeenNthCalledWith(1, expectedImplConfig)
+    expect(mockDialect).toHaveBeenCalledTimes(1)
+    expect(mockClient).toHaveBeenCalledTimes(1)
+    expect(mockClient.mock.calls[0][0].dialect).toEqual(underTest['pgClient'])
+    expect(mockClient.mock.calls[0][0].plugins).toBeInstanceOf(Array)
+    const trans = await underTest.transaction()
+
+    expect(mockTrans.execute).toHaveBeenCalledTimes(1)
+    expect(trans.reader).toBeUndefined()
+    expect(trans.writer).toBeInstanceOf(Object)
+    expect(trans.writer.transaction).toBeInstanceOf(Function)
+    expect(trans).toBeInstanceOf(Function)
+    expect(trans['transaction']).toBe(mockTrans)
+  })
+
+  test('KyselyDatabase -  read replica', async () => {
+    const underTest = new KyselyDatabase(config2)
+    expect(mockPgClient).toHaveBeenNthCalledWith(2, expectedImplConfig)
+    expect(mockDialect).toHaveBeenCalledTimes(2)
+    expect(mockClient).toHaveBeenCalledTimes(2)
+    expect(mockClient.mock.calls[0][0].dialect).toEqual(underTest['pgClient'])
+    expect(mockClient.mock.calls[0][0].plugins).toBeInstanceOf(Array)
+    expect(mockClient.mock.calls[1][0].dialect).toEqual(underTest['pgReadClient'])
+    expect(mockClient.mock.calls[1][0].plugins).toBeInstanceOf(Array)
+
+    const trans = await underTest.transaction()
+
+    expect(mockTrans.execute).toHaveBeenCalledTimes(1)
+    expect(trans.writer).toBeInstanceOf(Object)
+    expect(trans.writer.transaction).toBeInstanceOf(Function)
+    expect(trans.reader).toBeInstanceOf(Object)
+    expect(trans).toBeInstanceOf(Function)
+    expect(trans['transaction']).toBe(mockTrans)
+  })
+})