procbay-schema 1.0.0

package/prisma/seeders/utils/connection-manager.js

@@ -0,0 +1,380 @@
+import { PrismaClient } from "../../../src/prisma/index.js";
+import colors from "colors";
+
+// Initialize colors theme
+colors.setTheme({
+  info: "blue",
+  success: "green",
+  warn: "yellow",
+  error: "red",
+  debug: "gray",
+  highlight: "cyan",
+  bold: "bold",
+});
+
+export class ConnectionManager {
+  constructor() {
+    this.connections = new Map();
+    this.isShuttingDown = false;
+
+    // Register process exit handlers to clean up connections
+    process.on("exit", () => this.closeAllConnections());
+    process.on("SIGINT", () => this.handleShutdown());
+    process.on("SIGTERM", () => this.handleShutdown());
+    process.on("uncaughtException", (err) => {
+      console.error(colors.error(`Uncaught exception: ${err.message}`));
+      this.handleShutdown();
+    });
+  }
+
+  /**
+   * Gets a PrismaClient instance for the specified database
+   * @param {string} dbName - The database name
+   * @param {string} url - The database connection URL
+   * @param {object} options - Additional options
+   * @returns {PrismaClient} A PrismaClient instance
+   */
+  getConnection(dbName, url, options = {}) {
+    const connectionKey = `${dbName}:${url}`;
+
+    // Extract our custom options from the Prisma options
+    const { autoRelease, ...prismaOptions } = options;
+
+    // If connection exists and is healthy, return it
+    if (this.connections.has(connectionKey)) {
+      const connection = this.connections.get(connectionKey);
+      console.log(colors.debug(`Reusing existing connection for ${dbName}`));
+      return connection;
+    }
+
+    // Create new connection with custom logger and connection settings
+    const prisma = new PrismaClient({
+      datasources: {
+        db: {
+          url,
+        },
+      },
+      log: prismaOptions.log || [
+        { level: "warn", emit: "event" },
+        { level: "error", emit: "event" },
+      ],
+      ...prismaOptions, // Pass only valid Prisma options
+    });
+
+    // Add event listeners for connection warnings and errors
+    prisma.$on("warn", (e) => {
+      console.warn(colors.warn(`Database warning for ${dbName}: ${e.message}`));
+    });
+
+    prisma.$on("error", (e) => {
+      console.error(colors.error(`Database error for ${dbName}: ${e.message}`));
+    });
+
+    // Store connection
+    this.connections.set(connectionKey, prisma);
+    console.log(colors.debug(`Created new connection for ${dbName}`));
+
+    return prisma;
+  }
+
+  /**
+   * Releases a connection back to the pool
+   * @param {string} dbName - The database name
+   * @param {string} url - The database connection URL
+   */
+  releaseConnection(dbName, url) {
+    const connectionKey = `${dbName}:${url}`;
+    if (this.connections.has(connectionKey)) {
+      console.log(colors.debug(`Releasing connection for ${dbName}`));
+      this.connections.delete(connectionKey);
+    }
+  }
+
+  /**
+   * Close a specific connection
+   * @param {string} dbName - The database name
+   * @param {string} url - The database connection URL
+   */
+  async closeConnection(dbName, url) {
+    const connectionKey = `${dbName}:${url}`;
+    if (this.connections.has(connectionKey)) {
+      const connection = this.connections.get(connectionKey);
+      console.log(colors.debug(`Closing connection for ${dbName}`));
+
+      try {
+        await connection.$disconnect();
+        this.connections.delete(connectionKey);
+      } catch (error) {
+        console.error(
+          colors.error(
+            `Error closing connection for ${dbName}: ${error.message}`
+          )
+        );
+      }
+    }
+  }
+
+  /**
+   * Close all open connections
+   */
+  async closeAllConnections() {
+    if (this.connections.size === 0) return;
+
+    console.log(
+      colors.yellow(`Closing ${this.connections.size} database connections...`)
+    );
+
+    const closePromises = [];
+    for (const [key, connection] of this.connections.entries()) {
+      closePromises.push(
+        connection.$disconnect().catch((error) => {
+          console.error(
+            colors.error(`Error closing connection ${key}: ${error.message}`)
+          );
+        })
+      );
+    }
+
+    try {
+      await Promise.all(closePromises);
+      this.connections.clear();
+      console.log(colors.green("All database connections closed"));
+    } catch (error) {
+      console.error(
+        colors.error(`Error closing connections: ${error.message}`)
+      );
+    }
+  }
+
+  /**
+   * Handle process shutdown
+   */
+  async handleShutdown() {
+    if (this.isShuttingDown) return;
+    this.isShuttingDown = true;
+
+    console.log(
+      colors.yellow("\nShutting down, closing database connections...")
+    );
+    await this.closeAllConnections();
+    process.exit(0);
+  }
+
+  /**
+   * Execute an operation with a database connection
+   * @param {string} dbName - The database name
+   * @param {string} url - The database connection URL
+   * @param {function} operation - Async function that uses the connection
+   * @param {object} options - Connection options
+   * @returns {Promise<*>} Result of the operation
+   */
+  async executeWithConnection(dbName, url, operation, options = {}) {
+    // Separate our custom options from Prisma client options
+    const { autoRelease, ...prismaOptions } = options;
+
+    // Get a connection with only valid Prisma options
+    const connection = this.getConnection(dbName, url, prismaOptions);
+
+    try {
+      // Execute the operation with the connection
+      const result = await operation(connection);
+      return result;
+    } catch (error) {
+      console.error(
+        colors.error(`Error executing operation on ${dbName}: ${error.message}`)
+      );
+      throw error;
+    } finally {
+      // Only disconnect if autoRelease is true
+      if (autoRelease === true) {
+        await this.closeConnection(dbName, url);
+      }
+    }
+  }
+}
+
+// Export a singleton instance
+export const connectionManager = new ConnectionManager();
+export default connectionManager;
+
+/**
+ * Get singleton connection manager instance
+ */
+export function getConnectionManager(config = {}) {
+  return connectionManager;
+}
+
+/**
+ * Helper function for seeding operations
+ */
+export async function withOptimizedConnection(category, operation) {
+  const manager = getConnectionManager();
+  return await manager.executeWithConnection(category, operation);
+}
+
+/**
+ * Helper function for bulk operations
+ */
+export async function withBulkTransaction(category, operations) {
+  const manager = getConnectionManager();
+  return await manager.executeBulkTransaction(category, operations);
+}
+
+/**
+ * Enhanced connection pooling for content operations
+ */
+export class ContentConnectionPool {
+  constructor(options = {}) {
+    this.poolSize = options.poolSize || 8;
+    this.maxRetries = options.maxRetries || 3;
+    this.retryDelay = options.retryDelay || 1000;
+    this.connections = [];
+    this.activeConnections = new Set();
+    this.isInitialized = false;
+  }
+
+  /**
+   * Initialize connection pool
+   */
+  async initialize(dbUrl, prismaOptions = {}) {
+    if (this.isInitialized) return;
+
+    console.log(colors.cyan(`Initializing content connection pool with ${this.poolSize} connections...`));
+
+    for (let i = 0; i < this.poolSize; i++) {
+      try {
+        const connection = new PrismaClient({
+          datasources: { db: { url: dbUrl } },
+          log: prismaOptions.log || [{ level: "error", emit: "event" }],
+          ...prismaOptions
+        });
+
+        // Test the connection
+        await connection.$connect();
+        this.connections.push(connection);
+        
+        console.log(colors.debug(`Connection ${i + 1}/${this.poolSize} initialized`));
+      } catch (error) {
+        console.error(colors.error(`Failed to initialize connection ${i + 1}: ${error.message}`));
+      }
+    }
+
+    this.isInitialized = true;
+    console.log(colors.green(`Content connection pool initialized with ${this.connections.length} connections`));
+  }
+
+  /**
+   * Get an available connection from the pool
+   */
+  async getConnection() {
+    if (!this.isInitialized) {
+      throw new Error('Connection pool not initialized');
+    }
+
+    // Find an available connection
+    for (const connection of this.connections) {
+      if (!this.activeConnections.has(connection)) {
+        this.activeConnections.add(connection);
+        return connection;
+      }
+    }
+
+    // If no connections available, wait and retry
+    console.log(colors.yellow('No available connections, waiting...'));
+    await this.sleep(100);
+    return await this.getConnection();
+  }
+
+  /**
+   * Release a connection back to the pool
+   */
+  releaseConnection(connection) {
+    this.activeConnections.delete(connection);
+  }
+
+  /**
+   * Execute operation with pooled connection
+   */
+  async executeWithPool(operation) {
+    let connection;
+    let retries = 0;
+
+    while (retries < this.maxRetries) {
+      try {
+        connection = await this.getConnection();
+        const result = await operation(connection);
+        return result;
+      } catch (error) {
+        retries++;
+        console.warn(colors.yellow(`Operation failed (attempt ${retries}/${this.maxRetries}): ${error.message}`));
+        
+        if (retries < this.maxRetries) {
+          await this.sleep(this.retryDelay * retries);
+        } else {
+          throw error;
+        }
+      } finally {
+        if (connection) {
+          this.releaseConnection(connection);
+        }
+      }
+    }
+  }
+
+  /**
+   * Close all connections in the pool
+   */
+  async closeAll() {
+    console.log(colors.yellow(`Closing ${this.connections.length} pooled connections...`));
+    
+    const closePromises = this.connections.map(connection => 
+      connection.$disconnect().catch(error => 
+        console.error(colors.error(`Error closing pooled connection: ${error.message}`))
+      )
+    );
+
+    await Promise.all(closePromises);
+    this.connections = [];
+    this.activeConnections.clear();
+    this.isInitialized = false;
+    
+    console.log(colors.green('All pooled connections closed'));
+  }
+
+  sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+}
+
+/**
+ * Global content connection pool instance
+ */
+let contentConnectionPool = null;
+
+/**
+ * Get or create content connection pool
+ */
+export function getContentConnectionPool(options = {}) {
+  if (!contentConnectionPool) {
+    contentConnectionPool = new ContentConnectionPool(options);
+  }
+  return contentConnectionPool;
+}
+
+/**
+ * Helper for content seeding with connection pooling
+ */
+export async function withContentPool(dbUrl, operation, poolOptions = {}) {
+  const pool = getContentConnectionPool(poolOptions);
+  
+  if (!pool.isInitialized) {
+    await pool.initialize(dbUrl);
+  }
+  
+  try {
+    return await pool.executeWithPool(operation);
+  } catch (error) {
+    console.error(colors.error(`Content pool operation failed: ${error.message}`));
+    throw error;
+  }
+}