@creator.co/wapi 1.2.3 → 1.2.5

package/src/Database/Database.ts

@@ -0,0 +1,19 @@
+import { DatabaseTransaction } from './DatabaseTransaction'
+import type { DbConfig } from './types'
+
+/**
+ * Abstract class representing a database.
+ * @template T - The type of database transaction.
+ */
+export abstract class Database<T extends DatabaseTransaction> {
+  /**
+   * Creates a database instance, maintaining a reference to the database configuration.
+   */
+  protected constructor(public readonly config: DbConfig<any>) {}
+
+  /**
+   * Returns a promise resolving to a new instance of the transaction impl.
+   * @returns A promise that resolves to a transaction instance.
+   */
+  public abstract transaction(): Promise<T>
+}

package/src/Database/DatabaseManager.ts

@@ -0,0 +1,51 @@
+import * as hash from 'object-hash'
+
+import { KnexDatabase } from './integrations/knex/KnexDatabase'
+import { PostgresDatabase } from './integrations/pgsql/PostgresDatabase'
+import type { DatabaseImplType, DatabaseType, DbConfig } from './types'
+
+/**
+ * An object that maps database names to their corresponding database classes.
+ * @type {Object}
+ * @property {KnexDatabase} knex - The Knex database class.
+ * @property {PostgresDatabase} pg - The Postgres database class.
+ */
+export const DATABASES = {
+  knex: KnexDatabase,
+  pg: PostgresDatabase,
+}
+
+/**
+ * A class that manages databases and provides methods for creating and accessing database instances.
+ */
+export class DatabaseManager {
+  /**
+   * The singleton instance of the DatabaseManager class.
+   */
+  public static readonly INSTANCE = new DatabaseManager()
+  private databases: typeof DATABASES = DATABASES
+
+  private instances: { [k: string]: DatabaseImplType<any> } = {}
+
+  /**
+   * Creates a new instance of a database based on the provided configuration.
+   * @param {DbConfig<S>} config - The configuration object for the database.
+   * @returns {DatabaseImplType<S>} - The created database instance.
+   * @template S - The type of the database.
+   */
+  public create<S extends DatabaseType>(config: DbConfig<S>): DatabaseImplType<S> {
+    const configHash = hash(config)
+    if (this.instances[configHash]) {
+      return this.instances[configHash] as any
+    }
+    const instance = this.instantiateDb(config as any)
+    this.instances[configHash] = instance
+    return instance as any
+  }
+
+  private instantiateDb(
+    config: DbConfig<'knex'> | DbConfig<'pg'>
+  ): KnexDatabase | PostgresDatabase {
+    return new this.databases[config.type](config as any)
+  }
+}

package/src/Database/DatabaseTransaction.ts

@@ -0,0 +1,118 @@
+import { Database } from './Database'
+
+/**
+ * Abstract class representing a database transaction.
+ * @class DatabaseTransaction
+ */
+export abstract class DatabaseTransaction {
+  private _isOpen: boolean = true
+  protected delegate: any
+  protected database: Database<any>
+
+  /**
+   * Returns a boolean value indicating whether the transaction is open or not.
+   * @returns {boolean} - true if the object is open, false otherwise.
+   */
+  public get isOpen(): boolean {
+    return this._isOpen
+  }
+
+  /**
+   * Constructs a new instance of the class.
+   * @param {any} delegate - The delegate object.
+   * @param {Database<any>} database - The database object.
+   * @protected
+   */
+  protected constructor(delegate: any, database: Database<any>) {
+    this.delegate = delegate
+    this.database = database
+  }
+
+  /**
+   * Wraps an instance of a subclass of DatabaseTransaction with a Proxy object.
+   * The Proxy object intercepts method calls and delegates to the target instance.
+   * If the method is on the target instance, it is called directly.
+   * If the method is not on the target instance and the transaction is open, it is called on the target's delegate implementation.
+   * If the method is not on the target instance and the transaction is closed, an error is thrown.
+   * @param {T} subclass - The subclass instance to wrap with a Proxy.
+   * @returns {T} - The wrapped subclass instance.
+   * @throws {Error} - If the target instance is closed.
+   */
+  protected static wrapInstance<T extends DatabaseTransaction>(subclass: T): T {
+    const bind = (target: any, key: string | symbol) =>
+      typeof target[key] === 'function' ? target[key].bind(target) : target[key]
+
+    return new Proxy<T>(subclass, {
+      get(target: T, p: string | symbol): any {
+        if (target[p] !== undefined) {
+          return bind(target, p)
+        } else if (target._isOpen) {
+          return bind(target.delegate, p)
+        }
+        return undefined
+      },
+    })
+  }
+
+  /**
+   * Commits the transaction.
+   * @throws {Error} - If the transaction is already closed.
+   * @returns None
+   */
+  public async commit(): Promise<void> {
+    if (!this._isOpen) {
+      throw new Error('Cannot commit, transaction is already closed!')
+    }
+    await this.doCommit()
+    this._isOpen = false
+  }
+
+  /**
+   * Rollbacks the current transaction.
+   * @throws {Error} - If the transaction is already closed.
+   * @returns {Promise<void>} - A promise that resolves once the rollback is complete.
+   */
+  public async rollback(): Promise<void> {
+    if (!this._isOpen) {
+      throw new Error('Cannot rollback, transaction is already closed!')
+    }
+    await this.doRollback()
+    this._isOpen = false
+  }
+
+  /**
+   * Closes the transaction after a successful execution.
+   * @returns {Promise<void>} - A promise that resolves once the necessary actions are completed.
+   */
+  public async closeSuccess() {
+    if (this._isOpen) {
+      if (this.database.config.autoCommit) {
+        await this.doCommit()
+      } else {
+        await this.doRollback()
+      }
+    }
+  }
+
+  /**
+   * Closes the transaction after a failed execution.
+   * @returns {Promise<void>} - A promise that resolves once the necessary actions are completed.
+   */
+  public async closeFailure() {
+    if (this._isOpen) {
+      await this.doRollback()
+    }
+  }
+
+  /**
+   * An abstract method that performs the commit operation.
+   * @returns {Promise<any>} A promise that resolves when the commit operation is completed.
+   */
+  protected abstract doCommit(): Promise<any>
+
+  /**
+   * An abstract method that performs a rollback operation.
+   * @returns A Promise that resolves when the rollback operation is complete.
+   */
+  protected abstract doRollback(): Promise<any>
+}

package/src/Database/integrations/knex/KnexDatabase.ts

@@ -0,0 +1,47 @@
+import knex, { Knex } from 'knex'
+
+import { KnexTransaction, KnexTransactionImpl } from './KnexTransaction'
+import { Database } from '../../Database'
+import type { DbConfig } from '../../types'
+
+/**
+ * Represents a Knex database connection.
+ * @extends Database<KnexTransaction>
+ */
+export class KnexDatabase extends Database<KnexTransaction> {
+  private static knexProvider: (config: knex.Knex.Config<any>) => knex.Knex<any, unknown[]> = knex
+
+  private client: Knex
+
+  /**
+   * Constructs a new instance of the database class using the provided configuration.
+   * @param {DbConfig<'knex'>} config - The configuration object for the database.
+   * @returns None
+   */
+  public constructor(config: DbConfig<'knex'>) {
+    super(config)
+    this.client = KnexDatabase.knexProvider({
+      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,
+      },
+    })
+  }
+
+  /**
+   * Initiates a transaction using the underlying database client.
+   * @returns {Promise<KnexTransaction>} A promise that resolves to a KnexTransaction object representing the transaction.
+   */
+  public override async transaction(): Promise<KnexTransaction> {
+    const delegate = await this.client.transaction()
+    return KnexTransactionImpl.wrapDelegate(delegate, this)
+  }
+}

package/src/Database/integrations/knex/KnexTransaction.ts

@@ -0,0 +1,51 @@
+import { Knex } from 'knex'
+
+import { KnexDatabase } from './KnexDatabase'
+import { DatabaseTransaction } from '../../DatabaseTransaction'
+
+/**
+ * A type alias for a Knex transaction object.
+ * @typedef {KnexTransactionImpl & Knex.Transaction} KnexTransaction
+ */
+export type KnexTransaction = KnexTransactionImpl & Knex.Transaction
+
+/**
+ * Implementation of a Knex transaction that extends the DatabaseTransaction class.
+ */
+export class KnexTransactionImpl extends DatabaseTransaction {
+  /**
+   * Constructs a new instance of the private class.
+   * @param {Knex.Transaction} delegate - The delegate transaction object.
+   * @param {KnexDatabase} database - The database object.
+   * @returns None
+   */
+  private constructor(delegate: Knex.Transaction, database: KnexDatabase) {
+    super(delegate, database)
+  }
+
+  /**
+   * Wraps a delegate transaction object with a custom implementation of the KnexTransaction interface.
+   * @param {Knex.Transaction} delegate - The delegate transaction object to wrap.
+   * @param {KnexDatabase} database - The KnexDatabase instance associated with the transaction.
+   * @returns {KnexTransaction} - The wrapped transaction object.
+   */
+  public static wrapDelegate(delegate: Knex.Transaction, database: KnexDatabase): KnexTransaction {
+    return DatabaseTransaction.wrapInstance(new KnexTransactionImpl(delegate, database)) as any
+  }
+
+  /**
+   * Commits the changes made by the delegate object.
+   * @returns None
+   */
+  protected doCommit() {
+    return this.delegate.commit()
+  }
+
+  /**
+   * Performs a rollback operation by calling the rollback method of the delegate object.
+   * @returns None
+   */
+  protected doRollback() {
+    return this.delegate.rollback()
+  }
+}

package/src/Database/integrations/pgsql/PostgresDatabase.ts

@@ -0,0 +1,49 @@
+import { Pool } from 'pg'
+
+import { PostgresTransaction, PostgresTransactionImpl } from './PostgresTransaction'
+import { Database } from '../../Database'
+import type { DbConfig } from '../../types'
+
+/**
+ * Represents a Postgres database connection.
+ * @extends Database<PostgresTransaction>
+ */
+export class PostgresDatabase extends Database<PostgresTransaction> {
+  /**
+   * A private static property that represents a connection pool for a PostgreSQL database.
+   */
+  private static pgProvider = Pool
+  /**
+   * The client property represents a connection pool to a database.
+   * @private
+   * @type {Pool}
+   */
+  private client: Pool
+
+  /**
+   * Constructs a new instance of the class with the given database configuration.
+   * @param {DbConfig<'pg'>} config - The configuration object for the PostgreSQL database.
+   * @returns None
+   */
+  public constructor(config: DbConfig<'pg'>) {
+    super(config)
+    this.client = new PostgresDatabase.pgProvider({
+      host: config.host,
+      port: config.port,
+      user: config.username,
+      password: config.password,
+      database: config.database,
+      max: config.maxConnections,
+    })
+  }
+
+  /**
+   * Initiates a new transaction in the PostgreSQL database.
+   * @returns {Promise<PostgresTransaction>} A promise that resolves to a PostgresTransaction object representing the new transaction.
+   */
+  public override async transaction(): Promise<PostgresTransaction> {
+    const delegate = await this.client.connect()
+    await delegate.query('BEGIN')
+    return PostgresTransactionImpl.wrapDelegate(delegate, this)
+  }
+}

package/src/Database/integrations/pgsql/PostgresTransaction.ts

@@ -0,0 +1,54 @@
+import { PoolClient } from 'pg'
+
+import { PostgresDatabase } from './PostgresDatabase'
+import { DatabaseTransaction } from '../../DatabaseTransaction'
+
+/**
+ * A type alias representing a Postgres transaction. It extends the `PostgresTransactionImpl`
+ * interface and includes the `PoolClient` interface.
+ */
+export type PostgresTransaction = PostgresTransactionImpl & PoolClient
+
+/**
+ * Represents a transaction in a Postgres database.
+ */
+export class PostgresTransactionImpl extends DatabaseTransaction {
+  /**
+   * Constructs a new instance of the private class.
+   * @param {PoolClient} delegate - The delegate object.
+   * @param {PostgresDatabase} database - The database object.
+   * @returns None
+   */
+  private constructor(delegate: PoolClient, database: PostgresDatabase) {
+    super(delegate, database)
+  }
+
+  /**
+   * Static factory method for creating a new instance, wrapping a delegate PoolClient.
+   * @param {PoolClient} delegate - The delegate client to wrap.
+   * @param {PostgresDatabase} database - The PostgresDatabase instance associated with the transaction.
+   * @returns {PostgresTransaction} - A wrapped PostgresTransaction instance.
+   */
+  public static wrapDelegate(
+    delegate: PoolClient,
+    database: PostgresDatabase
+  ): PostgresTransaction {
+    return DatabaseTransaction.wrapInstance(new PostgresTransactionImpl(delegate, database)) as any
+  }
+
+  /**
+   * Commits the current transaction.
+   * @returns A promise that resolves when the commit is successful.
+   */
+  protected doCommit() {
+    return this.delegate.query('COMMIT')
+  }
+
+  /**
+   * Performs a rollback operation in the database.
+   * @returns A promise that resolves when the rollback operation is completed.
+   */
+  protected doRollback() {
+    return this.delegate.query('ROLLBACK')
+  }
+}

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)
+  })
+})