@creator.co/wapi 1.3.19-alpha1 → 1.4.0-alpha1

package/src/Database/types.ts

@@ -1,45 +1,60 @@
 import { Database } from './Database'
 import { DATABASES } from './DatabaseManager'
+import { KnexDatabase } from './integrations/knex/KnexDatabase'
+import { KyselyDatabase } from './integrations/kysely/KyselyDatabase'
+import { PostgresDatabase } from './integrations/pgsql/PostgresDatabase'
 
 /**
- * Represents the available types of databases.
+ * Represents the possible types of databases available in the system.
  * @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.
+ * Defines a type for a database class that includes instances for Knex, Postgres, and Kysely databases.
+ * @template T - The type of data the KyselyDatabase instance will handle.
+ * @property {new (...args: any[]) => KnexDatabase} knex - Constructor for KnexDatabase instances.
+ * @property {new (...args: any[]) => PostgresDatabase} pg - Constructor for PostgresDatabase instances.
+ * @property {new (...args: any[]) => KyselyDatabase<T>} kysely - Constructor for KyselyDatabase instances with type T.
  */
-export type DatabaseImplType<Type extends DatabaseType> = InstanceType<(typeof DATABASES)[Type]>
+export type DatabaseClass<T> = {
+  knex: new (...args: any[]) => KnexDatabase
+  pg: new (...args: any[]) => PostgresDatabase
+  kysely: new (...args: any[]) => KyselyDatabase<T>
+}
 
 /**
- * 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.
+ * Represents a specific implementation type for a database based on the provided DatabaseType.
+ * @param {DatabaseType} Type - The type of database to implement.
+ * @param {T} T - The generic type for the database implementation.
+ * @returns An instance of the specified database class for the given type.
  */
-export type DatabaseTransactionType<Type extends DatabaseType> =
-  DatabaseImplType<Type> extends Database<infer TransactionType> ? TransactionType : never
+export type DatabaseImplType<Type extends DatabaseType, T> = InstanceType<DatabaseClass<T>[Type]>
 
 /**
- * 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.
- * @property {boolean} [convertCamelToSnake] - Whether or not to convert camel case to snake case for column names.
- * @returns The transaction type associated with the specified database type.
+ * Defines the type of transaction for a specific database type and schema.
+ * @param {DatabaseType} Type - The type of the database.
+ * @param {DBSchema} DBSchema - The schema of the database.
+ * @returns The transaction type associated with the database type and schema.
  */
-export type DbConfig<S extends DatabaseType> = {
-  type: S
-  driver: string
+export type DatabaseTransactionType<Type extends DatabaseType, DBSchema> =
+  DatabaseImplType<Type, DBSchema> extends Database<infer TransactionType> ? TransactionType : never
+
+/**
+ * Defines the configuration options for different types of databases.
+ * @typedef {Object} DbBaseConfig
+ * @property {string} host - The host of the database.
+ * @property {number} port - The port number of the database.
+ * @property {string} username - The username for accessing the database.
+ * @property {string} password - The password for accessing the database.
+ * @property {string} database - The name of the database.
+ * @property {boolean} autoCommit - Flag indicating whether auto-commit is enabled.
+ * @property {number} maxConnections - The maximum number of connections allowed.
+ *
+ * @typedef {Object} DbConfig
+ * @property {string} type - The type of
+ */
+type DbBaseConfig = {
   host: string
   port: number
   username: string
@@ -47,8 +62,15 @@ export type DbConfig<S extends DatabaseType> = {
   database: string
   autoCommit: boolean
   maxConnections: number
-} & (S extends 'knex'
-  ? {
-      convertCamelToSnake?: boolean
-    }
-  : any)
+}
+export type DbConfig<S extends DatabaseType> = DbBaseConfig & { type: S } & (S extends 'knex'
+    ? {
+        driver?: string
+        convertCamelToSnake?: boolean
+      }
+    : unknown) &
+  (S extends 'pg' | 'kysely'
+    ? {
+        readReplica?: DbBaseConfig
+      }
+    : unknown)

package/src/Logger/Logger.ts

@@ -33,8 +33,10 @@ const PURE_CONSOLE = console['notGlobalLogger'] ? console['origin'] : console
 const DEFAULT_LOG_FUNCTION = PURE_CONSOLE.log.bind(PURE_CONSOLE)
 
 /**
- * An array of sensitive strings that should be blacklisted or excluded from certain operations.
- * This array includes strings such as 'password', 'phonenumber', 'resetCode', etc.
+ * Creates a blacklist array by mapping each string in the given array to its lowercase form.
+ * The resulting blacklist array is used to filter out sensitive information.
+ * @type {string[]} blacklist - An array of strings to be converted to lowercase and used as a blacklist.
+ * @returns {string[]} - An array of lowercase strings representing the blacklist.
  */
 const blacklist = ['password', 'token', 'accounts'].map(s => s.toLowerCase())
 
@@ -214,29 +216,24 @@ export default class Logger {
   }
 
   /**
-   * Returns the name of the caller at the specified index in the call stack.
-   * @param {number} index - The index of the caller in the call stack.
-   * @returns {string} The name of the caller, including the file name and line number.
+   * Retrieves the name of the caller function at the specified index in the stack trace.
+   * @param {number} index - The index of the caller function in the stack trace.
+   * @returns {string} The name of the caller function along with the file path and line number.
    */
   private callerName(index: number): string {
     const safeIndex = Math.min(index, stackTrace.get().length)
     if (stackTrace.get()[safeIndex]) {
-      let callerName = stackTrace.get()[safeIndex]
-        ? stackTrace.get()[safeIndex].getTypeName()
-        : null
-      if (!callerName) {
-        callerName = stackTrace?.get()?.[safeIndex]?.getFileName()?.split('/')
-        callerName = callerName?.slice(callerName?.indexOf('src'))?.join('/')
-      }
+      let callerName = stackTrace?.get()?.[safeIndex]?.getFileName()?.split('/')
+      callerName = callerName?.slice(callerName?.indexOf('src'))?.join('/')
       return callerName + ':' + stackTrace?.get()?.[safeIndex]?.getLineNumber()
     }
     return ''
   }
 
   /**
-   * Processes a log message based on the specified log level and arguments.
-   * @param {LOG_LEVELS} level - The log level of the message.
-   * @param {any[]} args - The arguments to be logged.
+   * Processes log messages based on the specified log level.
+   * @param {LOG_LEVELS} level - The level of the log message.
+   * @param {any} args - The arguments to be logged.
    * @returns None
    */
   private processLog(level: LOG_LEVELS, args: any): void {

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

@@ -67,9 +67,9 @@ const processServerlessResponse = (invokation: GenericHandlerEventResponse, res:
     let response = res.status(invokation.data.statusCode)
     // check for stream
     if (invokation.data?.body?.pipe) {
-      invokation.data.body.pipe(res)
+      invokation.data.body.pipe(response)
     } else {
-      response = res.json(Utils.parseObjectNullIfEmpty(invokation.data.body) || {})
+      response = response.json(Utils.parseObjectNullIfEmpty(invokation.data.body) || {})
     }
     return response
   }

package/tests/Database/DatabaseManager.test.ts

@@ -3,7 +3,7 @@ import { expect } from 'chai'
 import { DatabaseManager } from '../../src/Database'
 import type { DatabaseType, DbConfig } from '../../src/Database/types'
 
-type FakeDatabase = { host: string; type: 'knex' | 'pg' }
+type FakeDatabase = { host: string; type: 'knex' | 'pg' | 'kysely' }
 
 const fakeConfig = (host: string, type: DatabaseType) => {
   return {
@@ -23,6 +23,9 @@ describe('Database Manager', () => {
       pg: jest.fn(config => {
         return { host: config.host, type: 'pg' } as any
       }) as any,
+      kysely: jest.fn(config => {
+        return { host: config.host, type: 'kysely' } as any
+      }) as any,
     }
 
     const create = config => underTest.create({ ...config }) as unknown as FakeDatabase
@@ -31,6 +34,8 @@ describe('Database Manager', () => {
     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)
@@ -40,6 +45,10 @@ describe('Database Manager', () => {
     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)
@@ -51,5 +60,11 @@ describe('Database Manager', () => {
     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

@@ -47,7 +47,7 @@ describe('KnexDatabase', () => {
     const trans = await underTest.transaction()
 
     expect(trans).toBeInstanceOf(Function)
-    expect(trans['delegate']).toBe(mockTrans)
+    expect(trans.transaction).toBe(mockTrans)
   })
 
   test('KnexDatabase - convert camel to snake', async () => {
@@ -70,6 +70,6 @@ describe('KnexDatabase', () => {
     const trans = await underTest.transaction()
 
     expect(trans).toBeInstanceOf(Function)
-    expect(trans['delegate']).toBe(mockTrans)
+    expect(trans.transaction).toBe(mockTrans)
   })
 })

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

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

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

@@ -0,0 +1,109 @@
+import { expect as c_expect } from 'chai'
+import { PostgresDialect } from 'kysely'
+import { PoolClient } 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 => {
+        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 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).toHaveBeenNthCalledWith(1, { dialect: underTest.pgClient })
+
+    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).toHaveBeenNthCalledWith(1, { dialect: underTest.pgClient })
+    expect(mockClient).toHaveBeenNthCalledWith(2, { dialect: underTest.pgReadClient })
+
+    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)
+  })
+})

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

@@ -0,0 +1,118 @@
+import { Kysely, PostgresDialect, 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 => {
+        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)
+  })
+})