clhq-postgres-module 1.1.0-alpha.154 → 1.1.0-alpha.155

package/dist/database-utils.d.ts

@@ -0,0 +1,30 @@
+import { DataSource } from 'typeorm';
+export interface DatabaseConfig {
+    maxConnections?: number;
+    acquireTimeoutMillis?: number;
+    idleTimeoutMillis?: number;
+    connectionTimeoutMillis?: number;
+    queryTimeout?: number;
+    statementTimeout?: number;
+}
+export interface ConnectionHealth {
+    isHealthy: boolean;
+    responseTime: number;
+    error?: string;
+    timestamp: Date;
+}
+export interface ConnectionMetrics {
+    totalConnections: number;
+    activeConnections: number;
+    idleConnections: number;
+    waitingClients: number;
+    lastHealthCheck: Date;
+}
+export declare function checkConnectionHealth(dataSource: DataSource, timeoutMs?: number): Promise<ConnectionHealth>;
+export declare function getConnectionMetrics(dataSource: DataSource): Promise<ConnectionMetrics>;
+export declare function recoverConnection(dataSource: DataSource, entities: any[], config?: DatabaseConfig, maxRetries?: number): Promise<boolean>;
+export declare function createDataSource(entities: any[], config?: DatabaseConfig): Promise<DataSource>;
+export declare function closeDataSource(dataSource: DataSource): Promise<void>;
+export declare function withDatabase<T>(entities: any[], operation: (dataSource: DataSource) => Promise<T>, config?: DatabaseConfig): Promise<T>;
+export declare function withDatabaseResilient<T>(entities: any[], operation: (dataSource: DataSource) => Promise<T>, config?: DatabaseConfig, maxRetries?: number): Promise<T>;
+export declare function logConnectionStatus(dataSource: DataSource, label?: string): void;

package/dist/database-utils.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkConnectionHealth = checkConnectionHealth;
+exports.getConnectionMetrics = getConnectionMetrics;
+exports.recoverConnection = recoverConnection;
+exports.createDataSource = createDataSource;
+exports.closeDataSource = closeDataSource;
+exports.withDatabase = withDatabase;
+exports.withDatabaseResilient = withDatabaseResilient;
+exports.logConnectionStatus = logConnectionStatus;
+const typeorm_1 = require("typeorm");
+const DEFAULT_CONFIG = {
+    maxConnections: 1,
+    acquireTimeoutMillis: 30000,
+    idleTimeoutMillis: 30000,
+    connectionTimeoutMillis: 10000,
+    queryTimeout: 30000,
+    statementTimeout: 30000,
+};
+async function checkConnectionHealth(dataSource, timeoutMs = 5000) {
+    const startTime = Date.now();
+    const timestamp = new Date();
+    try {
+        if (!dataSource || !dataSource.isInitialized) {
+            return {
+                isHealthy: false,
+                responseTime: Date.now() - startTime,
+                error: 'DataSource not initialized',
+                timestamp,
+            };
+        }
+        await Promise.race([
+            dataSource.query('SELECT 1 as health_check'),
+            new Promise((_, reject) => setTimeout(() => reject(new Error('Health check timeout')), timeoutMs)),
+        ]);
+        return {
+            isHealthy: true,
+            responseTime: Date.now() - startTime,
+            timestamp,
+        };
+    }
+    catch (error) {
+        return {
+            isHealthy: false,
+            responseTime: Date.now() - startTime,
+            error: error instanceof Error ? error.message : String(error),
+            timestamp,
+        };
+    }
+}
+async function getConnectionMetrics(dataSource) {
+    const metrics = {
+        totalConnections: 0,
+        activeConnections: 0,
+        idleConnections: 0,
+        waitingClients: 0,
+        lastHealthCheck: new Date(),
+    };
+    if (!dataSource || !dataSource.isInitialized) {
+        return metrics;
+    }
+    metrics.totalConnections = dataSource.isInitialized ? 1 : 0;
+    metrics.activeConnections = dataSource.isInitialized ? 1 : 0;
+    return metrics;
+}
+async function recoverConnection(dataSource, entities, config = DEFAULT_CONFIG, maxRetries = 3) {
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        try {
+            console.log(`[DB] Recovery attempt ${attempt}/${maxRetries}`);
+            if (dataSource.isInitialized) {
+                await closeDataSource(dataSource);
+            }
+            const newDataSource = await createDataSource(entities, config);
+            const health = await checkConnectionHealth(newDataSource);
+            if (health.isHealthy) {
+                console.log(`[DB] Connection recovered successfully on attempt ${attempt}`);
+                Object.assign(dataSource, newDataSource);
+                return true;
+            }
+            else {
+                console.warn(`[DB] Recovery attempt ${attempt} failed health check:`, health.error);
+                await closeDataSource(newDataSource);
+            }
+        }
+        catch (error) {
+            console.error(`[DB] Recovery attempt ${attempt} failed:`, error);
+        }
+    }
+    console.error(`[DB] Connection recovery failed after ${maxRetries} attempts`);
+    return false;
+}
+async function createDataSource(entities, config = DEFAULT_CONFIG) {
+    const databaseUrl = process.env.PG_SESSION_POOLER_URL;
+    if (!databaseUrl) {
+        throw new Error('PG_SESSION_POOLER_URL environment variable is required');
+    }
+    const dataSource = new typeorm_1.DataSource({
+        type: 'postgres',
+        url: databaseUrl,
+        entities,
+        synchronize: false,
+        ssl: { rejectUnauthorized: false },
+        extra: {
+            max: config.maxConnections,
+            min: 0,
+            acquireTimeoutMillis: config.acquireTimeoutMillis,
+            idleTimeoutMillis: config.idleTimeoutMillis,
+            evictCheckIntervalMillis: 10000,
+            handleTimeoutMillis: 5000,
+            reapIntervalMillis: 1000,
+            createTimeoutMillis: config.acquireTimeoutMillis,
+            connectionTimeoutMillis: config.connectionTimeoutMillis,
+            query_timeout: config.queryTimeout,
+            statement_timeout: config.statementTimeout,
+            testOnBorrow: true,
+            testOnReturn: true,
+            testOnIdle: true,
+        },
+    });
+    const startTime = Date.now();
+    await dataSource.initialize();
+    const initTime = Date.now() - startTime;
+    console.log(`[DB] Connection initialized in ${initTime}ms with config:`, {
+        maxConnections: config.maxConnections,
+        url: databaseUrl.replace(/:\/\/.*@/, '://***:***@'),
+    });
+    return dataSource;
+}
+async function closeDataSource(dataSource) {
+    if (!dataSource || !dataSource.isInitialized) {
+        console.warn('[DB] Attempted to close uninitialized or null DataSource');
+        return;
+    }
+    try {
+        const startTime = Date.now();
+        await dataSource.destroy();
+        const closeTime = Date.now() - startTime;
+        console.log(`[DB] Connection closed in ${closeTime}ms`);
+    }
+    catch (error) {
+        console.error('[DB] Error closing connection:', error);
+        throw error;
+    }
+}
+async function withDatabase(entities, operation, config) {
+    const dataSource = await createDataSource(entities, config);
+    try {
+        const result = await operation(dataSource);
+        console.log('[DB] Operation completed successfully');
+        return result;
+    }
+    catch (error) {
+        console.error('[DB] Operation failed:', error);
+        throw error;
+    }
+    finally {
+        await closeDataSource(dataSource);
+    }
+}
+async function withDatabaseResilient(entities, operation, config, maxRetries = 2) {
+    let lastError;
+    for (let attempt = 1; attempt <= maxRetries + 1; attempt++) {
+        try {
+            return await withDatabase(entities, operation, config);
+        }
+        catch (error) {
+            lastError = error;
+            console.error(`[DB] Operation failed on attempt ${attempt}:`, error);
+            if (attempt <= maxRetries) {
+                console.log(`[DB] Retrying operation (attempt ${attempt + 1}/${maxRetries + 1})`);
+                await new Promise((resolve) => setTimeout(resolve, 1000 * attempt));
+            }
+        }
+    }
+    console.error(`[DB] Operation failed after ${maxRetries + 1} attempts`);
+    throw lastError;
+}
+function logConnectionStatus(dataSource, label = 'DB') {
+    if (!dataSource || !dataSource.isInitialized) {
+        console.log(`[${label}] DataSource not initialized`);
+        return;
+    }
+    console.log(`[${label}] Connection status: initialized=${dataSource.isInitialized}`);
+}

package/dist/index.d.ts

@@ -2,3 +2,4 @@ export * from './entities';
 export * from './repositories';
 export * from './repositories/repository.module';
 export * from './postgres.module';
+export * from './database-utils';

package/dist/index.js

@@ -18,3 +18,4 @@ __exportStar(require("./entities"), exports);
 __exportStar(require("./repositories"), exports);
 __exportStar(require("./repositories/repository.module"), exports);
 __exportStar(require("./postgres.module"), exports);
+__exportStar(require("./database-utils"), exports);

package/dist/postgres.module.js

@@ -52,6 +52,11 @@ const allEntities = [
     entities_1.Scene,
     entities_1.Item,
     entities_1.ProjectShare,
+    entities_1.AssetMetadata,
+    entities_1.ProjectMetadata,
+    entities_1.UserContext,
+    entities_1.AiEmbedding,
+    entities_1.MetadataActivityLog,
 ];
 let PostgresModule = class PostgresModule {
 };
@@ -65,6 +70,19 @@ exports.PostgresModule = PostgresModule = __decorate([
                 entities: allEntities,
                 synchronize: false,
                 logging: false,
+                extra: {
+                    max: 5,
+                    min: 0,
+                    acquireTimeoutMillis: 30000,
+                    idleTimeoutMillis: 30000,
+                    evictCheckIntervalMillis: 10000,
+                    handleTimeoutMillis: 5000,
+                    reapIntervalMillis: 1000,
+                    createTimeoutMillis: 30000,
+                    testOnBorrow: true,
+                    testOnReturn: true,
+                    testOnIdle: true,
+                },
                 ssl: process.env.NODE_ENV === 'test' ||
                     process.env.USE_TEST_CONTAINERS === 'true'
                     ? false

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clhq-postgres-module",
-  "version": "1.1.0-alpha.154",
+  "version": "1.1.0-alpha.155",
   "description": "PostgreSQL module using TypeORM for Clippy",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",