@ikonintegration/ikapi 4.0.1 → 5.0.0

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

@@ -0,0 +1,66 @@
+import { Kysely } from 'kysely';
+import { KyselyTransaction } from './KyselyTransaction.js';
+import { Database } from '../../Database.js';
+import type { DbConfig } from '../../types.js';
+/**
+ * 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 = never> extends Database<KyselyTransaction<DBSchema>> {
+    /**
+     * Represents a PostgreSQL provider for querying data using the PostgresDialect.
+     * @type {PostgresDialect}
+     */
+    private static kyselyPgProvider;
+    /**
+     * A public static property that provides access to the Kysely class.
+     * This property can be accessed without creating an instance of the class.
+     */
+    private static kyselyProvider;
+    /**
+     * A static property that represents a connection pool for PostgreSQL database connections.
+     * @type {Pool}
+     */
+    private static pgProvider;
+    /**
+     * Represents a PostgreSQL client using the PostgresDialect.
+     */
+    private readonly pgClient;
+    /**
+     * 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.
+     */
+    private readonly pgReadClient?;
+    /**
+     * 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>>;
+    /**
+     * Creates a database dialect based on the provided configuration.
+     * @param {DbBaseConfig} config - The configuration object for the database connection.
+     * @returns A database dialect instance based on the provided configuration.
+     */
+    private dialectFactory;
+    /**
+     * Creates a provider for interacting with a database using the specified Postgres dialect.
+     * @param {PostgresDialect} dialect - The Postgres dialect to use for the database connection.
+     * @returns A database provider for interacting with the database.
+     */
+    private providerFactory;
+}

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

@@ -0,0 +1,86 @@
+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());
+    });
+};
+import { CamelCasePlugin, Kysely, PostgresDialect } from 'kysely';
+import pg from 'pg';
+import { KyselyTransactionImpl } from './KyselyTransaction.js';
+import { Database } from '../../Database.js';
+/**
+ * Represents a database connection using the Kysely library with support for transactions.
+ * @template DBSchema - The schema type for the database.
+ */
+export class KyselyDatabase extends Database {
+    /**
+     * 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) {
+        super(config);
+        this.pgClient = this.dialectFactory(config);
+        this.client = this.providerFactory(this.pgClient);
+        if (config.readReplica) {
+            this.pgReadClient = this.dialectFactory(config.readReplica);
+            this.readClient = this.providerFactory(this.pgReadClient);
+        }
+    }
+    /**
+     * 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() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return KyselyTransactionImpl.newTransaction(this.client, this, this.readClient);
+        });
+    }
+    /**
+     * Creates a database dialect based on the provided configuration.
+     * @param {DbBaseConfig} config - The configuration object for the database connection.
+     * @returns A database dialect instance based on the provided configuration.
+     */
+    dialectFactory(config) {
+        return 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,
+            }),
+        });
+    }
+    /**
+     * Creates a provider for interacting with a database using the specified Postgres dialect.
+     * @param {PostgresDialect} dialect - The Postgres dialect to use for the database connection.
+     * @returns A database provider for interacting with the database.
+     */
+    providerFactory(dialect) {
+        return new KyselyDatabase.kyselyProvider({
+            dialect,
+            plugins: [new CamelCasePlugin()],
+        });
+    }
+}
+/**
+ * Represents a PostgreSQL provider for querying data using the PostgresDialect.
+ * @type {PostgresDialect}
+ */
+KyselyDatabase.kyselyPgProvider = 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;
+/**
+ * A static property that represents a connection pool for PostgreSQL database connections.
+ * @type {Pool}
+ */
+KyselyDatabase.pgProvider = pg.Pool;
+//# 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,OAAO,EAAE,eAAe,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAA;AACjE,OAAO,EAAE,MAAM,IAAI,CAAA;AAEnB,OAAO,EAAqB,qBAAqB,EAAE,MAAM,wBAAwB,CAAA;AACjF,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AAG5C;;;GAGG;AACH,MAAM,OAAO,cAAiC,SAAQ,QAAqC;IAmCzF;;;;OAIG;IACH,YAAY,MAA0B;QACpC,KAAK,CAAC,MAAM,CAAC,CAAA;QACb,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,CAAA;QAC3C,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;QACjD,IAAI,MAAM,CAAC,WAAW,EAAE,CAAC;YACvB,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,WAAW,CAAC,CAAA;YAC3D,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,YAAY,CAAC,CAAA;QAC3D,CAAC;IACH,CAAC;IAED;;;OAGG;IACmB,WAAW;;YAC/B,OAAO,qBAAqB,CAAC,cAAc,CAAW,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,UAAU,CAAC,CAAA;QAC3F,CAAC;KAAA;IAED;;;;OAIG;IACK,cAAc,CAAC,MAAoB;QACzC,OAAO,IAAI,cAAc,CAAC,gBAAgB,CAAC;YACzC,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;IACJ,CAAC;IAED;;;;OAIG;IACK,eAAe,CAAC,OAAwB;QAC9C,OAAO,IAAI,cAAc,CAAC,cAAc,CAAW;YACjD,OAAO;YACP,OAAO,EAAE,CAAC,IAAI,eAAe,EAAE,CAAC;SACjC,CAAC,CAAA;IACJ,CAAC;;AArFD;;;GAGG;AACY,+BAAgB,GAAG,eAAe,CAAA;AACjD;;;GAGG;AACY,6BAAc,GAAG,MAAM,CAAA;AACtC;;;GAGG;AACY,yBAAU,GAAG,EAAE,CAAC,IAAI,CAAA"}

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

@@ -0,0 +1,70 @@
+import { Kysely, Transaction } from 'kysely';
+import { KyselyDatabase } from './KyselyDatabase.js';
+import { Database } from '../../Database.js';
+import { DatabaseTransaction } from '../../DatabaseTransaction.js';
+/**
+ * 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>;
+}

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

@@ -0,0 +1,118 @@
+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());
+    });
+};
+import { DatabaseTransaction } from '../../DatabaseTransaction.js';
+/**
+ * Represents a transaction in a Postgres database.
+ */
+export class KyselyTransactionImpl extends DatabaseTransaction {
+    /**
+     * 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
+     */
+    constructor(delegate, database, reader) {
+        super(delegate, database, reader);
+        /**
+         * 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 = () => __awaiter(this, void 0, void 0, function* () {
+            this.txWrapper = new Deferred();
+            return new Promise(resolve => {
+                this.writer
+                    .transaction()
+                    .execute((trx) => __awaiter(this, void 0, void 0, function* () {
+                    this.transaction = trx;
+                    resolve(trx); // resolve with tx
+                    return this.txWrapper.promise; // wait for wrapper to be solved
+                }))
+                    .catch(() => {
+                    // 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 = () => {
+            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 = () => {
+            this.txWrapper.reject(new Error('Rollback'));
+            return Promise.resolve();
+        };
+    }
+    /**
+     * 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(connection, database, reader) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tx = new KyselyTransactionImpl(connection, database, reader);
+            yield tx.begin();
+            return DatabaseTransaction.proxyInstance(tx);
+        });
+    }
+}
+/**
+ * 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.
+ */
+class Deferred {
+    /**
+     * Constructor for creating a new Promise instance with resolve and reject functions.
+     * @constructor
+     */
+    constructor() {
+        this._promise = new Promise((resolve, reject) => {
+            this._reject = reject;
+            this._resolve = resolve;
+        });
+    }
+    /**
+     * Getter method to retrieve the Promise object.
+     * @returns {Promise<T>} A Promise object of type T.
+     */
+    get promise() {
+        return this._promise;
+    }
+    /**
+     * Resolves the Promise with the given value.
+     * @param {T | PromiseLike<T>} value - The value to resolve the Promise with.
+     * @returns void
+     */
+    resolve(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
+     */
+    reject(reason) {
+        if (this._reject) {
+            this._reject(reason);
+        }
+    }
+}
+//# 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,OAAO,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAA;AAQlE;;GAEG;AACH,MAAM,OAAO,qBAAgC,SAAQ,mBAAmB;IAyBtE;;;;;;OAMG;IACH,YACE,QAA0B,EAC1B,QAAkC,EAClC,MAAyB;QAEzB,KAAK,CAAC,QAAQ,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAA;QAoBnC;;;WAGG;QACO,YAAO,GAAG,GAAS,EAAE;YAC7B,IAAI,CAAC,SAAS,GAAG,IAAI,QAAQ,EAAO,CAAA;YACpC,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE;gBAC3B,IAAI,CAAC,MAAM;qBACR,WAAW,EAAE;qBACb,OAAO,CAAC,CAAM,GAAG,EAAC,EAAE;oBACnB,IAAI,CAAC,WAAW,GAAG,GAAG,CAAA;oBACtB,OAAO,CAAC,GAAG,CAAC,CAAA,CAAC,kBAAkB;oBAC/B,OAAO,IAAI,CAAC,SAAS,CAAC,OAAO,CAAA,CAAC,gCAAgC;gBAChE,CAAC,CAAA,CAAC;qBACD,KAAK,CAAC,GAAG,EAAE;oBACV,sDAAsD;gBACxD,CAAC,CAAC,CAAA;YACN,CAAC,CAAC,CAAA;QACJ,CAAC,CAAA,CAAA;QAED;;;WAGG;QACO,aAAQ,GAAG,GAAG,EAAE;YACxB,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;YAC5B,OAAO,OAAO,CAAC,OAAO,EAAE,CAAA;QAC1B,CAAC,CAAA;QAED;;;WAGG;QACO,eAAU,GAAG,GAAG,EAAE;YAC1B,IAAI,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;IACI,MAAM,CAAO,cAAc,CAChC,UAA4B,EAC5B,QAAkC,EAClC,MAAyB;;YAEzB,MAAM,EAAE,GAAG,IAAI,qBAAqB,CAAW,UAAU,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAA;YAC5E,MAAM,EAAE,CAAC,KAAK,EAAE,CAAA;YAChB,OAAO,mBAAmB,CAAC,aAAa,CAAC,EAAE,CAAQ,CAAA;QACrD,CAAC;KAAA;CAuCF;AAED;;;GAGG;AACH,MAAM,QAAQ;IAgBZ;;;OAGG;IACH;QACE,IAAI,CAAC,QAAQ,GAAG,IAAI,OAAO,CAAI,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACjD,IAAI,CAAC,OAAO,GAAG,MAAM,CAAA;YACrB,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAA;QACzB,CAAC,CAAC,CAAA;IACJ,CAAC;IAED;;;OAGG;IACH,IAAW,OAAO;QAChB,OAAO,IAAI,CAAC,QAAQ,CAAA;IACtB,CAAC;IAED;;;;OAIG;IACI,OAAO,CAAC,KAAyB;QACtC,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YAClB,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAA;QACtB,CAAC;IACH,CAAC;IAED;;;;OAIG;IACI,MAAM,CAAC,MAAY;QACxB,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAA;QACtB,CAAC;IACH,CAAC;CACF"}

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

@@ -0,0 +1,36 @@
+import pg from 'pg';
+import { PostgresTransaction } from './PostgresTransaction.js';
+import { Database } from '../../Database.js';
+import type { DbConfig } from '../../types.js';
+/**
+ * Represents a Postgres database connection that extends the Database class.
+ * @extends Database<PostgresTransaction>
+ */
+export declare class PostgresDatabase extends Database<PostgresTransaction> {
+    /**
+     * 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;
+    /**
+     * Represents a connection pool to manage multiple client connections to the database.
+     */
+    readonly client: pg.Pool;
+    /**
+     * A private property that represents a connection pool for clients.
+     * @type {Pool | undefined}
+     */
+    readonly readClient?: pg.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'>);
+    /**
+     * 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>;
+    private providerFactory;
+}

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

@@ -0,0 +1,54 @@
+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());
+    });
+};
+import pg from 'pg';
+import { PostgresTransactionImpl } from './PostgresTransaction.js';
+import { Database } from '../../Database.js';
+/**
+ * Represents a Postgres database connection that extends the Database class.
+ * @extends Database<PostgresTransaction>
+ */
+export class PostgresDatabase extends 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
+     */
+    constructor(config) {
+        super(config);
+        this.client = this.providerFactory(config);
+        if (config.readReplica)
+            this.readClient = this.providerFactory(config.readReplica);
+    }
+    /**
+     * 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() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return PostgresTransactionImpl.newTransaction(this.client, this, this.readClient);
+        });
+    }
+    providerFactory(config) {
+        return new PostgresDatabase.pgProvider({
+            host: config.host,
+            port: config.port,
+            user: config.username,
+            password: config.password,
+            database: config.database,
+            max: config.maxConnections,
+        });
+    }
+}
+/**
+ * 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.Pool;
+//# sourceMappingURL=PostgresDatabase.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PostgresDatabase.js","sourceRoot":"","sources":["../../../../../src/Database/integrations/pgsql/PostgresDatabase.ts"],"names":[],"mappings":";;;;;;;;;AAAA,OAAO,EAAE,MAAM,IAAI,CAAA;AAEnB,OAAO,EAAuB,uBAAuB,EAAE,MAAM,0BAA0B,CAAA;AACvF,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AAG5C;;;GAGG;AACH,MAAM,OAAO,gBAAiB,SAAQ,QAA6B;IAgBjE;;;;OAIG;IACH,YAAY,MAAsB;QAChC,KAAK,CAAC,MAAM,CAAC,CAAA;QACb,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,CAAA;QAC1C,IAAI,MAAM,CAAC,WAAW;YAAE,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,WAAW,CAAC,CAAA;IACpF,CAAC;IAED;;;OAGG;IACmB,WAAW;;YAC/B,OAAO,uBAAuB,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,UAAU,CAAC,CAAA;QACnF,CAAC;KAAA;IAEO,eAAe,CAAC,MAAoB;QAC1C,OAAO,IAAI,gBAAgB,CAAC,UAAU,CAAC;YACrC,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;;AA3CD;;;GAGG;AACY,2BAAU,GAAG,EAAE,CAAC,IAAI,CAAA"}

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

@@ -0,0 +1,63 @@
+import * as pg from 'pg';
+import { PostgresDatabase } from './PostgresDatabase.js';
+import { Database } from '../../Database.js';
+import { DatabaseTransaction } from '../../DatabaseTransaction.js';
+/**
+ * A type alias representing a Postgres transaction. It extends the `PostgresTransactionImpl`
+ * interface and includes the `PoolClient` interface.
+ */
+export type PostgresTransaction = PostgresTransactionImpl & pg.PoolClient;
+/**
+ * Represents a transaction in a Postgres database.
+ */
+export declare class PostgresTransactionImpl extends DatabaseTransaction {
+    /**
+     * A Pool object used for writing operations.
+     * @readonly
+     */
+    readonly writer: pg.Pool;
+    /**
+     * A readonly property representing a pool reader.
+     */
+    readonly reader: pg.Pool;
+    /**
+     * Represents a database transaction using a PoolClient.
+     * @type {PoolClient}
+     */
+    protected transaction: pg.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();
+    /**
+     * 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: pg.Pool, database: PostgresDatabase, reader?: pg.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.
+     */
+    protected doBegin: () => Promise<pg.QueryResult<any>>;
+    /**
+     * Executes a COMMIT query to commit the current transaction.
+     * @returns A Promise that resolves when the COMMIT query is successfully executed.
+     */
+    protected doCommit: () => Promise<pg.QueryResult<any>>;
+    /**
+     * Rolls back the current transaction by executing a 'ROLLBACK' query.
+     * @returns A Promise that resolves when the rollback is successful.
+     */
+    protected doRollback: () => Promise<pg.QueryResult<any>>;
+}

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

@@ -0,0 +1,61 @@
+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());
+    });
+};
+import { DatabaseTransaction } from '../../DatabaseTransaction.js';
+/**
+ * Represents a transaction in a Postgres database.
+ */
+export class PostgresTransactionImpl extends DatabaseTransaction {
+    /**
+     * 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).
+     */
+    constructor(writer, database, reader) {
+        super(writer, database, reader);
+        /**
+         * 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 = () => __awaiter(this, void 0, void 0, function* () {
+            this.transaction = yield this.writer.connect();
+            return this.transaction.query('BEGIN');
+        });
+        /**
+         * Executes a COMMIT query to commit the current transaction.
+         * @returns A Promise that resolves when the COMMIT query is successfully executed.
+         */
+        this.doCommit = () => {
+            return this.transaction.query('COMMIT');
+        };
+        /**
+         * Rolls back the current transaction by executing a 'ROLLBACK' query.
+         * @returns A Promise that resolves when the rollback is successful.
+         */
+        this.doRollback = () => {
+            return this.transaction.query('ROLLBACK');
+        };
+    }
+    /**
+     * 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, database, reader) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tx = new PostgresTransactionImpl(writer, database, reader);
+            yield tx.begin(); // defaults to opened
+            return DatabaseTransaction.proxyInstance(tx);
+        });
+    }
+}
+//# sourceMappingURL=PostgresTransaction.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PostgresTransaction.js","sourceRoot":"","sources":["../../../../../src/Database/integrations/pgsql/PostgresTransaction.ts"],"names":[],"mappings":";;;;;;;;;AAIA,OAAO,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAA;AAQlE;;GAEG;AACH,MAAM,OAAO,uBAAwB,SAAQ,mBAAmB;IAoB9D;;;;;OAKG;IACH,YAAoB,MAAe,EAAE,QAA0B,EAAE,MAAgB;QAC/E,KAAK,CAAC,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAA;QAoBjC;;;WAGG;QACO,YAAO,GAAG,GAAS,EAAE;YAC7B,IAAI,CAAC,WAAW,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAA;YAC9C,OAAO,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,OAAO,CAAC,CAAA;QACxC,CAAC,CAAA,CAAA;QAED;;;WAGG;QACO,aAAQ,GAAG,GAAG,EAAE;YACxB,OAAO,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAA;QACzC,CAAC,CAAA;QAED;;;WAGG;QACO,eAAU,GAAG,GAAG,EAAE;YAC1B,OAAO,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,UAAU,CAAC,CAAA;QAC3C,CAAC,CAAA;IA1CD,CAAC;IAED;;;;;;OAMG;IACI,MAAM,CAAO,cAAc,CAChC,MAAe,EACf,QAA0B,EAC1B,MAAgB;;YAEhB,MAAM,EAAE,GAAG,IAAI,uBAAuB,CAAC,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAA;YAChE,MAAM,EAAE,CAAC,KAAK,EAAE,CAAA,CAAC,qBAAqB;YACtC,OAAO,mBAAmB,CAAC,aAAa,CAAC,EAAE,CAAQ,CAAA;QACrD,CAAC;KAAA;CA0BF"}

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

@@ -0,0 +1,76 @@
+import { Database } from './Database.js';
+import { DATABASES } from './DatabaseManager.js';
+import { DynamoDatabase } from './integrations/dynamo/DynamoDatabase.js';
+import { KyselyDatabase } from './integrations/kysely/KyselyDatabase.js';
+import { PostgresDatabase } from './integrations/pgsql/PostgresDatabase.js';
+/**
+ * Represents the possible types of databases available in the system.
+ * @typedef {keyof typeof DATABASES} DatabaseType
+ */
+export type DatabaseType = keyof typeof DATABASES;
+/**
+ * Defines a type for a database class that includes instances for Postgres, and Kysely databases.
+ * @template T - The type of data the KyselyDatabase instance will handle.
+ * @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 DatabaseClass<T> = {
+    pg: new (...args: any[]) => PostgresDatabase;
+    kysely: new (...args: any[]) => KyselyDatabase<T>;
+    dynamo: new (...args: any[]) => DynamoDatabase;
+};
+/**
+ * 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 DatabaseImplType<Type extends DatabaseType, T> = InstanceType<DatabaseClass<T>[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 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
+ */
+export type DbBaseConfig = {
+    host: string;
+    port: number;
+    username: string;
+    password: string;
+    database: string;
+    autoCommit: boolean;
+    maxConnections: number;
+};
+/**
+ * Defines the configuration options for different types of databases.
+ * @template S - The type of database (e.g., 'dynamo', 'pg', 'kysely')
+ * @typedef {Object} DbConfig
+ * @property {DbBaseConfig} DbBaseConfig - The base configuration for the database.
+ * @property {S} type - The type of the database.
+ * @property {DbBaseConfig} [readReplica] - The read replica configuration for '
+ */
+export type DbConfig<S extends DatabaseType> = {
+    type: S;
+} & (S extends 'pg' | 'kysely' ? DbBaseConfig & {
+    readReplica?: DbBaseConfig;
+} : unknown) & (S extends 'dynamo' ? {
+    region: string;
+    tableName: string;
+    maxAttempts?: number;
+    connectionTimeout?: number;
+} : unknown);

package/dist/src/Database/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/Database/types.ts"],"names":[],"mappings":""}