@creator.co/wapi 1.3.19 → 1.4.0-alpha1

package/dist/src/Database/integrations/kysely/KyselyTransaction.js

@@ -0,0 +1,186 @@
+"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 __());
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KyselyTransactionImpl = void 0;
+var DatabaseTransaction_1 = require("../../DatabaseTransaction");
+/**
+ * Represents a transaction in a Postgres database.
+ */
+var KyselyTransactionImpl = /** @class */ (function (_super) {
+    __extends(KyselyTransactionImpl, _super);
+    /**
+     * Constructs a new instance of the class.
+     * @param {Kysely<DBSchema>} delegate - The delegate object for the database query.
+     * @param {KyselyDatabase<DBSchema>} database - The database object for the query.
+     * @param {Kysely<DBSchema>} [reader] - An optional reader object for the query.
+     * @returns None
+     */
+    function KyselyTransactionImpl(delegate, database, reader) {
+        var _this = _super.call(this, delegate, database, reader) || this;
+        /**
+         * Asynchronously begins a transaction using a writer and resolves the transaction once it is executed.
+         * @returns A Promise that resolves with the transaction object once the transaction is executed.
+         */
+        _this.doBegin = function () { return __awaiter(_this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                this.txWrapper = new Deferred();
+                return [2 /*return*/, new Promise(function (resolve) {
+                        _this.writer
+                            .transaction()
+                            .execute(function (trx) { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                this.transaction = trx;
+                                resolve(trx); // resolve with tx
+                                return [2 /*return*/, this.txWrapper.promise]; // wait for wrapper to be solved
+                            });
+                        }); })
+                            .catch(function () {
+                            // Don't do anything here. Just swallow the exception.
+                        });
+                    })];
+            });
+        }); };
+        /**
+         * Executes the commit operation by resolving the transaction wrapper and returning a resolved Promise.
+         * @returns A Promise that resolves to null.
+         */
+        _this.doCommit = function () {
+            _this.txWrapper.resolve(null);
+            return Promise.resolve();
+        };
+        /**
+         * Performs a rollback operation by rejecting the transaction wrapper with an error.
+         * @returns A resolved Promise after the rollback operation is completed.
+         */
+        _this.doRollback = function () {
+            _this.txWrapper.reject(new Error('Rollback'));
+            return Promise.resolve();
+        };
+        return _this;
+    }
+    /**
+     * Creates a new database transaction for the given database schema.
+     * @param {Kysely<DBSchema>} connection - The connection object for the transaction.
+     * @param {KyselyDatabase<DBSchema>} database - The database object for the transaction.
+     * @param {Kysely<DBSchema>} [reader] - An optional reader object for the transaction.
+     * @returns {Promise<KyselyTransaction<DBSchema>>} A promise that resolves to the created transaction.
+     */
+    KyselyTransactionImpl.newTransaction = function (connection, database, reader) {
+        return __awaiter(this, void 0, void 0, function () {
+            var tx;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        tx = new KyselyTransactionImpl(connection, database, reader);
+                        return [4 /*yield*/, tx.begin()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, DatabaseTransaction_1.DatabaseTransaction.proxyInstance(tx)];
+                }
+            });
+        });
+    };
+    return KyselyTransactionImpl;
+}(DatabaseTransaction_1.DatabaseTransaction));
+exports.KyselyTransactionImpl = KyselyTransactionImpl;
+/**
+ * Represents a deferred promise that can be resolved or rejected at a later time.
+ * @template T - The type of the value that the promise will resolve to.
+ */
+var Deferred = /** @class */ (function () {
+    /**
+     * Constructor for creating a new Promise instance with resolve and reject functions.
+     * @constructor
+     */
+    function Deferred() {
+        var _this = this;
+        this._promise = new Promise(function (resolve, reject) {
+            _this._reject = reject;
+            _this._resolve = resolve;
+        });
+    }
+    Object.defineProperty(Deferred.prototype, "promise", {
+        /**
+         * Getter method to retrieve the Promise object.
+         * @returns {Promise<T>} A Promise object of type T.
+         */
+        get: function () {
+            return this._promise;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Resolves the Promise with the given value.
+     * @param {T | PromiseLike<T>} value - The value to resolve the Promise with.
+     * @returns void
+     */
+    Deferred.prototype.resolve = function (value) {
+        if (this._resolve) {
+            this._resolve(value);
+        }
+    };
+    /**
+     * Rejects the Promise with the given reason, if the reject function is available.
+     * @param {any} reason - The reason for rejecting the Promise.
+     * @returns void
+     */
+    Deferred.prototype.reject = function (reason) {
+        if (this._reject) {
+            this._reject(reason);
+        }
+    };
+    return Deferred;
+}());
+//# sourceMappingURL=KyselyTransaction.js.map

package/dist/src/Database/integrations/kysely/KyselyTransaction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"KyselyTransaction.js","sourceRoot":"","sources":["../../../../../src/Database/integrations/kysely/KyselyTransaction.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIA,iEAA+D;AAQ/D;;GAEG;AACH;IAAqD,yCAAmB;IAyBtE;;;;;;OAMG;IACH,+BACE,QAA0B,EAC1B,QAAkC,EAClC,MAAyB;QAH3B,YAKE,kBAAM,QAAQ,EAAE,QAAQ,EAAE,MAAM,CAAC,SAClC;QAmBD;;;WAGG;QACO,aAAO,GAAG;;;gBAClB,IAAI,CAAC,SAAS,GAAG,IAAI,QAAQ,EAAO,CAAA;gBACpC,sBAAO,IAAI,OAAO,CAAC,UAAA,OAAO;wBACxB,KAAI,CAAC,MAAM;6BACR,WAAW,EAAE;6BACb,OAAO,CAAC,UAAM,GAAG;;gCAChB,IAAI,CAAC,WAAW,GAAG,GAAG,CAAA;gCACtB,OAAO,CAAC,GAAG,CAAC,CAAA,CAAC,kBAAkB;gCAC/B,sBAAO,IAAI,CAAC,SAAS,CAAC,OAAO,EAAA,CAAC,gCAAgC;;6BAC/D,CAAC;6BACD,KAAK,CAAC;4BACL,sDAAsD;wBACxD,CAAC,CAAC,CAAA;oBACN,CAAC,CAAC,EAAA;;aACH,CAAA;QAED;;;WAGG;QACO,cAAQ,GAAG;YACnB,KAAI,CAAC,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;YAC5B,OAAO,OAAO,CAAC,OAAO,EAAE,CAAA;QAC1B,CAAC,CAAA;QAED;;;WAGG;QACO,gBAAU,GAAG;YACrB,KAAI,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,UAAU,CAAC,CAAC,CAAA;YAC5C,OAAO,OAAO,CAAC,OAAO,EAAE,CAAA;QAC1B,CAAC,CAAA;;IAvDD,CAAC;IAED;;;;;;OAMG;IACiB,oCAAc,GAAlC,UACE,UAA4B,EAC5B,QAAkC,EAClC,MAAyB;;;;;;wBAEnB,EAAE,GAAG,IAAI,qBAAqB,CAAW,UAAU,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAA;wBAC5E,qBAAM,EAAE,CAAC,KAAK,EAAE,EAAA;;wBAAhB,SAAgB,CAAA;wBAChB,sBAAO,yCAAmB,CAAC,aAAa,CAAC,EAAE,CAAQ,EAAA;;;;KACpD;IAuCH,4BAAC;AAAD,CAAC,AA9FD,CAAqD,yCAAmB,GA8FvE;AA9FY,sDAAqB;AAgGlC;;;GAGG;AACH;IAgBE;;;OAGG;IACH;QAAA,iBAKC;QAJC,IAAI,CAAC,QAAQ,GAAG,IAAI,OAAO,CAAI,UAAC,OAAO,EAAE,MAAM;YAC7C,KAAI,CAAC,OAAO,GAAG,MAAM,CAAA;YACrB,KAAI,CAAC,QAAQ,GAAG,OAAO,CAAA;QACzB,CAAC,CAAC,CAAA;IACJ,CAAC;IAMD,sBAAW,6BAAO;QAJlB;;;WAGG;aACH;YACE,OAAO,IAAI,CAAC,QAAQ,CAAA;QACtB,CAAC;;;OAAA;IAED;;;;OAIG;IACI,0BAAO,GAAd,UAAe,KAAyB;QACtC,IAAI,IAAI,CAAC,QAAQ,EAAE;YACjB,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAA;SACrB;IACH,CAAC;IAED;;;;OAIG;IACI,yBAAM,GAAb,UAAc,MAAY;QACxB,IAAI,IAAI,CAAC,OAAO,EAAE;YAChB,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAA;SACrB;IACH,CAAC;IACH,eAAC;AAAD,CAAC,AAxDD,IAwDC"}

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

@@ -1,30 +1,35 @@
+import { Pool } from 'pg';
 import { PostgresTransaction } from './PostgresTransaction';
 import { Database } from '../../Database';
 import type { DbConfig } from '../../types';
 /**
- * Represents a Postgres database connection.
+ * Represents a Postgres database connection that extends the Database class.
  * @extends Database<PostgresTransaction>
  */
 export declare class PostgresDatabase extends Database<PostgresTransaction> {
     /**
-     * A private static property that represents a connection pool for a PostgreSQL database.
+     * A public static property that represents a connection pool for a PostgreSQL database.
+     * This property is used to manage and provide connections to the PostgreSQL database.
      */
-    private static pgProvider;
+    static pgProvider: typeof Pool;
     /**
-     * The client property represents a connection pool to a database.
-     * @private
-     * @type {Pool}
+     * Represents a connection pool to manage multiple client connections to the database.
      */
-    private client;
+    readonly 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.
+     * A private property that represents a connection pool for clients.
+     * @type {Pool | undefined}
+     */
+    readonly readClient?: Pool;
+    /**
+     * Constructor for creating a new instance of a database connection using Postgres.
+     * @param {DbConfig<'pg'>} config - The configuration object for the Postgres database.
      * @returns None
      */
     constructor(config: DbConfig<'pg'>);
     /**
-     * Initiates a new transaction in the PostgreSQL database.
-     * @returns {Promise<PostgresTransaction>} A promise that resolves to a PostgresTransaction object representing the new transaction.
+     * Creates a new Postgres transaction using the provided client and read client.
+     * @returns {Promise<PostgresTransaction>} A promise that resolves to a new PostgresTransaction object.
      */
     transaction(): Promise<PostgresTransaction>;
 }

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

@@ -56,14 +56,14 @@ var pg_1 = require("pg");
 var PostgresTransaction_1 = require("./PostgresTransaction");
 var Database_1 = require("../../Database");
 /**
- * Represents a Postgres database connection.
+ * Represents a Postgres database connection that extends the Database class.
  * @extends Database<PostgresTransaction>
  */
-var PostgresDatabase = /** @class */ (function (_super) {
+var PostgresDatabase = exports.PostgresDatabase = /** @class */ (function (_super) {
     __extends(PostgresDatabase, _super);
     /**
-     * Constructs a new instance of the class with the given database configuration.
-     * @param {DbConfig<'pg'>} config - The configuration object for the PostgreSQL database.
+     * Constructor for creating a new instance of a database connection using Postgres.
+     * @param {DbConfig<'pg'>} config - The configuration object for the Postgres database.
      * @returns None
      */
     function PostgresDatabase(config) {
@@ -76,33 +76,34 @@ var PostgresDatabase = /** @class */ (function (_super) {
             database: config.database,
             max: config.maxConnections,
         });
+        if (config.readReplica) {
+            _this.readClient = new PostgresDatabase.pgProvider({
+                host: config.readReplica.host,
+                port: config.readReplica.port,
+                user: config.readReplica.username,
+                password: config.readReplica.password,
+                database: config.readReplica.database,
+                max: config.readReplica.maxConnections,
+            });
+        }
         return _this;
     }
     /**
-     * Initiates a new transaction in the PostgreSQL database.
-     * @returns {Promise<PostgresTransaction>} A promise that resolves to a PostgresTransaction object representing the new transaction.
+     * Creates a new Postgres transaction using the provided client and read client.
+     * @returns {Promise<PostgresTransaction>} A promise that resolves to a new PostgresTransaction object.
      */
     PostgresDatabase.prototype.transaction = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var delegate;
             return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.client.connect()];
-                    case 1:
-                        delegate = _a.sent();
-                        return [4 /*yield*/, delegate.query('BEGIN')];
-                    case 2:
-                        _a.sent();
-                        return [2 /*return*/, PostgresTransaction_1.PostgresTransactionImpl.wrapDelegate(delegate, this)];
-                }
+                return [2 /*return*/, PostgresTransaction_1.PostgresTransactionImpl.newTransaction(this.client, this, this.readClient)];
             });
         });
     };
     /**
-     * A private static property that represents a connection pool for a PostgreSQL database.
+     * A public static property that represents a connection pool for a PostgreSQL database.
+     * This property is used to manage and provide connections to the PostgreSQL database.
      */
     PostgresDatabase.pgProvider = pg_1.Pool;
     return PostgresDatabase;
 }(Database_1.Database));
-exports.PostgresDatabase = PostgresDatabase;
 //# sourceMappingURL=PostgresDatabase.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"PostgresDatabase.js","sourceRoot":"","sources":["../../../../../src/Database/integrations/pgsql/PostgresDatabase.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,yBAAyB;AAEzB,6DAAoF;AACpF,2CAAyC;AAGzC;;;GAGG;AACH;IAAsC,oCAA6B;IAYjE;;;;OAIG;IACH,0BAAmB,MAAsB;QACvC,YAAA,MAAK,YAAC,MAAM,CAAC,SAAA;QACb,KAAI,CAAC,MAAM,GAAG,IAAI,gBAAgB,CAAC,UAAU,CAAC;YAC5C,IAAI,EAAE,MAAM,CAAC,IAAI;YACjB,IAAI,EAAE,MAAM,CAAC,IAAI;YACjB,IAAI,EAAE,MAAM,CAAC,QAAQ;YACrB,QAAQ,EAAE,MAAM,CAAC,QAAQ;YACzB,QAAQ,EAAE,MAAM,CAAC,QAAQ;YACzB,GAAG,EAAE,MAAM,CAAC,cAAc;SAC3B,CAAC,CAAA;;IACJ,CAAC;IAED;;;OAGG;IACmB,sCAAW,GAAjC;;;;;4BACmB,qBAAM,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,EAAA;;wBAAtC,QAAQ,GAAG,SAA2B;wBAC5C,qBAAM,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,EAAA;;wBAA7B,SAA6B,CAAA;wBAC7B,sBAAO,6CAAuB,CAAC,YAAY,CAAC,QAAQ,EAAE,IAAI,CAAC,EAAA;;;;KAC5D;IApCD;;OAEG;IACY,2BAAU,GAAG,SAAI,CAAA;IAkClC,uBAAC;CAAA,AAtCD,CAAsC,mBAAQ,GAsC7C;AAtCY,4CAAgB"}
+{"version":3,"file":"PostgresDatabase.js","sourceRoot":"","sources":["../../../../../src/Database/integrations/pgsql/PostgresDatabase.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,yBAAyB;AAEzB,6DAAoF;AACpF,2CAAyC;AAGzC;;;GAGG;AACH;IAAsC,oCAA6B;IAgBjE;;;;OAIG;IACH,0BAAmB,MAAsB;QAAzC,YACE,kBAAM,MAAM,CAAC,SAmBd;QAlBC,KAAI,CAAC,MAAM,GAAG,IAAI,gBAAgB,CAAC,UAAU,CAAC;YAC5C,IAAI,EAAE,MAAM,CAAC,IAAI;YACjB,IAAI,EAAE,MAAM,CAAC,IAAI;YACjB,IAAI,EAAE,MAAM,CAAC,QAAQ;YACrB,QAAQ,EAAE,MAAM,CAAC,QAAQ;YACzB,QAAQ,EAAE,MAAM,CAAC,QAAQ;YACzB,GAAG,EAAE,MAAM,CAAC,cAAc;SAC3B,CAAC,CAAA;QACF,IAAI,MAAM,CAAC,WAAW,EAAE;YACtB,KAAI,CAAC,UAAU,GAAG,IAAI,gBAAgB,CAAC,UAAU,CAAC;gBAChD,IAAI,EAAE,MAAM,CAAC,WAAW,CAAC,IAAI;gBAC7B,IAAI,EAAE,MAAM,CAAC,WAAW,CAAC,IAAI;gBAC7B,IAAI,EAAE,MAAM,CAAC,WAAW,CAAC,QAAQ;gBACjC,QAAQ,EAAE,MAAM,CAAC,WAAW,CAAC,QAAQ;gBACrC,QAAQ,EAAE,MAAM,CAAC,WAAW,CAAC,QAAQ;gBACrC,GAAG,EAAE,MAAM,CAAC,WAAW,CAAC,cAAc;aACvC,CAAC,CAAA;SACH;;IACH,CAAC;IAED;;;OAGG;IACmB,sCAAW,GAAjC;;;gBACE,sBAAO,6CAAuB,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,UAAU,CAAC,EAAA;;;KAClF;IAhDD;;;OAGG;IACW,2BAAU,GAAG,SAAI,CAAA;IA6CjC,uBAAC;CAAA,AAlDD,CAAsC,mBAAQ,GAkD7C"}

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

@@ -1,5 +1,6 @@
-import { PoolClient } from 'pg';
+import { Pool, PoolClient } from 'pg';
 import { PostgresDatabase } from './PostgresDatabase';
+import { Database } from '../../Database';
 import { DatabaseTransaction } from '../../DatabaseTransaction';
 /**
  * A type alias representing a Postgres transaction. It extends the `PostgresTransactionImpl`
@@ -11,27 +12,52 @@ export type PostgresTransaction = PostgresTransactionImpl & PoolClient;
  */
 export declare 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
+     * A Pool object used for writing operations.
+     * @readonly
+     */
+    readonly writer: Pool;
+    /**
+     * A readonly property representing a pool reader.
+     */
+    readonly reader: Pool;
+    /**
+     * Represents a database transaction using a PoolClient.
+     * @type {PoolClient}
+     */
+    protected transaction: PoolClient;
+    /**
+     * A protected property representing a database of type Database<PostgresTransaction>.
+     * This property is used to interact with a Postgres database using transactions.
+     */
+    protected database: Database<PostgresTransaction>;
+    /**
+     * Constructs a new instance of the class with the provided writer, database, and optional reader.
+     * @param {Pool} writer - The writer pool for database operations.
+     * @param {PostgresDatabase} database - The Postgres database instance.
+     * @param {Pool} [reader] - The reader pool for database operations (optional).
      */
     private constructor();
     /**
-     * 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.
+     * Creates a new database transaction using the provided writer and database instances.
+     * @param {Pool} writer - The writer instance for the transaction.
+     * @param {PostgresDatabase} database - The database instance for the transaction.
+     * @param {Pool} [reader] - Optional reader instance for the transaction.
+     * @returns {Promise<PostgresTransaction>} A promise that resolves to a new PostgresTransaction instance.
+     */
+    static newTransaction(writer: Pool, database: PostgresDatabase, reader?: Pool): Promise<PostgresTransaction>;
+    /**
+     * Initiates a transaction by connecting to the writer and executing a 'BEGIN' query.
+     * @returns {Promise<void>} A promise that resolves when the transaction is successfully initiated.
      */
-    static wrapDelegate(delegate: PoolClient, database: PostgresDatabase): PostgresTransaction;
+    protected doBegin: () => Promise<import("pg").QueryResult<any>>;
     /**
-     * Commits the current transaction.
-     * @returns A promise that resolves when the commit is successful.
+     * Executes a COMMIT query to commit the current transaction.
+     * @returns A Promise that resolves when the COMMIT query is successfully executed.
      */
-    protected doCommit: () => any;
+    protected doCommit: () => Promise<import("pg").QueryResult<any>>;
     /**
-     * Performs a rollback operation in the database.
-     * @returns A promise that resolves when the rollback operation is completed.
+     * Rolls back the current transaction by executing a 'ROLLBACK' query.
+     * @returns A Promise that resolves when the rollback is successful.
      */
-    protected doRollback: () => any;
+    protected doRollback: () => Promise<import("pg").QueryResult<any>>;
 }

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

@@ -14,6 +14,42 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PostgresTransactionImpl = void 0;
 var DatabaseTransaction_1 = require("../../DatabaseTransaction");
@@ -23,37 +59,67 @@ var DatabaseTransaction_1 = require("../../DatabaseTransaction");
 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
+     * Constructs a new instance of the class with the provided writer, database, and optional reader.
+     * @param {Pool} writer - The writer pool for database operations.
+     * @param {PostgresDatabase} database - The Postgres database instance.
+     * @param {Pool} [reader] - The reader pool for database operations (optional).
      */
-    function PostgresTransactionImpl(delegate, database) {
-        var _this = _super.call(this, delegate, database) || this;
+    function PostgresTransactionImpl(writer, database, reader) {
+        var _this = _super.call(this, writer, database, reader) || this;
+        /**
+         * Initiates a transaction by connecting to the writer and executing a 'BEGIN' query.
+         * @returns {Promise<void>} A promise that resolves when the transaction is successfully initiated.
+         */
+        _this.doBegin = function () { return __awaiter(_this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = this;
+                        return [4 /*yield*/, this.writer.connect()];
+                    case 1:
+                        _a.transaction = _b.sent();
+                        return [2 /*return*/, this.transaction.query('BEGIN')];
+                }
+            });
+        }); };
         /**
-         * Commits the current transaction.
-         * @returns A promise that resolves when the commit is successful.
+         * Executes a COMMIT query to commit the current transaction.
+         * @returns A Promise that resolves when the COMMIT query is successfully executed.
          */
         _this.doCommit = function () {
-            return _this.delegate.query('COMMIT');
+            return _this.transaction.query('COMMIT');
         };
         /**
-         * Performs a rollback operation in the database.
-         * @returns A promise that resolves when the rollback operation is completed.
+         * Rolls back the current transaction by executing a 'ROLLBACK' query.
+         * @returns A Promise that resolves when the rollback is successful.
          */
         _this.doRollback = function () {
-            return _this.delegate.query('ROLLBACK');
+            return _this.transaction.query('ROLLBACK');
         };
         return _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.
+     * Creates a new database transaction using the provided writer and database instances.
+     * @param {Pool} writer - The writer instance for the transaction.
+     * @param {PostgresDatabase} database - The database instance for the transaction.
+     * @param {Pool} [reader] - Optional reader instance for the transaction.
+     * @returns {Promise<PostgresTransaction>} A promise that resolves to a new PostgresTransaction instance.
      */
-    PostgresTransactionImpl.wrapDelegate = function (delegate, database) {
-        return DatabaseTransaction_1.DatabaseTransaction.wrapInstance(new PostgresTransactionImpl(delegate, database));
+    PostgresTransactionImpl.newTransaction = function (writer, database, reader) {
+        return __awaiter(this, void 0, void 0, function () {
+            var tx;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        tx = new PostgresTransactionImpl(writer, database, reader);
+                        return [4 /*yield*/, tx.begin()]; // defaults to opened
+                    case 1:
+                        _a.sent(); // defaults to opened
+                        return [2 /*return*/, DatabaseTransaction_1.DatabaseTransaction.proxyInstance(tx)];
+                }
+            });
+        });
     };
     return PostgresTransactionImpl;
 }(DatabaseTransaction_1.DatabaseTransaction));

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

@@ -1 +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;QAClE,YAAA,MAAK,YAAC,QAAQ,EAAE,QAAQ,CAAC,SAAA;QAgB3B;;;WAGG;QACO,cAAQ,GAAG;YACnB,OAAO,KAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAA;QACtC,CAAC,CAAA;QAED;;;WAGG;QACO,gBAAU,GAAG;YACrB,OAAO,KAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,UAAU,CAAC,CAAA;QACxC,CAAC,CAAA;;IA7BD,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;IAiBH,8BAAC;AAAD,CAAC,AAvCD,CAA6C,yCAAmB,GAuC/D;AAvCY,0DAAuB"}
+{"version":3,"file":"PostgresTransaction.js","sourceRoot":"","sources":["../../../../../src/Database/integrations/pgsql/PostgresTransaction.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIA,iEAA+D;AAQ/D;;GAEG;AACH;IAA6C,2CAAmB;IAoB9D;;;;;OAKG;IACH,iCAAoB,MAAY,EAAE,QAA0B,EAAE,MAAa;QAA3E,YACE,kBAAM,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC,SAChC;QAmBD;;;WAGG;QACO,aAAO,GAAG;;;;;wBAClB,KAAA,IAAI,CAAA;wBAAe,qBAAM,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,EAAA;;wBAA9C,GAAK,WAAW,GAAG,SAA2B,CAAA;wBAC9C,sBAAO,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,OAAO,CAAC,EAAA;;;aACvC,CAAA;QAED;;;WAGG;QACO,cAAQ,GAAG;YACnB,OAAO,KAAI,CAAC,WAAW,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAA;QACzC,CAAC,CAAA;QAED;;;WAGG;QACO,gBAAU,GAAG;YACrB,OAAO,KAAI,CAAC,WAAW,CAAC,KAAK,CAAC,UAAU,CAAC,CAAA;QAC3C,CAAC,CAAA;;IA1CD,CAAC;IAED;;;;;;OAMG;IACiB,sCAAc,GAAlC,UACE,MAAY,EACZ,QAA0B,EAC1B,MAAa;;;;;;wBAEP,EAAE,GAAG,IAAI,uBAAuB,CAAC,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAA;wBAChE,qBAAM,EAAE,CAAC,KAAK,EAAE,EAAA,CAAC,qBAAqB;;wBAAtC,SAAgB,CAAA,CAAC,qBAAqB;wBACtC,sBAAO,yCAAmB,CAAC,aAAa,CAAC,EAAE,CAAQ,EAAA;;;;KACpD;IA0BH,8BAAC;AAAD,CAAC,AAvED,CAA6C,yCAAmB,GAuE/D;AAvEY,0DAAuB"}

package/dist/src/Database/types.d.ts

@@ -1,40 +1,54 @@
 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;
@@ -42,6 +56,13 @@ export type DbConfig<S extends DatabaseType> = {
     database: string;
     autoCommit: boolean;
     maxConnections: number;
+};
+export type DbConfig<S extends DatabaseType> = DbBaseConfig & {
+    type: S;
 } & (S extends 'knex' ? {
+    driver?: string;
     convertCamelToSnake?: boolean;
-} : any);
+} : unknown) & (S extends 'pg' | 'kysely' ? {
+    readReplica?: DbBaseConfig;
+} : unknown);
+export {};