@creator.co/wapi 1.2.4 → 1.2.5

package/src/Database/types.d.ts

@@ -0,0 +1,49 @@
+import { Database } from './Database'
+import { DATABASES } from './DatabaseManager'
+
+/**
+ * Represents the available types of databases.
+ * @typedef {keyof typeof DATABASES} DatabaseType
+ */
+export type DatabaseType = keyof typeof DATABASES
+
+/**
+ * Represents the instance type of the specified database implementation.
+ * @param {Type} Type - The type of the database implementation.
+ */
+export type DatabaseImplType<Type extends DatabaseType> = InstanceType<(typeof DATABASES)[Type]>
+
+/**
+ * Defines a type for a database transaction based on the specified database type.
+ * @param {Type} - The database type.
+ * @returns The transaction type associated with the specified database type.
+ */
+export type DatabaseTransactionType<Type extends DatabaseType> =
+  DatabaseImplType<Type> extends Database<infer TransactionType> ? TransactionType : never
+
+/**
+ * Represents the configuration for a database connection.
+ * @template S - The type of the database (e.g. "mysql", "postgres", etc.)
+ * @interface DbConfig
+ * @property {S} type - The type of the database.
+ * @property {string} driver - The driver to use for the database connection.
+ * @property {string} host - The host of the database server.
+ * @property {number} port - The port number of the database server.
+ * @property {string} username - The username for the database connection.
+ * @property {string} password - The password for the database connection.
+ * @property {string} database - The name of the database to connect to.
+ * @property {boolean} autoCommit - Whether or not to automatically commit transactions.
+ * @property {number} maxConnections - The maximum number of connections to the database.
+ * @returns The transaction type associated with the specified database type.
+ */
+export interface DbConfig<S extends DatabaseType> {
+  type: S
+  driver: string
+  host: string
+  port: number
+  username: string
+  password: string
+  database: string
+  autoCommit: boolean
+  maxConnections: number
+}

package/src/Server/lib/container/Proxy.ts

@@ -150,7 +150,8 @@ export default class Proxy {
     console.debug('[Proxy] - [STOPPING]')
     return new Promise(resolve => {
       this.listener.close(_err => {
-        if (err || _err) console.log('[Proxy] - exit output:', err || _err)
+        const err2 = err || _err
+        if (err2) console.log('[Proxy] - exit output:', err2)
         console.log('[Proxy] - [STOPPED]')
         process.exit(err || _err ? 1 : 0)
         resolve(null)

package/tests/BaseEvent/Transaction.test.ts

@@ -3,6 +3,7 @@ import { expect } from 'chai'
 
 import Response from '../../src/API/Response'
 import Transaction from '../../src/BaseEvent/Transaction'
+import type { DbConfig } from '../../src/Database/types'
 import Globals from '../../src/Globals'
 import { defaultHeaders, emptyEvent, observableContext } from '../Test.utils'
 
@@ -219,4 +220,62 @@ describe('Transaction error invocation path with exception', () => {
   })
 })
 
+describe('Transaction - db integration', () => {
+  const testResources = () => {
+    const mockTrans = {
+      select: jest.fn(),
+      closeSuccess: jest.fn(),
+      closeFailure: jest.fn(),
+    }
+    const mockCreate = jest.fn(
+      () => ({ transaction: () => new Promise(resolve => resolve(mockTrans)) }) as any
+    )
+
+    const transaction = new Transaction(emptyEvent(), observableContext())
+    transaction['databaseManager'] = {
+      create: mockCreate,
+    } as any
+
+    return {
+      transaction,
+      mockCreate,
+      mockTrans,
+    }
+  }
+
+  const config = { username: 'test' } as DbConfig<'knex'>
+
+  test('Transaction provides dbTransaction and calls closeSuccess', async () => {
+    const { mockCreate, mockTrans, transaction } = testResources()
+
+    await transaction.execute(async () => {
+      const knexTransaction = await transaction.getDbTransaction(config)
+
+      knexTransaction.select('name')
+
+      return Response.SuccessResponse(null)
+    })
+    j_expect(mockCreate).toBeCalledWith(config)
+    j_expect(mockTrans.select).toBeCalledWith('name')
+    j_expect(mockTrans.closeSuccess).toBeCalled()
+  })
+
+  test('Errored transaction calls closeFailure', async () => {
+    const { mockCreate, transaction, mockTrans } = testResources()
+
+    const ss = await transaction.execute(async () => {
+      const _ii = await transaction.getDbTransaction(config)
+      console.log('ii', _ii)
+      throw new Error('Something went wrong!')
+
+      return Response.SuccessResponse(null)
+    })
+
+    console.log(ss)
+
+    j_expect(mockCreate).toBeCalledWith(config)
+    j_expect(mockTrans.closeFailure).toBeCalled()
+  })
+})
+
 export {}

package/tests/Database/DatabaseManager.test.ts

@@ -0,0 +1,55 @@
+import { expect } from 'chai'
+
+import { DatabaseManager } from '../../src/Database/DatabaseManager'
+import type { DatabaseType, DbConfig } from '../../src/Database/types'
+
+type FakeDatabase = { host: string; type: 'knex' | 'pg' }
+
+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 => {
+        return { host: config.host, type: 'knex' } as any
+      }) as any,
+      pg: jest.fn(config => {
+        return { host: config.host, type: 'pg' } 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 knex1 = create(knexConfig1)
+    const knex2 = create(knexConfig1)
+    const knex3 = create(knexConfig2)
+
+    const pg1 = create(pgConfig1)
+    const pg2 = create(pgConfig1)
+    const pg3 = create(pgConfig2)
+
+    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)
+  })
+})

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

@@ -0,0 +1,53 @@
+import { Knex } from 'knex'
+
+import { KnexDatabase } from '../../../../src/Database/integrations/knex/KnexDatabase'
+import { KnexTransactionImpl } from '../../../../src/Database/integrations/knex/KnexTransaction'
+import type { DbConfig } from '../../../../src/Database/types'
+
+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(KnexTransactionImpl)
+    expect(trans['delegate']).toBe(mockTrans)
+  })
+})

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

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

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

@@ -0,0 +1,50 @@
+import { PoolClient } from 'pg'
+
+import { PostgresDatabase } from '../../../../src/Database/integrations/pgsql/PostgresDatabase'
+import { PostgresTransactionImpl } from '../../../../src/Database/integrations/pgsql/PostgresTransaction'
+import type { DbConfig } from '../../../../src/Database/types'
+
+const config: DbConfig<'pg'> = {
+  type: 'pg',
+  username: 'username',
+  password: 'password',
+  host: 'host',
+  port: 1234,
+  database: 'database',
+  driver: 'driver',
+  maxConnections: 1,
+  autoCommit: true,
+}
+
+const expectedImplConfig = {
+  host: config.host,
+  port: config.port,
+  user: config.username,
+  password: config.password,
+  database: config.database,
+  max: config.maxConnections,
+}
+
+describe('PostgresDatabase', () => {
+  test('PostgresDatabase', async () => {
+    const mockTrans = {
+      query: jest.fn(() => {}),
+    } as any
+    const mockClient = jest.fn(
+      () =>
+        ({
+          connect: async () => mockTrans,
+        }) as PoolClient
+    )
+    PostgresDatabase['pgProvider'] = mockClient as any
+
+    const underTest = new PostgresDatabase(config)
+    expect(mockClient).toBeCalledWith(expectedImplConfig)
+
+    const trans = await underTest.transaction()
+
+    expect(mockTrans.query).toBeCalledWith('BEGIN')
+    expect(trans).toBeInstanceOf(PostgresTransactionImpl)
+    expect(trans['delegate']).toBe(mockTrans)
+  })
+})

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

@@ -0,0 +1,51 @@
+import { PoolClient } from 'pg'
+
+import { PostgresDatabase } from '../../../../src/Database/integrations/pgsql/PostgresDatabase'
+import { PostgresTransactionImpl } from '../../../../src/Database/integrations/pgsql/PostgresTransaction'
+import type { DbConfig } from '../../../../src/Database/types'
+
+const testResources = (config: Partial<DbConfig<'pg'>>) => {
+  const database = {
+    config: {
+      autoCommit: true,
+      ...config,
+    } as DbConfig<'pg'>,
+  } as PostgresDatabase
+
+  const delegate = jest.fn().mockImplementation(() => {
+    return {
+      commit: jest.fn(),
+      rollback: jest.fn(),
+      query: jest.fn(),
+    }
+  })() as any as PoolClient
+
+  return {
+    delegate,
+    underTest: PostgresTransactionImpl.wrapDelegate(delegate, database),
+  }
+}
+
+describe('PostgresTransaction', () => {
+  test('Can only commit once', async () => {
+    const { delegate, underTest } = testResources({})
+    await underTest.commit()
+    expect(underTest.isOpen).toBe(false)
+    expect(delegate.query).toBeCalledWith('COMMIT')
+
+    await expect(underTest.commit).rejects.toThrowError(
+      'Cannot commit, transaction is already closed!'
+    )
+  })
+
+  test('Can only rollback once', async () => {
+    const { delegate, underTest } = testResources({})
+    await underTest.rollback()
+    expect(underTest.isOpen).toBe(false)
+    expect(delegate.query).toBeCalledWith('ROLLBACK')
+
+    await expect(underTest.rollback).rejects.toThrowError(
+      'Cannot rollback, transaction is already closed!'
+    )
+  })
+})

package/tsconfig.json

@@ -1,6 +1,11 @@
 {
   "exclude": ["**/*.test.*", "**/__mocks__/*", "**/__tests__/*", "**/tests/*"],
   "compilerOptions": {
+    "lib": [
+      "es5",
+      "es6",
+      "dom"
+    ],
     "noImplicitAny": false,
     "noEmitOnError": true,
     "removeComments": false,