@ciscode/database-kit 1.0.0 → 1.0.1

package/dist/adapters/postgres.adapter.js

@@ -1,5 +1,4 @@
 "use strict";
-// src/adapters/postgres.adapter.ts
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -15,8 +14,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 var PostgresAdapter_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PostgresAdapter = void 0;
-const knex_1 = __importDefault(require("knex"));
 const common_1 = require("@nestjs/common");
+const knex_1 = __importDefault(require("knex"));
+const database_contracts_1 = require("../contracts/database.contracts");
 /**
  * PostgreSQL adapter for DatabaseKit.
  * Handles PostgreSQL connection and repository creation via Knex.
@@ -41,15 +41,25 @@ let PostgresAdapter = PostgresAdapter_1 = class PostgresAdapter {
      * @returns Knex instance
      */
     connect(overrides = {}) {
+        var _a, _b, _c, _d, _e;
         if (!this.knexInstance) {
-            this.logger.log('Creating PostgreSQL connection pool...');
+            this.logger.log("Creating PostgreSQL connection pool...");
+            // Apply pool configuration from config
+            const poolConfig = this.config.pool || {};
+            const pool = {
+                min: (_a = poolConfig.min) !== null && _a !== void 0 ? _a : 0,
+                max: (_b = poolConfig.max) !== null && _b !== void 0 ? _b : 10,
+                idleTimeoutMillis: (_c = poolConfig.idleTimeoutMs) !== null && _c !== void 0 ? _c : 30000,
+                acquireTimeoutMillis: (_d = poolConfig.acquireTimeoutMs) !== null && _d !== void 0 ? _d : 60000,
+            };
             this.knexInstance = (0, knex_1.default)({
-                client: 'pg',
+                client: "pg",
                 connection: this.config.connectionString,
-                pool: { min: 0, max: 10 },
+                pool,
+                acquireConnectionTimeout: (_e = poolConfig.acquireTimeoutMs) !== null && _e !== void 0 ? _e : 60000,
                 ...overrides,
             });
-            this.logger.log('PostgreSQL connection pool created');
+            this.logger.log("PostgreSQL connection pool created");
         }
         return this.knexInstance;
     }
@@ -60,7 +70,7 @@ let PostgresAdapter = PostgresAdapter_1 = class PostgresAdapter {
         if (this.knexInstance) {
             await this.knexInstance.destroy();
             this.knexInstance = undefined;
-            this.logger.log('PostgreSQL connection pool destroyed');
+            this.logger.log("PostgreSQL connection pool destroyed");
         }
     }
     /**
@@ -69,7 +79,7 @@ let PostgresAdapter = PostgresAdapter_1 = class PostgresAdapter {
      */
     getKnex() {
         if (!this.knexInstance) {
-            throw new Error('PostgreSQL not connected. Call connect() first.');
+            throw new Error("PostgreSQL not connected. Call connect() first.");
         }
         return this.knexInstance;
     }
@@ -79,19 +89,142 @@ let PostgresAdapter = PostgresAdapter_1 = class PostgresAdapter {
     isConnected() {
         return !!this.knexInstance;
     }
+    /**
+     * Performs a health check on the PostgreSQL connection.
+     * Executes a simple query to verify the database is responsive.
+     *
+     * @returns Health check result with status and response time
+     *
+     * @example
+     * ```typescript
+     * const health = await adapter.healthCheck();
+     * if (!health.healthy) {
+     *   console.error('Database unhealthy:', health.error);
+     * }
+     * ```
+     */
+    async healthCheck() {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        const startTime = Date.now();
+        try {
+            if (!this.knexInstance) {
+                return {
+                    healthy: false,
+                    responseTimeMs: Date.now() - startTime,
+                    type: "postgres",
+                    error: "Not connected to PostgreSQL",
+                };
+            }
+            // Execute simple query to verify connection
+            const result = await this.knexInstance.raw("SELECT version(), current_database()");
+            const row = (_a = result.rows) === null || _a === void 0 ? void 0 : _a[0];
+            // Get pool info if available
+            const pool = this.knexInstance.client.pool;
+            return {
+                healthy: true,
+                responseTimeMs: Date.now() - startTime,
+                type: "postgres",
+                details: {
+                    version: (_b = row === null || row === void 0 ? void 0 : row.version) === null || _b === void 0 ? void 0 : _b.split(" ").slice(0, 2).join(" "),
+                    activeConnections: (_d = (_c = pool === null || pool === void 0 ? void 0 : pool.numUsed) === null || _c === void 0 ? void 0 : _c.call(pool)) !== null && _d !== void 0 ? _d : 0,
+                    poolSize: ((_f = (_e = pool === null || pool === void 0 ? void 0 : pool.numUsed) === null || _e === void 0 ? void 0 : _e.call(pool)) !== null && _f !== void 0 ? _f : 0) + ((_h = (_g = pool === null || pool === void 0 ? void 0 : pool.numFree) === null || _g === void 0 ? void 0 : _g.call(pool)) !== null && _h !== void 0 ? _h : 0),
+                },
+            };
+        }
+        catch (error) {
+            return {
+                healthy: false,
+                responseTimeMs: Date.now() - startTime,
+                type: "postgres",
+                error: error instanceof Error ? error.message : "Unknown error",
+            };
+        }
+    }
     /**
      * Creates a repository for a PostgreSQL table.
      * The repository provides a standardized CRUD interface.
      *
      * @param cfg - Configuration for the entity/table
+     * @param trx - Optional Knex transaction for transaction support
      * @returns Repository instance with CRUD methods
      */
-    createRepository(cfg) {
-        const kx = this.getKnex();
+    createRepository(cfg, trx) {
+        var _a, _b, _c, _d, _e;
+        const kx = trx || this.getKnex();
         const table = cfg.table;
-        const pk = cfg.primaryKey || 'id';
+        const pk = cfg.primaryKey || "id";
         const allowed = cfg.columns || [];
         const baseFilter = cfg.defaultFilter || {};
+        // Soft delete configuration
+        const softDeleteEnabled = (_a = cfg.softDelete) !== null && _a !== void 0 ? _a : false;
+        const softDeleteField = (_b = cfg.softDeleteField) !== null && _b !== void 0 ? _b : "deleted_at";
+        // Timestamp configuration
+        const timestampsEnabled = (_c = cfg.timestamps) !== null && _c !== void 0 ? _c : false;
+        const createdAtField = (_d = cfg.createdAtField) !== null && _d !== void 0 ? _d : "created_at";
+        const updatedAtField = (_e = cfg.updatedAtField) !== null && _e !== void 0 ? _e : "updated_at";
+        // Hooks configuration
+        const hooks = cfg.hooks;
+        // Create not-deleted filter for soft delete
+        const notDeletedFilter = softDeleteEnabled
+            ? { [softDeleteField]: { isNull: true } }
+            : {};
+        // Helper to add createdAt timestamp
+        const addCreatedAt = (data) => {
+            if (timestampsEnabled) {
+                return { ...data, [createdAtField]: new Date() };
+            }
+            return data;
+        };
+        // Helper to add updatedAt timestamp
+        const addUpdatedAt = (data) => {
+            if (timestampsEnabled) {
+                return { ...data, [updatedAtField]: new Date() };
+            }
+            return data;
+        };
+        // Hook helper functions
+        const runBeforeCreate = async (data) => {
+            if (hooks === null || hooks === void 0 ? void 0 : hooks.beforeCreate) {
+                const result = await hooks.beforeCreate({
+                    data,
+                    operation: "create",
+                    isBulk: false,
+                });
+                return result !== null && result !== void 0 ? result : data;
+            }
+            return data;
+        };
+        const runAfterCreate = async (entity) => {
+            if (hooks === null || hooks === void 0 ? void 0 : hooks.afterCreate) {
+                await hooks.afterCreate(entity);
+            }
+        };
+        const runBeforeUpdate = async (data) => {
+            if (hooks === null || hooks === void 0 ? void 0 : hooks.beforeUpdate) {
+                const result = await hooks.beforeUpdate({
+                    data,
+                    operation: "update",
+                    isBulk: false,
+                });
+                return result !== null && result !== void 0 ? result : data;
+            }
+            return data;
+        };
+        const runAfterUpdate = async (entity) => {
+            if (hooks === null || hooks === void 0 ? void 0 : hooks.afterUpdate) {
+                await hooks.afterUpdate(entity);
+            }
+        };
+        const runBeforeDelete = async (id) => {
+            if (hooks === null || hooks === void 0 ? void 0 : hooks.beforeDelete) {
+                await hooks.beforeDelete(id);
+            }
+        };
+        const runAfterDelete = async (success) => {
+            if (hooks === null || hooks === void 0 ? void 0 : hooks.afterDelete) {
+                await hooks.afterDelete(success);
+            }
+        };
         const assertFieldAllowed = (field) => {
             if (allowed.length && !allowed.includes(field)) {
                 throw new Error(`Field "${field}" is not allowed for table "${table}". Add it to columns[] in config.`);
@@ -100,20 +233,20 @@ let PostgresAdapter = PostgresAdapter_1 = class PostgresAdapter {
         const applyFilter = (qb, filter) => {
             Object.entries(filter).forEach(([key, value]) => {
                 assertFieldAllowed(key);
-                if (value && typeof value === 'object' && !Array.isArray(value)) {
+                if (value && typeof value === "object" && !Array.isArray(value)) {
                     const ops = value;
                     if (ops.eq !== undefined)
                         qb.where(key, ops.eq);
                     if (ops.ne !== undefined)
                         qb.whereNot(key, ops.ne);
                     if (ops.gt !== undefined)
-                        qb.where(key, '>', ops.gt);
+                        qb.where(key, ">", ops.gt);
                     if (ops.gte !== undefined)
-                        qb.where(key, '>=', ops.gte);
+                        qb.where(key, ">=", ops.gte);
                     if (ops.lt !== undefined)
-                        qb.where(key, '<', ops.lt);
+                        qb.where(key, "<", ops.lt);
                     if (ops.lte !== undefined)
-                        qb.where(key, '<=', ops.lte);
+                        qb.where(key, "<=", ops.lte);
                     if (ops.in)
                         qb.whereIn(key, ops.in);
                     if (ops.nin)
@@ -133,11 +266,11 @@ let PostgresAdapter = PostgresAdapter_1 = class PostgresAdapter {
         const applySort = (qb, sort) => {
             if (!sort)
                 return;
-            if (typeof sort === 'string') {
-                const parts = sort.split(',');
+            if (typeof sort === "string") {
+                const parts = sort.split(",");
                 for (const p of parts) {
-                    const dir = p.startsWith('-') ? 'desc' : 'asc';
-                    const col = p.replace(/^[-+]/, '');
+                    const dir = p.startsWith("-") ? "desc" : "asc";
+                    const col = p.replace(/^[-+]/, "");
                     assertFieldAllowed(col);
                     qb.orderBy(col, dir);
                 }
@@ -145,7 +278,7 @@ let PostgresAdapter = PostgresAdapter_1 = class PostgresAdapter {
             else {
                 Object.entries(sort).forEach(([col, dir]) => {
                     assertFieldAllowed(col);
-                    const direction = dir === -1 || String(dir).toLowerCase() === 'desc' ? 'desc' : 'asc';
+                    const direction = dir === -1 || String(dir).toLowerCase() === "desc" ? "desc" : "asc";
                     qb.orderBy(col, direction);
                 });
             }
@@ -156,70 +289,331 @@ let PostgresAdapter = PostgresAdapter_1 = class PostgresAdapter {
         };
         const repo = {
             async create(data) {
-                const [row] = await kx(table).insert(data).returning('*');
-                return row;
+                // Run beforeCreate hook
+                let processedData = await runBeforeCreate(data);
+                processedData = addCreatedAt(processedData);
+                const [row] = await kx(table).insert(processedData).returning("*");
+                const entity = row;
+                // Run afterCreate hook
+                await runAfterCreate(entity);
+                return entity;
             },
             async findById(id) {
-                const row = await kx(table)
-                    .select('*')
-                    .where({ [pk]: id, ...baseFilter })
-                    .first();
+                const mergedFilter = { ...baseFilter, ...notDeletedFilter };
+                const qb = kx(table)
+                    .select("*")
+                    .where({ [pk]: id });
+                applyFilter(qb, mergedFilter);
+                const row = await qb.first();
                 return row || null;
             },
             async findAll(filter = {}) {
-                const mergedFilter = { ...baseFilter, ...filter };
-                const qb = kx(table).select('*');
+                const mergedFilter = { ...baseFilter, ...notDeletedFilter, ...filter };
+                const qb = kx(table).select("*");
                 applyFilter(qb, mergedFilter);
                 const rows = await qb;
                 return rows;
             },
+            async findOne(filter) {
+                const mergedFilter = { ...baseFilter, ...notDeletedFilter, ...filter };
+                const qb = kx(table).select("*");
+                applyFilter(qb, mergedFilter);
+                const row = await qb.first();
+                return row || null;
+            },
             async findPage(options = {}) {
                 var _a;
                 const { filter = {}, page = 1, limit = 10, sort } = options;
-                const mergedFilter = { ...baseFilter, ...filter };
+                const mergedFilter = { ...baseFilter, ...notDeletedFilter, ...filter };
                 const offset = Math.max(0, (page - 1) * limit);
-                const qb = kx(table).select('*');
+                const qb = kx(table).select("*");
                 applyFilter(qb, mergedFilter);
                 applySort(qb, sort);
                 const data = (await qb.clone().limit(limit).offset(offset));
                 const countRow = await kx(table)
-                    .count({ count: '*' })
+                    .count({ count: "*" })
                     .modify((q) => applyFilter(q, mergedFilter));
                 const total = Number(((_a = countRow[0]) === null || _a === void 0 ? void 0 : _a.count) || 0);
                 return shapePage(data, page, limit, total);
             },
             async updateById(id, update) {
-                const [row] = await kx(table)
-                    .where({ [pk]: id })
-                    .update(update)
-                    .returning('*');
-                return row || null;
+                // Run beforeUpdate hook
+                let processedUpdate = await runBeforeUpdate(update);
+                processedUpdate = addUpdatedAt(processedUpdate);
+                const mergedFilter = { ...baseFilter, ...notDeletedFilter };
+                const qb = kx(table).where({ [pk]: id });
+                applyFilter(qb, mergedFilter);
+                const [row] = await qb.update(processedUpdate).returning("*");
+                const entity = row || null;
+                // Run afterUpdate hook
+                await runAfterUpdate(entity);
+                return entity;
             },
             async deleteById(id) {
-                const [row] = await kx(table)
-                    .where({ [pk]: id })
-                    .delete()
-                    .returning('*');
-                return !!row;
+                // Run beforeDelete hook
+                await runBeforeDelete(id);
+                const mergedFilter = { ...baseFilter, ...notDeletedFilter };
+                let success;
+                // If soft delete is enabled, update instead of delete
+                if (softDeleteEnabled) {
+                    const qb = kx(table).where({ [pk]: id });
+                    applyFilter(qb, mergedFilter);
+                    const affectedRows = await qb.update({
+                        [softDeleteField]: new Date(),
+                    });
+                    success = affectedRows > 0;
+                }
+                else {
+                    const qb = kx(table).where({ [pk]: id });
+                    applyFilter(qb, mergedFilter);
+                    const affectedRows = await qb.delete();
+                    success = affectedRows > 0;
+                }
+                // Run afterDelete hook
+                await runAfterDelete(success);
+                return success;
             },
             async count(filter = {}) {
-                const mergedFilter = { ...baseFilter, ...filter };
+                const mergedFilter = { ...baseFilter, ...notDeletedFilter, ...filter };
                 const [{ count }] = await kx(table)
-                    .count({ count: '*' })
+                    .count({ count: "*" })
                     .modify((q) => applyFilter(q, mergedFilter));
                 return Number(count || 0);
             },
             async exists(filter = {}) {
-                const mergedFilter = { ...baseFilter, ...filter };
+                const mergedFilter = { ...baseFilter, ...notDeletedFilter, ...filter };
                 const row = await kx(table)
                     .select([pk])
                     .modify((q) => applyFilter(q, mergedFilter))
                     .first();
                 return !!row;
             },
+            // -----------------------------
+            // Bulk Operations
+            // -----------------------------
+            async insertMany(data) {
+                if (data.length === 0)
+                    return [];
+                // Add createdAt timestamp to each record
+                const timestampedData = data.map((item) => addCreatedAt(item));
+                const rows = await kx(table).insert(timestampedData).returning("*");
+                return rows;
+            },
+            async updateMany(filter, update) {
+                const mergedFilter = { ...baseFilter, ...notDeletedFilter, ...filter };
+                const timestampedUpdate = addUpdatedAt(update);
+                const affectedRows = await kx(table)
+                    .modify((q) => applyFilter(q, mergedFilter))
+                    .update(timestampedUpdate);
+                return affectedRows;
+            },
+            async deleteMany(filter) {
+                const mergedFilter = { ...baseFilter, ...notDeletedFilter, ...filter };
+                // If soft delete is enabled, update instead of delete
+                if (softDeleteEnabled) {
+                    const affectedRows = await kx(table)
+                        .modify((q) => applyFilter(q, mergedFilter))
+                        .update({ [softDeleteField]: new Date() });
+                    return affectedRows;
+                }
+                const affectedRows = await kx(table)
+                    .modify((q) => applyFilter(q, mergedFilter))
+                    .delete();
+                return affectedRows;
+            },
+            // -----------------------------
+            // Advanced Query Operations
+            // -----------------------------
+            async upsert(filter, data) {
+                const mergedFilter = { ...baseFilter, ...notDeletedFilter, ...filter };
+                // Try to find existing record
+                const qb = kx(table).select("*");
+                applyFilter(qb, mergedFilter);
+                const existing = await qb.first();
+                if (existing) {
+                    // Update existing record
+                    const timestampedUpdate = addUpdatedAt(data);
+                    const updateQb = kx(table).where({ [pk]: existing[pk] });
+                    const [row] = await updateQb.update(timestampedUpdate).returning("*");
+                    return row;
+                }
+                else {
+                    // Insert new record
+                    const timestampedData = addCreatedAt({ ...filter, ...data });
+                    const [row] = await kx(table).insert(timestampedData).returning("*");
+                    return row;
+                }
+            },
+            async distinct(field, filter = {}) {
+                const mergedFilter = { ...baseFilter, ...notDeletedFilter, ...filter };
+                const qb = kx(table)
+                    .distinct(String(field))
+                    .modify((q) => applyFilter(q, mergedFilter));
+                const rows = await qb;
+                return rows.map((row) => row[String(field)]);
+            },
+            async select(filter, fields) {
+                const mergedFilter = { ...baseFilter, ...notDeletedFilter, ...filter };
+                const qb = kx(table)
+                    .select(fields.map(String))
+                    .modify((q) => applyFilter(q, mergedFilter));
+                const rows = await qb;
+                return rows;
+            },
+            // -----------------------------
+            // Soft Delete Operations
+            // -----------------------------
+            softDelete: softDeleteEnabled
+                ? async (id) => {
+                    const mergedFilter = { ...baseFilter, ...notDeletedFilter };
+                    const qb = kx(table).where({ [pk]: id });
+                    applyFilter(qb, mergedFilter);
+                    const affectedRows = await qb.update({
+                        [softDeleteField]: new Date(),
+                    });
+                    return affectedRows > 0;
+                }
+                : undefined,
+            softDeleteMany: softDeleteEnabled
+                ? async (filter) => {
+                    const mergedFilter = {
+                        ...baseFilter,
+                        ...notDeletedFilter,
+                        ...filter,
+                    };
+                    const affectedRows = await kx(table)
+                        .modify((q) => applyFilter(q, mergedFilter))
+                        .update({ [softDeleteField]: new Date() });
+                    return affectedRows;
+                }
+                : undefined,
+            restore: softDeleteEnabled
+                ? async (id) => {
+                    const deletedFilter = { [softDeleteField]: { isNotNull: true } };
+                    const mergedFilter = { ...baseFilter, ...deletedFilter };
+                    const qb = kx(table).where({ [pk]: id });
+                    applyFilter(qb, mergedFilter);
+                    const [row] = await qb
+                        .update({ [softDeleteField]: null })
+                        .returning("*");
+                    return row || null;
+                }
+                : undefined,
+            restoreMany: softDeleteEnabled
+                ? async (filter) => {
+                    const deletedFilter = { [softDeleteField]: { isNotNull: true } };
+                    const mergedFilter = { ...baseFilter, ...deletedFilter, ...filter };
+                    const affectedRows = await kx(table)
+                        .modify((q) => applyFilter(q, mergedFilter))
+                        .update({ [softDeleteField]: null });
+                    return affectedRows;
+                }
+                : undefined,
+            findAllWithDeleted: softDeleteEnabled
+                ? async (filter = {}) => {
+                    // Ignore soft delete filter, include all records
+                    const mergedFilter = { ...baseFilter, ...filter };
+                    const qb = kx(table).select("*");
+                    applyFilter(qb, mergedFilter);
+                    const rows = await qb;
+                    return rows;
+                }
+                : undefined,
+            findDeleted: softDeleteEnabled
+                ? async (filter = {}) => {
+                    // Only find deleted records
+                    const deletedFilter = { [softDeleteField]: { isNotNull: true } };
+                    const mergedFilter = { ...baseFilter, ...deletedFilter, ...filter };
+                    const qb = kx(table).select("*");
+                    applyFilter(qb, mergedFilter);
+                    const rows = await qb;
+                    return rows;
+                }
+                : undefined,
         };
         return repo;
     }
+    /**
+     * Executes a callback within a PostgreSQL transaction.
+     * All database operations within the callback are atomic.
+     *
+     * @param callback - Function to execute within the transaction
+     * @param options - Transaction options including isolation level
+     * @returns Result of the callback function
+     * @throws Error if transaction fails after all retries
+     *
+     * @example
+     * ```typescript
+     * const result = await postgresAdapter.withTransaction(async (ctx) => {
+     *   const usersRepo = ctx.createRepository<User>({ table: 'users' });
+     *   const ordersRepo = ctx.createRepository<Order>({ table: 'orders' });
+     *
+     *   const [user] = await usersRepo.create({ name: 'John' });
+     *   const [order] = await ordersRepo.create({ user_id: user.id, total: 100 });
+     *
+     *   return { user, order };
+     * }, { isolationLevel: 'serializable' });
+     * ```
+     */
+    async withTransaction(callback, options = {}) {
+        const { isolationLevel = "read committed", retries = 0, timeout = database_contracts_1.DATABASE_KIT_CONSTANTS.DEFAULT_TRANSACTION_TIMEOUT, } = options;
+        const kx = this.getKnex();
+        let lastError;
+        for (let attempt = 0; attempt <= retries; attempt++) {
+            try {
+                const result = await kx.transaction(async (trx) => {
+                    // Set statement timeout for the transaction
+                    await trx.raw(`SET LOCAL statement_timeout = ${timeout}`);
+                    const context = {
+                        transaction: trx,
+                        createRepository: (config) => this.createRepository(config, trx),
+                    };
+                    return await callback(context);
+                }, { isolationLevel });
+                this.logger.debug(`Transaction committed successfully (attempt ${attempt + 1})`);
+                return result;
+            }
+            catch (error) {
+                lastError = error;
+                this.logger.warn(`Transaction failed (attempt ${attempt + 1}/${retries + 1}): ${lastError.message}`);
+                // Check if error is retryable
+                const isRetryable = this.isRetryableError(error);
+                if (!isRetryable || attempt >= retries) {
+                    throw lastError;
+                }
+                // Exponential backoff before retry
+                const backoffMs = Math.min(100 * Math.pow(2, attempt), 3000);
+                await this.sleep(backoffMs);
+            }
+        }
+        throw lastError || new Error("Transaction failed");
+    }
+    /**
+     * Checks if a PostgreSQL error is retryable.
+     */
+    isRetryableError(error) {
+        if (error && typeof error === "object") {
+            const pgError = error;
+            // PostgreSQL serialization failure codes
+            const retryableCodes = [
+                "40001", // serialization_failure
+                "40P01", // deadlock_detected
+                "55P03", // lock_not_available
+                "57P01", // admin_shutdown
+                "57014", // query_canceled (timeout)
+            ];
+            if (pgError.code && retryableCodes.includes(pgError.code)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Simple sleep utility for retry backoff.
+     */
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
 };
 exports.PostgresAdapter = PostgresAdapter;
 exports.PostgresAdapter = PostgresAdapter = PostgresAdapter_1 = __decorate([