@pipeline-builder/pipeline-data 0.0.1

package/lib/database/retry-strategy.js

@@ -0,0 +1,122 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { createLogger } from '@pipeline-builder/api-core';
+const logger = createLogger('retry-strategy');
+/**
+ * Implements exponential backoff retry strategy for database connections.
+ *
+ * Features:
+ * - Exponential backoff with configurable base delay
+ * - Attempt tracking and logging
+ * - Graceful failure after max retries
+ *
+ * @example
+ * ```typescript
+ * const strategy = new ConnectionRetryStrategy({ maxRetries: 3, baseDelay: 1000 });
+ *
+ * const result = await strategy.execute(async () => {
+ *   return await db.query('SELECT 1');
+ * });
+ * ```
+ */
+export class ConnectionRetryStrategy {
+    config;
+    attempts = 0;
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Executes an operation with retry logic
+     *
+     * @param operation - Async function to execute with retries
+     * @returns Promise resolving to operation result
+     * @throws Error if all retry attempts fail
+     */
+    async execute(operation) {
+        this.attempts = 0;
+        while (this.attempts < this.config.maxRetries) {
+            try {
+                const result = await operation();
+                if (this.attempts > 0) {
+                    logger.info('Operation succeeded after retry');
+                }
+                return result;
+            }
+            catch (error) {
+                this.attempts++;
+                if (this.attempts >= this.config.maxRetries) {
+                    logger.error(`Max retry attempts (${this.config.maxRetries}) reached`);
+                    throw error;
+                }
+                const delay = this.calculateBackoff(this.attempts);
+                logger.warn(`Operation failed (attempt ${this.attempts}/${this.config.maxRetries}), retrying in ${delay}ms...`, { error: error instanceof Error ? error.message : String(error) });
+                await this.sleep(delay);
+            }
+        }
+        throw new Error('Retry logic failed unexpectedly');
+    }
+    /**
+     * Handles connection errors with retry tracking
+     *
+     * @param error - Error that occurred
+     * @param testConnection - Function to test if connection is restored
+     */
+    async handleConnectionError(error, testConnection) {
+        this.attempts++;
+        logger.error(`Connection error (attempt ${this.attempts}/${this.config.maxRetries}):`, error.message);
+        if (this.attempts < this.config.maxRetries) {
+            const delay = this.calculateBackoff(this.attempts);
+            logger.info(`Retrying connection in ${delay}ms...`);
+            await this.sleep(delay);
+            try {
+                const isHealthy = await testConnection();
+                if (isHealthy) {
+                    logger.info('Connection restored');
+                    this.attempts = 0; // Reset on successful connection
+                }
+                else {
+                    logger.error('Connection test failed after retry');
+                }
+            }
+            catch (retryError) {
+                logger.error('Retry failed:', retryError);
+            }
+        }
+        else {
+            logger.error('Max connection retry attempts reached');
+        }
+    }
+    /**
+     * Resets the attempt counter
+     * Call this after a successful operation
+     */
+    reset() {
+        this.attempts = 0;
+    }
+    /**
+     * Gets the current attempt count
+     */
+    getAttempts() {
+        return this.attempts;
+    }
+    /**
+     * Calculates exponential backoff delay
+     *
+     * @param attempt - Current attempt number (1-indexed)
+     * @returns Delay in milliseconds
+     */
+    calculateBackoff(attempt) {
+        const base = this.config.baseDelay * Math.pow(2, attempt - 1);
+        const jitter = Math.random() * 0.1 * base;
+        return base + jitter;
+    }
+    /**
+     * Sleeps for the specified duration
+     *
+     * @param ms - Milliseconds to sleep
+     */
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"retry-strategy.js","sourceRoot":"","sources":["../../src/database/retry-strategy.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAE1D,MAAM,MAAM,GAAG,YAAY,CAAC,gBAAgB,CAAC,CAAC;AAY9C;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,OAAO,uBAAuB;IAGL,MAAM;IAF3B,QAAQ,GAAG,CAAC,CAAC;IAErB,YAA6B,MAAmB;sBAAnB,MAAM;IAAgB,CAAC;IAEpD;;;;;;OAMG;IACH,KAAK,CAAC,OAAO,CAAI,SAA2B;QAC1C,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC;QAElB,OAAO,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;YAC9C,IAAI,CAAC;gBACH,MAAM,MAAM,GAAG,MAAM,SAAS,EAAE,CAAC;gBACjC,IAAI,IAAI,CAAC,QAAQ,GAAG,CAAC,EAAE,CAAC;oBACtB,MAAM,CAAC,IAAI,CAAC,iCAAiC,CAAC,CAAC;gBACjD,CAAC;gBACD,OAAO,MAAM,CAAC;YAChB,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,IAAI,CAAC,QAAQ,EAAE,CAAC;gBAEhB,IAAI,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;oBAC5C,MAAM,CAAC,KAAK,CAAC,uBAAuB,IAAI,CAAC,MAAM,CAAC,UAAU,WAAW,CAAC,CAAC;oBACvE,MAAM,KAAK,CAAC;gBACd,CAAC;gBAED,MAAM,KAAK,GAAG,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;gBACnD,MAAM,CAAC,IAAI,CACT,6BAA6B,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,MAAM,CAAC,UAAU,kBAAkB,KAAK,OAAO,EAClG,EAAE,KAAK,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAClE,CAAC;gBAEF,MAAM,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YAC1B,CAAC;QACH,CAAC;QAED,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAC;IACrD,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,qBAAqB,CAAC,KAAY,EAAE,cAAsC;QAC9E,IAAI,CAAC,QAAQ,EAAE,CAAC;QAEhB,MAAM,CAAC,KAAK,CACV,6BAA6B,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,MAAM,CAAC,UAAU,IAAI,EACxE,KAAK,CAAC,OAAO,CACd,CAAC;QAEF,IAAI,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;YAC3C,MAAM,KAAK,GAAG,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YACnD,MAAM,CAAC,IAAI,CAAC,0BAA0B,KAAK,OAAO,CAAC,CAAC;YAEpD,MAAM,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YAExB,IAAI,CAAC;gBACH,MAAM,SAAS,GAAG,MAAM,cAAc,EAAE,CAAC;gBACzC,IAAI,SAAS,EAAE,CAAC;oBACd,MAAM,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC;oBACnC,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC,CAAC,iCAAiC;gBACtD,CAAC;qBAAM,CAAC;oBACN,MAAM,CAAC,KAAK,CAAC,oCAAoC,CAAC,CAAC;gBACrD,CAAC;YACH,CAAC;YAAC,OAAO,UAAU,EAAE,CAAC;gBACpB,MAAM,CAAC,KAAK,CAAC,eAAe,EAAE,UAAU,CAAC,CAAC;YAC5C,CAAC;QACH,CAAC;aAAM,CAAC;YACN,MAAM,CAAC,KAAK,CAAC,uCAAuC,CAAC,CAAC;QACxD,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,KAAK;QACH,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC;IACpB,CAAC;IAED;;OAEG;IACH,WAAW;QACT,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IAED;;;;;OAKG;IACK,gBAAgB,CAAC,OAAe;QACtC,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,CAAC,CAAC;QAC9D,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,EAAE,GAAG,GAAG,GAAG,IAAI,CAAC;QAC1C,OAAO,IAAI,GAAG,MAAM,CAAC;IACvB,CAAC;IAED;;;;OAIG;IACK,KAAK,CAAC,EAAU;QACtB,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,CAAC;IACzD,CAAC;CACF","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { createLogger } from '@pipeline-builder/api-core';\n\nconst logger = createLogger('retry-strategy');\n\n/**\n * Configuration for connection retry strategy\n */\nexport interface RetryConfig {\n  /** Maximum number of retry attempts */\n  maxRetries: number;\n  /** Base delay between retries in milliseconds */\n  baseDelay: number;\n}\n\n/**\n * Implements exponential backoff retry strategy for database connections.\n *\n * Features:\n * - Exponential backoff with configurable base delay\n * - Attempt tracking and logging\n * - Graceful failure after max retries\n *\n * @example\n * ```typescript\n * const strategy = new ConnectionRetryStrategy({ maxRetries: 3, baseDelay: 1000 });\n *\n * const result = await strategy.execute(async () => {\n *   return await db.query('SELECT 1');\n * });\n * ```\n */\nexport class ConnectionRetryStrategy {\n  private attempts = 0;\n\n  constructor(private readonly config: RetryConfig) {}\n\n  /**\n   * Executes an operation with retry logic\n   *\n   * @param operation - Async function to execute with retries\n   * @returns Promise resolving to operation result\n   * @throws Error if all retry attempts fail\n   */\n  async execute<T>(operation: () => Promise<T>): Promise<T> {\n    this.attempts = 0;\n\n    while (this.attempts < this.config.maxRetries) {\n      try {\n        const result = await operation();\n        if (this.attempts > 0) {\n          logger.info('Operation succeeded after retry');\n        }\n        return result;\n      } catch (error) {\n        this.attempts++;\n\n        if (this.attempts >= this.config.maxRetries) {\n          logger.error(`Max retry attempts (${this.config.maxRetries}) reached`);\n          throw error;\n        }\n\n        const delay = this.calculateBackoff(this.attempts);\n        logger.warn(\n          `Operation failed (attempt ${this.attempts}/${this.config.maxRetries}), retrying in ${delay}ms...`,\n          { error: error instanceof Error ? error.message : String(error) },\n        );\n\n        await this.sleep(delay);\n      }\n    }\n\n    throw new Error('Retry logic failed unexpectedly');\n  }\n\n  /**\n   * Handles connection errors with retry tracking\n   *\n   * @param error - Error that occurred\n   * @param testConnection - Function to test if connection is restored\n   */\n  async handleConnectionError(error: Error, testConnection: () => Promise<boolean>): Promise<void> {\n    this.attempts++;\n\n    logger.error(\n      `Connection error (attempt ${this.attempts}/${this.config.maxRetries}):`,\n      error.message,\n    );\n\n    if (this.attempts < this.config.maxRetries) {\n      const delay = this.calculateBackoff(this.attempts);\n      logger.info(`Retrying connection in ${delay}ms...`);\n\n      await this.sleep(delay);\n\n      try {\n        const isHealthy = await testConnection();\n        if (isHealthy) {\n          logger.info('Connection restored');\n          this.attempts = 0; // Reset on successful connection\n        } else {\n          logger.error('Connection test failed after retry');\n        }\n      } catch (retryError) {\n        logger.error('Retry failed:', retryError);\n      }\n    } else {\n      logger.error('Max connection retry attempts reached');\n    }\n  }\n\n  /**\n   * Resets the attempt counter\n   * Call this after a successful operation\n   */\n  reset(): void {\n    this.attempts = 0;\n  }\n\n  /**\n   * Gets the current attempt count\n   */\n  getAttempts(): number {\n    return this.attempts;\n  }\n\n  /**\n   * Calculates exponential backoff delay\n   *\n   * @param attempt - Current attempt number (1-indexed)\n   * @returns Delay in milliseconds\n   */\n  private calculateBackoff(attempt: number): number {\n    const base = this.config.baseDelay * Math.pow(2, attempt - 1);\n    const jitter = Math.random() * 0.1 * base;\n    return base + jitter;\n  }\n\n  /**\n   * Sleeps for the specified duration\n   *\n   * @param ms - Milliseconds to sleep\n   */\n  private sleep(ms: number): Promise<void> {\n    return new Promise(resolve => setTimeout(resolve, ms));\n  }\n}\n"]}