@creator.co/wapi 1.3.19 → 1.4.0-alpha1

package/dist/src/Database/DatabaseTransaction.js.map

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

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

@@ -1,23 +1,37 @@
+import knex, { Knex } from 'knex';
 import { KnexTransaction } from './KnexTransaction';
 import { Database } from '../../Database';
 import type { DbConfig } from '../../types';
 /**
- * Represents a Knex database connection.
- * @extends Database<KnexTransaction>
+ * Represents a KnexDatabase class that extends Database and provides methods for interacting with a Knex database.
  */
 export declare class KnexDatabase extends Database<KnexTransaction> {
-    private static knexProvider;
-    private client;
     /**
-     * Constructs a new instance of the database class using the provided configuration.
-     * @param {DbConfig<'knex'>} config - The configuration object for the database.
+     * A static property that provides a Knex instance based on the given configuration.
+     * @param {knex.Knex.Config<any>} config - The configuration object for Knex.
+     * @returns {knex.Knex<any, unknown[]>} A Knex instance based on the provided configuration.
+     */
+    static knexProvider: (config: knex.Knex.Config<any>) => knex.Knex<any, unknown[]>;
+    /**
+     * Represents a Knex client for interacting with a database.
+     * @type {Knex}
+     */
+    readonly client: Knex;
+    /**
+     * Constructor for creating a new instance of a database connection using Knex.
+     * @param {DbConfig<'knex'>} config - The configuration object for the Knex database.
      * @returns None
      */
     constructor(config: DbConfig<'knex'>);
+    /**
+     * Constructs a Knex configuration object based on the provided DbConfig.
+     * @param {DbConfig<'knex'>} config - The database configuration object.
+     * @returns The Knex configuration object with appropriate settings based on the input config.
+     */
     private constructConfig;
     /**
-     * Initiates a transaction using the underlying database client.
-     * @returns {Promise<KnexTransaction>} A promise that resolves to a KnexTransaction object representing the transaction.
+     * Override method to start a new transaction using KnexTransactionImpl.
+     * @returns {Promise<KnexTransaction>} A promise that resolves to a KnexTransaction object.
      */
     transaction(): Promise<KnexTransaction>;
 }

package/dist/src/Database/integrations/knex/KnexDatabase.js

@@ -57,14 +57,13 @@ var knexStringcase = require("knex-stringcase");
 var KnexTransaction_1 = require("./KnexTransaction");
 var Database_1 = require("../../Database");
 /**
- * Represents a Knex database connection.
- * @extends Database<KnexTransaction>
+ * Represents a KnexDatabase class that extends Database and provides methods for interacting with a Knex database.
  */
-var KnexDatabase = /** @class */ (function (_super) {
+var KnexDatabase = exports.KnexDatabase = /** @class */ (function (_super) {
     __extends(KnexDatabase, _super);
     /**
-     * Constructs a new instance of the database class using the provided configuration.
-     * @param {DbConfig<'knex'>} config - The configuration object for the database.
+     * Constructor for creating a new instance of a database connection using Knex.
+     * @param {DbConfig<'knex'>} config - The configuration object for the Knex database.
      * @returns None
      */
     function KnexDatabase(config) {
@@ -72,6 +71,11 @@ var KnexDatabase = /** @class */ (function (_super) {
         _this.client = KnexDatabase.knexProvider(_this.constructConfig(config));
         return _this;
     }
+    /**
+     * Constructs a Knex configuration object based on the provided DbConfig.
+     * @param {DbConfig<'knex'>} config - The database configuration object.
+     * @returns The Knex configuration object with appropriate settings based on the input config.
+     */
     KnexDatabase.prototype.constructConfig = function (config) {
         var knexConfig = {
             client: config.driver,
@@ -90,24 +94,25 @@ var KnexDatabase = /** @class */ (function (_super) {
         return config.convertCamelToSnake ? knexStringcase(knexConfig) : knexConfig;
     };
     /**
-     * Initiates a transaction using the underlying database client.
-     * @returns {Promise<KnexTransaction>} A promise that resolves to a KnexTransaction object representing the transaction.
+     * Override method to start a new transaction using KnexTransactionImpl.
+     * @returns {Promise<KnexTransaction>} A promise that resolves to a KnexTransaction object.
      */
     KnexDatabase.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.transaction()];
-                    case 1:
-                        delegate = _a.sent();
-                        return [2 /*return*/, KnexTransaction_1.KnexTransactionImpl.wrapDelegate(delegate, this)];
+                    case 0: return [4 /*yield*/, KnexTransaction_1.KnexTransactionImpl.newTransaction(this.client, this)];
+                    case 1: return [2 /*return*/, _a.sent()];
                 }
             });
         });
     };
+    /**
+     * A static property that provides a Knex instance based on the given configuration.
+     * @param {knex.Knex.Config<any>} config - The configuration object for Knex.
+     * @returns {knex.Knex<any, unknown[]>} A Knex instance based on the provided configuration.
+     */
     KnexDatabase.knexProvider = knex_1.default;
     return KnexDatabase;
 }(Database_1.Database));
-exports.KnexDatabase = KnexDatabase;
 //# sourceMappingURL=KnexDatabase.js.map

package/dist/src/Database/integrations/knex/KnexDatabase.js.map

@@ -1 +1 @@
-{"version":3,"file":"KnexDatabase.js","sourceRoot":"","sources":["../../../../../src/Database/integrations/knex/KnexDatabase.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,6BAAiC;AACjC,gDAAiD;AAEjD,qDAAwE;AACxE,2CAAyC;AAGzC;;;GAGG;AACH;IAAkC,gCAAyB;IAKzD;;;;OAIG;IACH,sBAAmB,MAAwB;QACzC,YAAA,MAAK,YAAC,MAAM,CAAC,SAAA;QAEb,KAAI,CAAC,MAAM,GAAG,YAAY,CAAC,YAAY,CAAC,KAAI,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,CAAA;;IACvE,CAAC;IAEO,sCAAe,GAAvB,UAAwB,MAAwB;QAC9C,IAAM,UAAU,GAAG;YACjB,MAAM,EAAE,MAAM,CAAC,MAAM;YACrB,UAAU,EAAE;gBACV,IAAI,EAAE,MAAM,CAAC,IAAI;gBACjB,IAAI,EAAE,MAAM,CAAC,IAAI;gBACjB,IAAI,EAAE,MAAM,CAAC,QAAQ;gBACrB,QAAQ,EAAE,MAAM,CAAC,QAAQ;gBACzB,QAAQ,EAAE,MAAM,CAAC,QAAQ;aAC1B;YACD,IAAI,EAAE;gBACJ,GAAG,EAAE,CAAC;gBACN,GAAG,EAAE,MAAM,CAAC,cAAc;aAC3B;SACF,CAAA;QAED,OAAO,MAAM,CAAC,mBAAmB,CAAC,CAAC,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,UAAU,CAAA;IAC7E,CAAC;IAED;;;OAGG;IACmB,kCAAW,GAAjC;;;;;4BACmB,qBAAM,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE,EAAA;;wBAA1C,QAAQ,GAAG,SAA+B;wBAChD,sBAAO,qCAAmB,CAAC,YAAY,CAAC,QAAQ,EAAE,IAAI,CAAC,EAAA;;;;KACxD;IAzCc,yBAAY,GAAiE,cAAI,CAAA;IA0ClG,mBAAC;CAAA,AA3CD,CAAkC,mBAAQ,GA2CzC;AA3CY,oCAAY"}
+{"version":3,"file":"KnexDatabase.js","sourceRoot":"","sources":["../../../../../src/Database/integrations/knex/KnexDatabase.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,6BAAiC;AACjC,gDAAiD;AAEjD,qDAAwE;AACxE,2CAAyC;AAGzC;;GAEG;AACH;IAAkC,gCAAyB;IAazD;;;;OAIG;IACH,sBAAmB,MAAwB;QAA3C,YACE,kBAAM,MAAM,CAAC,SAGd;QADC,KAAI,CAAC,MAAM,GAAG,YAAY,CAAC,YAAY,CAAC,KAAI,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,CAAA;;IACvE,CAAC;IAED;;;;OAIG;IACK,sCAAe,GAAvB,UAAwB,MAAwB;QAC9C,IAAM,UAAU,GAAG;YACjB,MAAM,EAAE,MAAM,CAAC,MAAM;YACrB,UAAU,EAAE;gBACV,IAAI,EAAE,MAAM,CAAC,IAAI;gBACjB,IAAI,EAAE,MAAM,CAAC,IAAI;gBACjB,IAAI,EAAE,MAAM,CAAC,QAAQ;gBACrB,QAAQ,EAAE,MAAM,CAAC,QAAQ;gBACzB,QAAQ,EAAE,MAAM,CAAC,QAAQ;aAC1B;YACD,IAAI,EAAE;gBACJ,GAAG,EAAE,CAAC;gBACN,GAAG,EAAE,MAAM,CAAC,cAAc;aAC3B;SACF,CAAA;QAED,OAAO,MAAM,CAAC,mBAAmB,CAAC,CAAC,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,UAAU,CAAA;IAC7E,CAAC;IAED;;;OAGG;IACmB,kCAAW,GAAjC;;;;4BACS,qBAAM,qCAAmB,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,EAAA;4BAAlE,sBAAO,SAA2D,EAAA;;;;KACnE;IArDD;;;;OAIG;IACW,yBAAY,GAAiE,cAAI,CAAA;IAiDjG,mBAAC;CAAA,AAvDD,CAAkC,mBAAQ,GAuDzC"}

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

@@ -1,37 +1,60 @@
 import { Knex } from 'knex';
 import { KnexDatabase } from './KnexDatabase';
+import { Database } from '../../Database';
 import { DatabaseTransaction } from '../../DatabaseTransaction';
 /**
- * A type alias for a Knex transaction object.
- * @typedef {KnexTransactionImpl & Knex.Transaction} KnexTransaction
+ * Represents a Knex transaction, combining the functionality of KnexTransactionImpl
+ * and Knex.Transaction types.
  */
 export type KnexTransaction = KnexTransactionImpl & Knex.Transaction;
 /**
- * Implementation of a Knex transaction that extends the DatabaseTransaction class.
+ * Represents a Knex database transaction implementation that extends DatabaseTransaction.
+ * @class
  */
 export declare 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.
+     * The Knex instance used for writing operations.
+     * @type {Knex}
+     */
+    readonly writer: Knex;
+    /**
+     * Represents a transaction in Knex, a SQL query builder for Node.js.
+     * This property is used to perform a series of database operations as a single unit of work.
+     * @type {Knex.Transaction} - The transaction object provided by Knex.
+     */
+    protected transaction: Knex.Transaction;
+    /**
+     * A protected property representing the database connection using KnexTransaction.
+     * @type {Database<KnexTransaction>}
+     */
+    protected database: Database<KnexTransaction>;
+    /**
+     * Constructs a new instance of the class with the provided Knex writer and database.
+     * @param {Knex} writer - The Knex instance used for writing to the database.
+     * @param {KnexDatabase} database - The KnexDatabase instance used for database operations.
      * @returns None
      */
     private constructor();
     /**
-     * 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.
+     * Creates a new database transaction using the provided Knex instance and database configuration.
+     * @param {Knex} write - The Knex instance used for read and write operations.
+     * @param {KnexDatabase} database - The database configuration for the transaction.
+     * @returns {Promise<KnexTransaction>} A promise that resolves to a new database transaction.
      */
-    static wrapDelegate(delegate: Knex.Transaction, database: KnexDatabase): KnexTransaction;
+    static newTransaction(write: Knex, database: KnexDatabase): Promise<KnexTransaction>;
     /**
-     * Commits the changes made by the delegate object.
-     * @returns None
+     * Initiates a transaction using the writer and assigns it to the 'transaction' property.
+     * @returns {Promise<Transaction>} A promise that resolves to the transaction object.
      */
-    protected doCommit: () => any;
+    protected doBegin: () => Promise<Knex.Transaction<any, any[]>>;
     /**
-     * Performs a rollback operation by calling the rollback method of the delegate object.
+     * Commits the current transaction.
      * @returns None
      */
-    protected doRollback: () => any;
+    protected doCommit: () => Knex.QueryBuilder<any, any[]>;
+    /**
+     * Rollback the current transaction.
+     * @returns The result of the rollback operation.
+     */
+    protected doRollback: () => Knex.QueryBuilder<any, any[]>;
 }

package/dist/src/Database/integrations/knex/KnexTransaction.js

@@ -14,46 +14,112 @@ 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.KnexTransactionImpl = void 0;
 var DatabaseTransaction_1 = require("../../DatabaseTransaction");
 /**
- * Implementation of a Knex transaction that extends the DatabaseTransaction class.
+ * Represents a Knex database transaction implementation that extends DatabaseTransaction.
+ * @class
  */
 var KnexTransactionImpl = /** @class */ (function (_super) {
     __extends(KnexTransactionImpl, _super);
     /**
-     * Constructs a new instance of the private class.
-     * @param {Knex.Transaction} delegate - The delegate transaction object.
-     * @param {KnexDatabase} database - The database object.
+     * Constructs a new instance of the class with the provided Knex writer and database.
+     * @param {Knex} writer - The Knex instance used for writing to the database.
+     * @param {KnexDatabase} database - The KnexDatabase instance used for database operations.
      * @returns None
      */
-    function KnexTransactionImpl(delegate, database) {
-        var _this = _super.call(this, delegate, database) || this;
+    function KnexTransactionImpl(writer, database) {
+        var _this = _super.call(this, writer, database) || this;
+        /**
+         * Initiates a transaction using the writer and assigns it to the 'transaction' property.
+         * @returns {Promise<Transaction>} A promise that resolves to the transaction object.
+         */
+        _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.transaction()];
+                    case 1:
+                        _a.transaction = _b.sent();
+                        return [2 /*return*/, this.transaction];
+                }
+            });
+        }); };
         /**
-         * Commits the changes made by the delegate object.
+         * Commits the current transaction.
          * @returns None
          */
         _this.doCommit = function () {
-            return _this.delegate.commit();
+            return _this.transaction.commit();
         };
         /**
-         * Performs a rollback operation by calling the rollback method of the delegate object.
-         * @returns None
+         * Rollback the current transaction.
+         * @returns The result of the rollback operation.
          */
         _this.doRollback = function () {
-            return _this.delegate.rollback();
+            return _this.transaction.rollback();
         };
         return _this;
     }
     /**
-     * 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.
+     * Creates a new database transaction using the provided Knex instance and database configuration.
+     * @param {Knex} write - The Knex instance used for read and write operations.
+     * @param {KnexDatabase} database - The database configuration for the transaction.
+     * @returns {Promise<KnexTransaction>} A promise that resolves to a new database transaction.
      */
-    KnexTransactionImpl.wrapDelegate = function (delegate, database) {
-        return DatabaseTransaction_1.DatabaseTransaction.wrapInstance(new KnexTransactionImpl(delegate, database));
+    KnexTransactionImpl.newTransaction = function (write, database) {
+        return __awaiter(this, void 0, void 0, function () {
+            var tx;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        tx = new KnexTransactionImpl(write, database);
+                        return [4 /*yield*/, tx.begin()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, DatabaseTransaction_1.DatabaseTransaction.proxyInstance(tx)];
+                }
+            });
+        });
     };
     return KnexTransactionImpl;
 }(DatabaseTransaction_1.DatabaseTransaction));

package/dist/src/Database/integrations/knex/KnexTransaction.js.map

@@ -1 +1 @@
-{"version":3,"file":"KnexTransaction.js","sourceRoot":"","sources":["../../../../../src/Database/integrations/knex/KnexTransaction.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAGA,iEAA+D;AAQ/D;;GAEG;AACH;IAAyC,uCAAmB;IAC1D;;;;;OAKG;IACH,6BAAoB,QAA0B,EAAE,QAAsB;QACpE,YAAA,MAAK,YAAC,QAAQ,EAAE,QAAQ,CAAC,SAAA;QAa3B;;;WAGG;QACO,cAAQ,GAAG;YACnB,OAAO,KAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAA;QAC/B,CAAC,CAAA;QAED;;;WAGG;QACO,gBAAU,GAAG;YACrB,OAAO,KAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAA;QACjC,CAAC,CAAA;;IA1BD,CAAC;IAED;;;;;OAKG;IACW,gCAAY,GAA1B,UAA2B,QAA0B,EAAE,QAAsB;QAC3E,OAAO,yCAAmB,CAAC,YAAY,CAAC,IAAI,mBAAmB,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAQ,CAAA;IAC7F,CAAC;IAiBH,0BAAC;AAAD,CAAC,AApCD,CAAyC,yCAAmB,GAoC3D;AApCY,kDAAmB"}
+{"version":3,"file":"KnexTransaction.js","sourceRoot":"","sources":["../../../../../src/Database/integrations/knex/KnexTransaction.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIA,iEAA+D;AAQ/D;;;GAGG;AACH;IAAyC,uCAAmB;IAkB1D;;;;;OAKG;IACH,6BAAoB,MAAY,EAAE,QAAsB;QAAxD,YACE,kBAAM,MAAM,EAAE,QAAQ,CAAC,SACxB;QAiBD;;;WAGG;QACO,aAAO,GAAG;;;;;wBAClB,KAAA,IAAI,CAAA;wBAAe,qBAAM,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE,EAAA;;wBAAlD,GAAK,WAAW,GAAG,SAA+B,CAAA;wBAClD,sBAAO,IAAI,CAAC,WAAW,EAAA;;;aACxB,CAAA;QAED;;;WAGG;QACO,cAAQ,GAAG;YACnB,OAAO,KAAI,CAAC,WAAW,CAAC,MAAM,EAAE,CAAA;QAClC,CAAC,CAAA;QAED;;;WAGG;QACO,gBAAU,GAAG;YACrB,OAAO,KAAI,CAAC,WAAW,CAAC,QAAQ,EAAE,CAAA;QACpC,CAAC,CAAA;;IAxCD,CAAC;IAED;;;;;OAKG;IACiB,kCAAc,GAAlC,UACE,KAAW,EACX,QAAsB;;;;;;wBAEhB,EAAE,GAAG,IAAI,mBAAmB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAA;wBACnD,qBAAM,EAAE,CAAC,KAAK,EAAE,EAAA;;wBAAhB,SAAgB,CAAA;wBAChB,sBAAO,yCAAmB,CAAC,aAAa,CAAC,EAAE,CAAQ,EAAA;;;;KACpD;IA0BH,0BAAC;AAAD,CAAC,AAnED,CAAyC,yCAAmB,GAmE3D;AAnEY,kDAAmB"}

package/dist/src/Database/integrations/kysely/KyselyDatabase.d.ts

@@ -0,0 +1,55 @@
+import { Kysely, PostgresDialect } from 'kysely';
+import { Pool } from 'pg';
+import { KyselyTransaction } from './KyselyTransaction';
+import { Database } from '../../Database';
+import type { DbConfig } from '../../types';
+/**
+ * Represents a database connection using the Kysely library with support for transactions.
+ * @template DBSchema - The schema type for the database.
+ */
+export declare class KyselyDatabase<DBSchema> extends Database<KyselyTransaction<DBSchema>> {
+    /**
+     * Represents a PostgreSQL provider for querying data using the PostgresDialect.
+     * @type {PostgresDialect}
+     */
+    static kyselyPgProvider: typeof PostgresDialect;
+    /**
+     * A public static property that provides access to the Kysely class.
+     * This property can be accessed without creating an instance of the class.
+     */
+    static kyselyProvider: typeof Kysely;
+    /**
+     * A static property that represents a connection pool for PostgreSQL database connections.
+     * @type {Pool}
+     */
+    static pgProvider: typeof Pool;
+    /**
+     * Represents a PostgreSQL client using the PostgresDialect.
+     */
+    readonly pgClient: PostgresDialect;
+    /**
+     * Represents a client for querying the database with the specified schema.
+     * @type {Kysely<DBSchema>} client - The client for querying the database.
+     */
+    readonly client: Kysely<DBSchema>;
+    /**
+     * Optional property representing the Postgres dialect for reading in a database client.
+     */
+    readonly pgReadClient?: PostgresDialect;
+    /**
+     * Represents a client for reading from the database.
+     * @type {Kysely<DBSchema> | undefined} - The client for reading from the database.
+     */
+    readonly readClient?: Kysely<DBSchema>;
+    /**
+     * Constructor for creating a database connection using the provided configuration.
+     * @param {DbConfig<'kysely'>} config - The configuration object for the database connection.
+     * @returns None
+     */
+    constructor(config: DbConfig<'kysely'>);
+    /**
+     * Override method that starts a new transaction using the provided client and read client.
+     * @returns A Promise that resolves to a KyselyTransaction object for the specified database schema.
+     */
+    transaction(): Promise<KyselyTransaction<DBSchema>>;
+}

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

@@ -0,0 +1,126 @@
+"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.KyselyDatabase = void 0;
+var kysely_1 = require("kysely");
+var pg_1 = require("pg");
+var KyselyTransaction_1 = require("./KyselyTransaction");
+var Database_1 = require("../../Database");
+/**
+ * Represents a database connection using the Kysely library with support for transactions.
+ * @template DBSchema - The schema type for the database.
+ */
+var KyselyDatabase = exports.KyselyDatabase = /** @class */ (function (_super) {
+    __extends(KyselyDatabase, _super);
+    /**
+     * Constructor for creating a database connection using the provided configuration.
+     * @param {DbConfig<'kysely'>} config - The configuration object for the database connection.
+     * @returns None
+     */
+    function KyselyDatabase(config) {
+        var _this = _super.call(this, config) || this;
+        _this.pgClient = new KyselyDatabase.kyselyPgProvider({
+            pool: new KyselyDatabase.pgProvider({
+                host: config.host,
+                port: config.port,
+                user: config.username,
+                password: config.password,
+                database: config.database,
+                max: config.maxConnections,
+            }),
+        });
+        _this.client = new KyselyDatabase.kyselyProvider({ dialect: _this.pgClient });
+        if (config.readReplica) {
+            _this.pgReadClient = new KyselyDatabase.kyselyPgProvider({
+                pool: new KyselyDatabase.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,
+                }),
+            });
+            _this.readClient = new KyselyDatabase.kyselyProvider({ dialect: _this.pgReadClient });
+        }
+        return _this;
+    }
+    /**
+     * Override method that starts a new transaction using the provided client and read client.
+     * @returns A Promise that resolves to a KyselyTransaction object for the specified database schema.
+     */
+    KyselyDatabase.prototype.transaction = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, KyselyTransaction_1.KyselyTransactionImpl.newTransaction(this.client, this, this.readClient)];
+            });
+        });
+    };
+    /**
+     * Represents a PostgreSQL provider for querying data using the PostgresDialect.
+     * @type {PostgresDialect}
+     */
+    KyselyDatabase.kyselyPgProvider = kysely_1.PostgresDialect;
+    /**
+     * A public static property that provides access to the Kysely class.
+     * This property can be accessed without creating an instance of the class.
+     */
+    KyselyDatabase.kyselyProvider = kysely_1.Kysely;
+    /**
+     * A static property that represents a connection pool for PostgreSQL database connections.
+     * @type {Pool}
+     */
+    KyselyDatabase.pgProvider = pg_1.Pool;
+    return KyselyDatabase;
+}(Database_1.Database));
+//# sourceMappingURL=KyselyDatabase.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"KyselyDatabase.js","sourceRoot":"","sources":["../../../../../src/Database/integrations/kysely/KyselyDatabase.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,iCAAgD;AAChD,yBAAyB;AAEzB,yDAA8E;AAC9E,2CAAyC;AAGzC;;;GAGG;AACH;IAA8C,kCAAqC;IAmCjF;;;;OAIG;IACH,wBAAmB,MAA0B;QAA7C,YACE,kBAAM,MAAM,CAAC,SAyBd;QAxBC,KAAI,CAAC,QAAQ,GAAG,IAAI,cAAc,CAAC,gBAAgB,CAAC;YAClD,IAAI,EAAE,IAAI,cAAc,CAAC,UAAU,CAAC;gBAClC,IAAI,EAAE,MAAM,CAAC,IAAI;gBACjB,IAAI,EAAE,MAAM,CAAC,IAAI;gBACjB,IAAI,EAAE,MAAM,CAAC,QAAQ;gBACrB,QAAQ,EAAE,MAAM,CAAC,QAAQ;gBACzB,QAAQ,EAAE,MAAM,CAAC,QAAQ;gBACzB,GAAG,EAAE,MAAM,CAAC,cAAc;aAC3B,CAAC;SACH,CAAC,CAAA;QACF,KAAI,CAAC,MAAM,GAAG,IAAI,cAAc,CAAC,cAAc,CAAW,EAAE,OAAO,EAAE,KAAI,CAAC,QAAQ,EAAE,CAAC,CAAA;QACrF,IAAI,MAAM,CAAC,WAAW,EAAE;YACtB,KAAI,CAAC,YAAY,GAAG,IAAI,cAAc,CAAC,gBAAgB,CAAC;gBACtD,IAAI,EAAE,IAAI,cAAc,CAAC,UAAU,CAAC;oBAClC,IAAI,EAAE,MAAM,CAAC,WAAW,CAAC,IAAI;oBAC7B,IAAI,EAAE,MAAM,CAAC,WAAW,CAAC,IAAI;oBAC7B,IAAI,EAAE,MAAM,CAAC,WAAW,CAAC,QAAQ;oBACjC,QAAQ,EAAE,MAAM,CAAC,WAAW,CAAC,QAAQ;oBACrC,QAAQ,EAAE,MAAM,CAAC,WAAW,CAAC,QAAQ;oBACrC,GAAG,EAAE,MAAM,CAAC,WAAW,CAAC,cAAc;iBACvC,CAAC;aACH,CAAC,CAAA;YACF,KAAI,CAAC,UAAU,GAAG,IAAI,cAAc,CAAC,cAAc,CAAW,EAAE,OAAO,EAAE,KAAI,CAAC,YAAY,EAAE,CAAC,CAAA;SAC9F;;IACH,CAAC;IAED;;;OAGG;IACmB,oCAAW,GAAjC;;;gBACE,sBAAO,yCAAqB,CAAC,cAAc,CAAW,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,UAAU,CAAC,EAAA;;;KAC1F;IAzED;;;OAGG;IACW,+BAAgB,GAAG,wBAAe,CAAA;IAChD;;;OAGG;IACW,6BAAc,GAAG,eAAM,CAAA;IACrC;;;OAGG;IACW,yBAAU,GAAG,SAAI,CAAA;IA4DjC,qBAAC;CAAA,AA3ED,CAA8C,mBAAQ,GA2ErD"}

package/dist/src/Database/integrations/kysely/KyselyTransaction.d.ts

@@ -0,0 +1,70 @@
+import { Kysely, Transaction } from 'kysely';
+import { KyselyDatabase } from './KyselyDatabase';
+import { Database } from '../../Database';
+import { DatabaseTransaction } from '../../DatabaseTransaction';
+/**
+ * Represents a transaction for querying a database with a specific schema.
+ * @typeparam DBSchema - The schema of the database.
+ * @type {KyselyTransactionImpl<DBSchema> & Transaction<DBSchema>}
+ */
+export type KyselyTransaction<DBSchema> = KyselyTransactionImpl<DBSchema> & Transaction<DBSchema>;
+/**
+ * Represents a transaction in a Postgres database.
+ */
+export declare class KyselyTransactionImpl<DBSchema> extends DatabaseTransaction {
+    /**
+     * A readonly property representing a writer for a Kysely object.
+     * @type {Kysely<any>}
+     */
+    readonly writer: Kysely<any>;
+    /**
+     * A readonly property representing a reader of type Kysely<any>.
+     * This property allows reading data of any type using the Kysely interface.
+     */
+    readonly reader: Kysely<any>;
+    /**
+     * A protected property representing a transaction of type any.
+     */
+    protected transaction: Transaction<any>;
+    /**
+     * A protected property representing a database instance.
+     * @type {Database<KyselyTransaction<DBSchema>>}
+     */
+    protected database: Database<KyselyTransaction<DBSchema>>;
+    /**
+     * A private property that represents a deferred object.
+     * @type {Deferred<any>}
+     */
+    private txWrapper;
+    /**
+     * 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
+     */
+    private constructor();
+    /**
+     * 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.
+     */
+    static newTransaction<DBSchema>(connection: Kysely<DBSchema>, database: KyselyDatabase<DBSchema>, reader?: Kysely<DBSchema>): Promise<KyselyTransaction<DBSchema>>;
+    /**
+     * 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.
+     */
+    protected doBegin: () => Promise<unknown>;
+    /**
+     * Executes the commit operation by resolving the transaction wrapper and returning a resolved Promise.
+     * @returns A Promise that resolves to null.
+     */
+    protected doCommit: () => Promise<void>;
+    /**
+     * Performs a rollback operation by rejecting the transaction wrapper with an error.
+     * @returns A resolved Promise after the rollback operation is completed.
+     */
+    protected doRollback: () => Promise<void>;
+}