@creator.co/wapi 1.2.3 → 1.2.5

package/dist/src/Crypto/JWT.d.ts

@@ -0,0 +1,64 @@
+import * as jwt from 'jsonwebtoken';
+/**
+ * ${1:Description placeholder}
+ *
+ * @typedef {JWTValidationResponse}
+ */
+type JWTValidationResponse = {
+    isValid: true;
+    decodedToken: jwt.JwtPayload;
+} | {
+    isValid: false;
+    isExpired?: boolean;
+};
+/**
+ * ${1:Description placeholder}
+ *
+ * @export
+ * @class JWT
+ * @typedef {JWT}
+ */
+export default class JWT {
+    /**
+     * ${1:Description placeholder}
+     *
+     * @private
+     * @readonly
+     * @type {string}
+     */
+    private readonly tokenSecret;
+    /**
+     * ${1:Description placeholder}
+     *
+     * @private
+     * @readonly
+     * @type {string}
+     */
+    private readonly defaultExpiration;
+    /**
+     * Creates an instance of JWT.
+     *
+     * @constructor
+     * @param {string} tokenSecret
+     * @param {?string} [defaultExpiration]
+     */
+    constructor(tokenSecret: string, defaultExpiration?: string);
+    /**
+     * ${1:Description placeholder}
+     *
+     * @param {object} data
+     * @param {?string} [expiration]
+     * @param {?string} [overrideToken]
+     * @param {?*} [opts]
+     * @returns {string}
+     */
+    createToken(data: object, expiration?: string, overrideToken?: string, opts?: any): string;
+    /**
+     * ${1:Description placeholder}
+     *
+     * @param {string} token
+     * @returns {JWTValidationResponse}
+     */
+    validateToken(token: string): JWTValidationResponse;
+}
+export {};

package/dist/src/Crypto/JWT.js

@@ -0,0 +1,74 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var jwt = require("jsonwebtoken");
+/**
+ * ${1:Description placeholder}
+ *
+ * @export
+ * @class JWT
+ * @typedef {JWT}
+ */
+var JWT = /** @class */ (function () {
+    /**
+     * Creates an instance of JWT.
+     *
+     * @constructor
+     * @param {string} tokenSecret
+     * @param {?string} [defaultExpiration]
+     */
+    function JWT(tokenSecret, defaultExpiration) {
+        this.tokenSecret = tokenSecret;
+        this.defaultExpiration = defaultExpiration;
+    }
+    //
+    /**
+     * ${1:Description placeholder}
+     *
+     * @param {object} data
+     * @param {?string} [expiration]
+     * @param {?string} [overrideToken]
+     * @param {?*} [opts]
+     * @returns {string}
+     */
+    JWT.prototype.createToken = function (data, expiration, overrideToken, opts) {
+        var exp = expiration || this.defaultExpiration;
+        return jwt.sign(data, overrideToken || this.tokenSecret, exp ? __assign({ expiresIn: exp }, (opts || {})) : opts || {});
+    };
+    /**
+     * ${1:Description placeholder}
+     *
+     * @param {string} token
+     * @returns {JWTValidationResponse}
+     */
+    JWT.prototype.validateToken = function (token) {
+        try {
+            // Check if is valid
+            var isValid = jwt.verify(token, this.tokenSecret);
+            if (isValid) {
+                var payload = jwt.decode(token, { json: true });
+                if (payload)
+                    return { isValid: true, decodedToken: payload };
+            }
+        }
+        catch (err) {
+            console.error(err);
+            if (err instanceof jwt.TokenExpiredError)
+                return { isValid: false, isExpired: true };
+        }
+        return { isValid: false };
+    };
+    return JWT;
+}());
+exports.default = JWT;
+//# sourceMappingURL=JWT.js.map

package/dist/src/Crypto/JWT.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"JWT.js","sourceRoot":"","sources":["../../../src/Crypto/JWT.ts"],"names":[],"mappings":";;;;;;;;;;;;;AAAA,kCAAmC;AAcnC;;;;;;GAMG;AACH;IAiBE;;;;;;OAMG;IACH,aAAY,WAAmB,EAAE,iBAA0B;QACzD,IAAI,CAAC,WAAW,GAAG,WAAW,CAAA;QAC9B,IAAI,CAAC,iBAAiB,GAAG,iBAAiB,CAAA;IAC5C,CAAC;IACD,EAAE;IACF;;;;;;;;OAQG;IACH,yBAAW,GAAX,UAAY,IAAY,EAAE,UAAmB,EAAE,aAAsB,EAAE,IAAU;QAC/E,IAAM,GAAG,GAAG,UAAU,IAAI,IAAI,CAAC,iBAAiB,CAAA;QAChD,OAAO,GAAG,CAAC,IAAI,CACb,IAAI,EACJ,aAAa,IAAI,IAAI,CAAC,WAAW,EACjC,GAAG,CAAC,CAAC,YAAG,SAAS,EAAE,GAAG,IAAK,CAAC,IAAI,IAAI,EAAE,CAAC,EAAG,CAAC,CAAC,IAAI,IAAI,EAAE,CACvD,CAAA;IACH,CAAC;IACD;;;;;OAKG;IACH,2BAAa,GAAb,UAAc,KAAa;QACzB,IAAI;YACF,oBAAoB;YACpB,IAAM,OAAO,GAAG,GAAG,CAAC,MAAM,CAAC,KAAK,EAAE,IAAI,CAAC,WAAW,CAAC,CAAA;YACnD,IAAI,OAAO,EAAE;gBACX,IAAM,OAAO,GAAG,GAAG,CAAC,MAAM,CAAC,KAAK,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAA;gBACjD,IAAI,OAAO;oBAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,YAAY,EAAE,OAAO,EAAE,CAAA;aAC7D;SACF;QAAC,OAAO,GAAG,EAAE;YACZ,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;YAClB,IAAI,GAAG,YAAY,GAAG,CAAC,iBAAiB;gBAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,CAAA;SACrF;QACD,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,CAAA;IAC3B,CAAC;IACH,UAAC;AAAD,CAAC,AAlED,IAkEC"}

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

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

package/dist/src/Database/Database.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Database = void 0;
+/**
+ * Abstract class representing a database.
+ * @template T - The type of database transaction.
+ */
+var Database = /** @class */ (function () {
+    /**
+     * Creates a database instance, maintaining a reference to the database configuration.
+     */
+    function Database(config) {
+        this.config = config;
+    }
+    return Database;
+}());
+exports.Database = Database;
+//# sourceMappingURL=Database.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Database.js","sourceRoot":"","sources":["../../../src/Database/Database.ts"],"names":[],"mappings":";;;AAGA;;;GAGG;AACH;IACE;;OAEG;IACH,kBAAsC,MAAqB;QAArB,WAAM,GAAN,MAAM,CAAe;IAAG,CAAC;IAOjE,eAAC;AAAD,CAAC,AAXD,IAWC;AAXqB,4BAAQ"}

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

@@ -0,0 +1,32 @@
+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 declare const DATABASES: {
+    knex: typeof KnexDatabase;
+    pg: typeof PostgresDatabase;
+};
+/**
+ * A class that manages databases and provides methods for creating and accessing database instances.
+ */
+export declare class DatabaseManager {
+    /**
+     * The singleton instance of the DatabaseManager class.
+     */
+    static readonly INSTANCE: DatabaseManager;
+    private databases;
+    private instances;
+    /**
+     * 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.
+     */
+    create<S extends DatabaseType>(config: DbConfig<S>): DatabaseImplType<S>;
+    private instantiateDb;
+}

package/dist/src/Database/DatabaseManager.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseManager = exports.DATABASES = void 0;
+var hash = require("object-hash");
+var KnexDatabase_1 = require("./integrations/knex/KnexDatabase");
+var PostgresDatabase_1 = require("./integrations/pgsql/PostgresDatabase");
+/**
+ * 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.
+ */
+exports.DATABASES = {
+    knex: KnexDatabase_1.KnexDatabase,
+    pg: PostgresDatabase_1.PostgresDatabase,
+};
+/**
+ * A class that manages databases and provides methods for creating and accessing database instances.
+ */
+var DatabaseManager = /** @class */ (function () {
+    function DatabaseManager() {
+        this.databases = exports.DATABASES;
+        this.instances = {};
+    }
+    /**
+     * 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.
+     */
+    DatabaseManager.prototype.create = function (config) {
+        var configHash = hash(config);
+        if (this.instances[configHash]) {
+            return this.instances[configHash];
+        }
+        var instance = this.instantiateDb(config);
+        this.instances[configHash] = instance;
+        return instance;
+    };
+    DatabaseManager.prototype.instantiateDb = function (config) {
+        return new this.databases[config.type](config);
+    };
+    /**
+     * The singleton instance of the DatabaseManager class.
+     */
+    DatabaseManager.INSTANCE = new DatabaseManager();
+    return DatabaseManager;
+}());
+exports.DatabaseManager = DatabaseManager;
+//# sourceMappingURL=DatabaseManager.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DatabaseManager.js","sourceRoot":"","sources":["../../../src/Database/DatabaseManager.ts"],"names":[],"mappings":";;;AAAA,kCAAmC;AAEnC,iEAA+D;AAC/D,0EAAwE;AAGxE;;;;;GAKG;AACU,QAAA,SAAS,GAAG;IACvB,IAAI,EAAE,2BAAY;IAClB,EAAE,EAAE,mCAAgB;CACrB,CAAA;AAED;;GAEG;AACH;IAAA;QAKU,cAAS,GAAqB,iBAAS,CAAA;QAEvC,cAAS,GAA2C,EAAE,CAAA;IAuBhE,CAAC;IArBC;;;;;OAKG;IACI,gCAAM,GAAb,UAAsC,MAAmB;QACvD,IAAM,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC,CAAA;QAC/B,IAAI,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE;YAC9B,OAAO,IAAI,CAAC,SAAS,CAAC,UAAU,CAAQ,CAAA;SACzC;QACD,IAAM,QAAQ,GAAG,IAAI,CAAC,aAAa,CAAC,MAAa,CAAC,CAAA;QAClD,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,GAAG,QAAQ,CAAA;QACrC,OAAO,QAAe,CAAA;IACxB,CAAC;IAEO,uCAAa,GAArB,UACE,MAAyC;QAEzC,OAAO,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,MAAa,CAAC,CAAA;IACvD,CAAC;IA5BD;;OAEG;IACoB,wBAAQ,GAAG,IAAI,eAAe,EAAE,AAAxB,CAAwB;IA0BzD,sBAAC;CAAA,AA9BD,IA8BC;AA9BY,0CAAe"}

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

@@ -0,0 +1,65 @@
+import { Database } from './Database';
+/**
+ * Abstract class representing a database transaction.
+ * @class DatabaseTransaction
+ */
+export declare abstract class DatabaseTransaction {
+    private _isOpen;
+    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.
+     */
+    get isOpen(): boolean;
+    /**
+     * 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>);
+    /**
+     * 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;
+    /**
+     * Commits the transaction.
+     * @throws {Error} - If the transaction is already closed.
+     * @returns None
+     */
+    commit(): Promise<void>;
+    /**
+     * Rollbacks the current transaction.
+     * @throws {Error} - If the transaction is already closed.
+     * @returns {Promise<void>} - A promise that resolves once the rollback is complete.
+     */
+    rollback(): Promise<void>;
+    /**
+     * Closes the transaction after a successful execution.
+     * @returns {Promise<void>} - A promise that resolves once the necessary actions are completed.
+     */
+    closeSuccess(): Promise<void>;
+    /**
+     * Closes the transaction after a failed execution.
+     * @returns {Promise<void>} - A promise that resolves once the necessary actions are completed.
+     */
+    closeFailure(): Promise<void>;
+    /**
+     * 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/dist/src/Database/DatabaseTransaction.js

@@ -0,0 +1,183 @@
+"use strict";
+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.DatabaseTransaction = void 0;
+/**
+ * Abstract class representing a database transaction.
+ * @class DatabaseTransaction
+ */
+var DatabaseTransaction = /** @class */ (function () {
+    /**
+     * Constructs a new instance of the class.
+     * @param {any} delegate - The delegate object.
+     * @param {Database<any>} database - The database object.
+     * @protected
+     */
+    function DatabaseTransaction(delegate, database) {
+        this._isOpen = true;
+        this.delegate = delegate;
+        this.database = database;
+    }
+    Object.defineProperty(DatabaseTransaction.prototype, "isOpen", {
+        /**
+         * Returns a boolean value indicating whether the transaction is open or not.
+         * @returns {boolean} - true if the object is open, false otherwise.
+         */
+        get: function () {
+            return this._isOpen;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * 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.
+     */
+    DatabaseTransaction.wrapInstance = function (subclass) {
+        var bind = function (target, key) {
+            return typeof target[key] === 'function' ? target[key].bind(target) : target[key];
+        };
+        return new Proxy(subclass, {
+            get: function (target, p) {
+                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
+     */
+    DatabaseTransaction.prototype.commit = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this._isOpen) {
+                            throw new Error('Cannot commit, transaction is already closed!');
+                        }
+                        return [4 /*yield*/, this.doCommit()];
+                    case 1:
+                        _a.sent();
+                        this._isOpen = false;
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Rollbacks the current transaction.
+     * @throws {Error} - If the transaction is already closed.
+     * @returns {Promise<void>} - A promise that resolves once the rollback is complete.
+     */
+    DatabaseTransaction.prototype.rollback = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this._isOpen) {
+                            throw new Error('Cannot rollback, transaction is already closed!');
+                        }
+                        return [4 /*yield*/, this.doRollback()];
+                    case 1:
+                        _a.sent();
+                        this._isOpen = false;
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Closes the transaction after a successful execution.
+     * @returns {Promise<void>} - A promise that resolves once the necessary actions are completed.
+     */
+    DatabaseTransaction.prototype.closeSuccess = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this._isOpen) return [3 /*break*/, 4];
+                        if (!this.database.config.autoCommit) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.doCommit()];
+                    case 1:
+                        _a.sent();
+                        return [3 /*break*/, 4];
+                    case 2: return [4 /*yield*/, this.doRollback()];
+                    case 3:
+                        _a.sent();
+                        _a.label = 4;
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Closes the transaction after a failed execution.
+     * @returns {Promise<void>} - A promise that resolves once the necessary actions are completed.
+     */
+    DatabaseTransaction.prototype.closeFailure = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this._isOpen) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.doRollback()];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return DatabaseTransaction;
+}());
+exports.DatabaseTransaction = DatabaseTransaction;
+//# sourceMappingURL=DatabaseTransaction.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DatabaseTransaction.js","sourceRoot":"","sources":["../../../src/Database/DatabaseTransaction.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA;;;GAGG;AACH;IAaE;;;;;OAKG;IACH,6BAAsB,QAAa,EAAE,QAAuB;QAlBpD,YAAO,GAAY,IAAI,CAAA;QAmB7B,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAA;QACxB,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAA;IAC1B,CAAC;IAbD,sBAAW,uCAAM;QAJjB;;;WAGG;aACH;YACE,OAAO,IAAI,CAAC,OAAO,CAAA;QACrB,CAAC;;;OAAA;IAaD;;;;;;;;;OASG;IACc,gCAAY,GAA7B,UAA6D,QAAW;QACtE,IAAM,IAAI,GAAG,UAAC,MAAW,EAAE,GAAoB;YAC7C,OAAA,OAAO,MAAM,CAAC,GAAG,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC;QAA1E,CAA0E,CAAA;QAE5E,OAAO,IAAI,KAAK,CAAI,QAAQ,EAAE;YAC5B,GAAG,YAAC,MAAS,EAAE,CAAkB;gBAC/B,IAAI,MAAM,CAAC,CAAC,CAAC,KAAK,SAAS,EAAE;oBAC3B,OAAO,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC,CAAA;iBACvB;qBAAM,IAAI,MAAM,CAAC,OAAO,EAAE;oBACzB,OAAO,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAA;iBAChC;gBACD,OAAO,SAAS,CAAA;YAClB,CAAC;SACF,CAAC,CAAA;IACJ,CAAC;IAED;;;;OAIG;IACU,oCAAM,GAAnB;;;;;wBACE,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE;4BACjB,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAA;yBACjE;wBACD,qBAAM,IAAI,CAAC,QAAQ,EAAE,EAAA;;wBAArB,SAAqB,CAAA;wBACrB,IAAI,CAAC,OAAO,GAAG,KAAK,CAAA;;;;;KACrB;IAED;;;;OAIG;IACU,sCAAQ,GAArB;;;;;wBACE,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE;4BACjB,MAAM,IAAI,KAAK,CAAC,iDAAiD,CAAC,CAAA;yBACnE;wBACD,qBAAM,IAAI,CAAC,UAAU,EAAE,EAAA;;wBAAvB,SAAuB,CAAA;wBACvB,IAAI,CAAC,OAAO,GAAG,KAAK,CAAA;;;;;KACrB;IAED;;;OAGG;IACU,0CAAY,GAAzB;;;;;6BACM,IAAI,CAAC,OAAO,EAAZ,wBAAY;6BACV,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,UAAU,EAA/B,wBAA+B;wBACjC,qBAAM,IAAI,CAAC,QAAQ,EAAE,EAAA;;wBAArB,SAAqB,CAAA;;4BAErB,qBAAM,IAAI,CAAC,UAAU,EAAE,EAAA;;wBAAvB,SAAuB,CAAA;;;;;;KAG5B;IAED;;;OAGG;IACU,0CAAY,GAAzB;;;;;6BACM,IAAI,CAAC,OAAO,EAAZ,wBAAY;wBACd,qBAAM,IAAI,CAAC,UAAU,EAAE,EAAA;;wBAAvB,SAAuB,CAAA;;;;;;KAE1B;IAaH,0BAAC;AAAD,CAAC,AA/GD,IA+GC;AA/GqB,kDAAmB"}

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

@@ -0,0 +1,22 @@
+import { KnexTransaction } from './KnexTransaction';
+import { Database } from '../../Database';
+import type { DbConfig } from '../../types';
+/**
+ * Represents a Knex database connection.
+ * @extends Database<KnexTransaction>
+ */
+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.
+     * @returns None
+     */
+    constructor(config: DbConfig<'knex'>);
+    /**
+     * Initiates a transaction using the underlying database client.
+     * @returns {Promise<KnexTransaction>} A promise that resolves to a KnexTransaction object representing the transaction.
+     */
+    transaction(): Promise<KnexTransaction>;
+}

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

@@ -0,0 +1,108 @@
+"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.KnexDatabase = void 0;
+var knex_1 = require("knex");
+var KnexTransaction_1 = require("./KnexTransaction");
+var Database_1 = require("../../Database");
+/**
+ * Represents a Knex database connection.
+ * @extends Database<KnexTransaction>
+ */
+var 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.
+     * @returns None
+     */
+    function KnexDatabase(config) {
+        var _this = _super.call(this, config) || this;
+        _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,
+            },
+        });
+        return _this;
+    }
+    /**
+     * Initiates a transaction using the underlying database client.
+     * @returns {Promise<KnexTransaction>} A promise that resolves to a KnexTransaction object representing the transaction.
+     */
+    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)];
+                }
+            });
+        });
+    };
+    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

@@ -0,0 +1 @@
+{"version":3,"file":"KnexDatabase.js","sourceRoot":"","sources":["../../../../../src/Database/integrations/knex/KnexDatabase.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,6BAAiC;AAEjC,qDAAwE;AACxE,2CAAyC;AAGzC;;;GAGG;AACH;IAAkC,gCAAyB;IAKzD;;;;OAIG;IACH,sBAAmB,MAAwB;QAA3C,YACE,kBAAM,MAAM,CAAC,SAed;QAdC,KAAI,CAAC,MAAM,GAAG,YAAY,CAAC,YAAY,CAAC;YACtC,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,CAAC,CAAA;;IACJ,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;IAlCc,yBAAY,GAAiE,cAAI,CAAA;IAmClG,mBAAC;CAAA,AApCD,CAAkC,mBAAQ,GAoCzC;AApCY,oCAAY"}