@creator.co/wapi 1.2.4 → 1.2.5

package/dist/src/Database/integrations/pgsql/PostgresTransaction.js

@@ -0,0 +1,60 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgresTransactionImpl = void 0;
+var DatabaseTransaction_1 = require("../../DatabaseTransaction");
+/**
+ * Represents a transaction in a Postgres database.
+ */
+var PostgresTransactionImpl = /** @class */ (function (_super) {
+    __extends(PostgresTransactionImpl, _super);
+    /**
+     * Constructs a new instance of the private class.
+     * @param {PoolClient} delegate - The delegate object.
+     * @param {PostgresDatabase} database - The database object.
+     * @returns None
+     */
+    function PostgresTransactionImpl(delegate, database) {
+        return _super.call(this, delegate, database) || this;
+    }
+    /**
+     * 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.
+     */
+    PostgresTransactionImpl.wrapDelegate = function (delegate, database) {
+        return DatabaseTransaction_1.DatabaseTransaction.wrapInstance(new PostgresTransactionImpl(delegate, database));
+    };
+    /**
+     * Commits the current transaction.
+     * @returns A promise that resolves when the commit is successful.
+     */
+    PostgresTransactionImpl.prototype.doCommit = function () {
+        return this.delegate.query('COMMIT');
+    };
+    /**
+     * Performs a rollback operation in the database.
+     * @returns A promise that resolves when the rollback operation is completed.
+     */
+    PostgresTransactionImpl.prototype.doRollback = function () {
+        return this.delegate.query('ROLLBACK');
+    };
+    return PostgresTransactionImpl;
+}(DatabaseTransaction_1.DatabaseTransaction));
+exports.PostgresTransactionImpl = PostgresTransactionImpl;
+//# sourceMappingURL=PostgresTransaction.js.map

package/dist/src/Database/integrations/pgsql/PostgresTransaction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PostgresTransaction.js","sourceRoot":"","sources":["../../../../../src/Database/integrations/pgsql/PostgresTransaction.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAGA,iEAA+D;AAQ/D;;GAEG;AACH;IAA6C,2CAAmB;IAC9D;;;;;OAKG;IACH,iCAAoB,QAAoB,EAAE,QAA0B;eAClE,kBAAM,QAAQ,EAAE,QAAQ,CAAC;IAC3B,CAAC;IAED;;;;;OAKG;IACW,oCAAY,GAA1B,UACE,QAAoB,EACpB,QAA0B;QAE1B,OAAO,yCAAmB,CAAC,YAAY,CAAC,IAAI,uBAAuB,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAQ,CAAA;IACjG,CAAC;IAED;;;OAGG;IACO,0CAAQ,GAAlB;QACE,OAAO,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAA;IACtC,CAAC;IAED;;;OAGG;IACO,4CAAU,GAApB;QACE,OAAO,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,UAAU,CAAC,CAAA;IACxC,CAAC;IACH,8BAAC;AAAD,CAAC,AAvCD,CAA6C,yCAAmB,GAuC/D;AAvCY,0DAAuB"}

package/dist/src/Server/lib/container/Proxy.js

@@ -167,8 +167,9 @@ var Proxy = /** @class */ (function () {
                 console.debug('[Proxy] - [STOPPING]');
                 return [2 /*return*/, new Promise(function (resolve) {
                         _this.listener.close(function (_err) {
-                            if (err || _err)
-                                console.log('[Proxy] - exit output:', err || _err);
+                            var err2 = err || _err;
+                            if (err2)
+                                console.log('[Proxy] - exit output:', err2);
                             console.log('[Proxy] - [STOPPED]');
                             process.exit(err || _err ? 1 : 0);
                             resolve(null);

package/dist/src/Server/lib/container/Proxy.js.map

@@ -1 +1 @@
-{"version":3,"file":"Proxy.js","sourceRoot":"","sources":["../../../../../src/Server/lib/container/Proxy.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"Proxy.js","sourceRoot":"","sources":["../../../../../src/Server/lib/container/Proxy.ts"],"names":[],"mappings":"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"}

package/jest.config.ts

@@ -19,7 +19,7 @@ const config: Config.InitialOptions = {
     ],
   ],
   coverageReporters: ['clover', 'json', 'lcov', ['text', { file: 'coverage.txt' }], 'json-summary'],
-  collectCoverageFrom: ['src/**/*.(t|j)s'],
+  collectCoverageFrom: ['src/**/*.(t|j)s', '!src/**/*.d.(t|j)s'],
   coverageThreshold: {
     global: {
       branches: 80,

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@creator.co/wapi",
-  "version": "1.2.4",
+  "version": "1.2.5",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "commonjs",
   "scripts": {
-    "build": "npm run lint && tsc --build",
+    "build": "tsc --build",
     "clean": "tsc --build --clean",
     "lint-fix": "eslint . --ext .ts --fix",
     "lint": "eslint . --ext .ts",
@@ -24,6 +24,7 @@
     "@aws-sdk/credential-provider-node": "^3.414.0",
     "@types/email-templates": "^10.0.1",
     "@types/nodemailer": "^6.4.10",
+    "@types/object-hash": "^3.0.4",
     "abind": "^1.0.5",
     "cors": "^2.8.5",
     "cuid": "^3.0.0",
@@ -32,18 +33,23 @@
     "express": "^4.18.2",
     "json-stringify-safe": "^5.0.1",
     "jsonwebtoken": "^9.0.2",
+    "knex": "^3.0.1",
     "node-cache": "^5.1.2",
+    "object-hash": "^3.0.0",
     "parse-duration": "^1.1.0",
+    "pg": "^8.11.3",
     "sha1": "^1.1.1",
     "stack-trace": "0.0.10",
     "zod": "^3.22.4"
   },
   "devDependencies": {
     "@types/aws-lambda": "^8.10.119",
+    "@types/chai": "^4.3.9",
     "@types/express": "^4.17.19",
     "@types/jest": "^29.5.6",
     "@types/jsonwebtoken": "^9.0.3",
     "@types/node": "^20.5.7",
+    "@types/pg": "^8.10.5",
     "@typescript-eslint/eslint-plugin": "^6.5.0",
     "@typescript-eslint/parser": "^6.5.0",
     "aws-lambda": "^1.0.7",

package/src/BaseEvent/Transaction.ts

@@ -2,6 +2,9 @@ import type { APIGatewayEvent, Context, SQSEvent } from 'aws-lambda'
 
 import Request from '../API/Request'
 import Response, { ResponseErrorType } from '../API/Response'
+import { DatabaseManager } from '../Database/DatabaseManager'
+import { DatabaseTransaction } from '../Database/DatabaseTransaction'
+import type { DatabaseTransactionType, DatabaseType, DbConfig } from '../Database/types'
 import Globals from '../Globals'
 import Logger, { LoggerConfig } from '../Logger/Logger'
 import Publisher, { PublisherConfig } from '../Publisher/Publisher'
@@ -24,6 +27,8 @@ export default class Transaction<
   ResponseInnerType = null,
   MiscRespType = null,
 > {
+  private databaseManager: DatabaseManager = DatabaseManager.INSTANCE
+  private transactions: DatabaseTransaction[] = []
   private event: any
   private context: Context
   private response: Response<ResponseInnerType | ResponseErrorType> | MiscRespType | null
@@ -34,6 +39,7 @@ export default class Transaction<
   public readonly request: Request<InputType>
   public readonly publisher: Publisher
   public responseProxy: (response: Response<ResponseInnerType>) => Promise<void>
+
   //
   constructor(event: APIGatewayEvent | SQSEvent, context: Context, config?: TransactionConfig) {
     const transactionId = context.awsRequestId
@@ -74,6 +80,7 @@ export default class Transaction<
     // allow request to async succeed through lambda context
     return null
   }
+
   //Executions
   private async iexecute(
     executionFunc: TransactionExecution<
@@ -119,32 +126,54 @@ export default class Transaction<
     }
     return executionFailed
   }
-  private async executeDBTransactions(safeExecution) {
+
+  /**
+   * Retrieves a database transaction for the specified database configuration.
+   * @async
+   * @param {DbConfig<S>} config - The configuration object for the database.
+   * @returns {Promise<DatabaseTransactionType<S>>} A promise that resolves to the database transaction.
+   */
+  public async getDbTransaction<S extends DatabaseType>(
+    config: DbConfig<S>
+  ): Promise<DatabaseTransactionType<S>> {
+    const db = this.databaseManager.create(config)
+    const dbTrans = await db.transaction()
+    this.transactions.push(dbTrans)
+    return dbTrans as any
+  }
+
+  private async executeDBTransactions(safeExecution: () => Promise<boolean>): Promise<void> {
     try {
-      // //start DB
-      // if (this.db) await this.db.connect();
-      // //start transaction
-      // if (this.db) await this.db.beginTransaction();
-      // //
-      // let executionFailed =
-      await safeExecution()
-      // //Commit if not failed, rollback if failed
-      // if (!executionFailed) {
-      //   if (this.db) await this.db.commit();
-      // } else {
-      //   this.logger.log("Rolling back DB transactions. Main code failed!");
-      //   if (this.db) await this.db.rollback();
-      // }
-      // //Cleanup DB after execution
-      // if (this.db) await this.db.cleanup();
+      // Execute
+      const execFailed = await safeExecution()
+      for (const transaction of [...this.transactions].reverse()) {
+        try {
+          await transaction[execFailed ? 'closeFailure' : 'closeSuccess']()
+        } catch (e) {
+          // TODO: should we keep committing transactions even if one fails?
+          this.logger.error('Exception when closing DB transactions after success.')
+          this.logger.exception(e)
+        }
+      }
     } catch (e) {
+      /* this part of the code handle exceptions at transaction level,
+         so probably a bug but we still handle such */
+      for (const transaction of [...this.transactions].reverse()) {
+        try {
+          await transaction.closeFailure()
+        } catch (e) {
+          this.logger.error('Exception when closing DB transactions after failure.')
+          this.logger.exception(e)
+        }
+      }
       this.logger.error('Exception when executing DB transactions.')
       this.logger.log(e.stack)
       //retrow?
       if (this.retrowErrors) throw e
     }
   }
-  private async executeLoggerFlush(safeExecution) {
+
+  private async executeLoggerFlush(safeExecution): Promise<void> {
     try {
       await safeExecution()
     } catch (e) {
@@ -156,6 +185,7 @@ export default class Transaction<
       this.logger.debug('Transaction ended')
     }
   }
+
   /* Response support */
   private getErrorResponse(error: string, code: string): Response<ResponseErrorType> {
     return Response.BadRequestResponseWithRollback(error, code)

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