@machinemetrics/mm-erp-sdk 0.1.7-beta.3 → 0.1.8-beta.1

package/src/services/psql-erp-service/psql-service.ts

@@ -10,23 +10,22 @@ type PagingParams = {
 };
 
 export class PsqlService {
-  private connection: odbc.Connection | null = null;
   private config: PsqlConfiguration;
 
   constructor(config: PsqlConfiguration) {
     this.config = config;
   }
 
-  async dispose() {
-    await this.closeConnection();
-  }
+  // REMOVED: dispose() method - not needed anymore
+  // REMOVED: connection property - not needed anymore
+  // REMOVED: openConnection() method - not needed anymore
+  // REMOVED: closeConnection() method - not needed anymore
 
   /**
    * Build PSQL ODBC connection string
    * CRITICAL: ServerName must use IP.PORT format (e.g., 10.4.0.11.1583)
    */
   private buildConnectionString(): string {
-    // PSQL requires ServerName in format IP.PORT (not IP:PORT)
     const serverName = `${this.config.host}.${this.config.port}`;
 
     return (
@@ -43,7 +42,7 @@ export class PsqlService {
 
   /**
    * Execute a query and return the results
-   * Interface matches SqlServerService for consistency
+   * Creates a fresh connection for each query to avoid handle corruption
    *
    * @param query The SQL query to execute
    * @param params Query parameters (currently unused for PSQL read operations)
@@ -55,12 +54,14 @@ export class PsqlService {
     params: Record<string, string> = {},
     paging?: PagingParams
   ): Promise<ERPResponse | undefined> {
-    const connection = await this.openConnection();
+    let connection: odbc.Connection | null = null;
 
-    let records;
     try {
-      // For Phase 1 (read-only), we execute queries directly
-      // Phase 2 will add proper parameter binding for INSERT/UPDATE/DELETE
+      // Create fresh connection for THIS query only
+      const connStr = this.buildConnectionString();
+      logger.debug("Creating fresh PSQL connection for query");
+      connection = await odbc.connect(connStr);
+
       if (Object.keys(params).length > 0) {
         logger.warn(
           "PsqlService: Query parameters provided but parameter binding not yet implemented. " +
@@ -68,85 +69,62 @@ export class PsqlService {
         );
       }
 
-      records = await connection.query(query);
+      const records = await connection.query(query);
+      const allRecords = PsqlService.recordsetToRecords(records);
+      const rowsFetched = allRecords.length;
+
+      // Apply paging if requested
+      const pagedData =
+        paging?.offset !== undefined || paging?.limit !== undefined
+          ? allRecords.slice(
+              paging.offset || 0,
+              (paging.offset || 0) + (paging.limit || allRecords.length)
+            )
+          : allRecords;
+
+      return {
+        data: pagedData,
+        paging: {
+          count: rowsFetched,
+          limit: paging?.limit || 0,
+          offset: paging?.offset || 0,
+          nextPage:
+            paging?.limit && (paging.offset || 0) + paging.limit < rowsFetched
+              ? String((paging.offset || 0) + paging.limit)
+              : undefined,
+          previousPage: paging?.offset
+            ? String(Math.max(0, (paging.offset || 0) - (paging.limit || 10)))
+            : undefined,
+        },
+      };
     } catch (error) {
       const errorInfo = error as OdbcErrorResponse;
       logger.error("Error fetching data from PSQL", {
         error: errorInfo.message,
         odbcErrors: errorInfo.odbcErrors,
+        query: query.substring(0, 200), // Log first 200 chars of query
       });
 
       throw this.handleOdbcError(errorInfo);
-    }
-
-    const allRecords = PsqlService.recordsetToRecords(records);
-    const rowsFetched = allRecords.length;
-
-    // Apply paging if requested
-    const pagedData =
-      paging?.offset !== undefined || paging?.limit !== undefined
-        ? allRecords.slice(
-            paging.offset || 0,
-            (paging.offset || 0) + (paging.limit || allRecords.length)
-          )
-        : allRecords;
-
-    return {
-      data: pagedData,
-      paging: {
-        count: rowsFetched,
-        limit: paging?.limit || 0,
-        offset: paging?.offset || 0,
-        nextPage:
-          paging?.limit && (paging.offset || 0) + paging.limit < rowsFetched
-            ? String((paging.offset || 0) + paging.limit)
-            : undefined,
-        previousPage: paging?.offset
-          ? String(Math.max(0, (paging.offset || 0) - (paging.limit || 10)))
-          : undefined,
-      },
-    };
-  }
-
-  /**
-   * Opens a connection to PSQL database
-   * Caches the connection so that it can be reused.
-   * On failure to connect, throws
-   */
-  async openConnection(): Promise<odbc.Connection> {
-    // If we have a connection, reuse it
-    // Note: ODBC connections don't have a .connected property like SQL Server
-    // We'll keep it simple and reuse if not null
-    if (this.connection) {
-      logger.debug("Reusing existing PSQL connection");
-      return this.connection;
-    }
-
-    try {
-      const connStr = this.buildConnectionString();
-      logger.info("Opening new PSQL connection");
-      logger.debug(
-        "Connection string (password hidden):",
-        connStr.replace(/PWD=[^;]+/, "PWD=***")
-      );
-
-      this.connection = await odbc.connect(connStr);
-      logger.info("Successfully connected to PSQL database");
-      return this.connection;
-    } catch (error) {
-      logger.error("PsqlService>>openConnection>> Connection failed", {
-        error,
-      });
-      throw this.handleOdbcError(error as OdbcErrorResponse);
+    } finally {
+      // CRITICAL: Always close connection, even on error
+      if (connection) {
+        try {
+          await connection.close();
+          logger.debug("PSQL connection closed successfully");
+        } catch (err) {
+          // Don't throw on close errors, just log
+          logger.warn("Error closing PSQL connection (non-fatal)", {
+            error: err,
+          });
+        }
+      }
     }
   }
 
   /**
    * Transform ODBC result set to array of Record<string, string> instances.
    * IMPORTANT: PSQL CHAR fields are often padded with spaces - we trim them
-   *
-   * @param recordset Result set from ODBC query
-   * @returns array of Record<string, string> instances
    */
   public static recordsetToRecords(recordset: any[]): Record<string, string>[] {
     if (!Array.isArray(recordset)) {
@@ -157,7 +135,6 @@ export class PsqlService {
       const transformedRow: Record<string, string> = {};
       Object.keys(row).forEach((key) => {
         const value = row[key];
-        // Convert to string and trim (PSQL CHAR fields have trailing spaces)
         transformedRow[key] =
           value !== null && value !== undefined ? String(value).trim() : "";
       });
@@ -198,18 +175,4 @@ export class PsqlService {
         return new Error(`PSQL error (${errorCode || "unknown"}): ${message}`);
     }
   }
-
-  private async closeConnection(): Promise<void> {
-    if (this.connection) {
-      logger.info("Closing PSQL connection");
-      try {
-        await this.connection.close();
-      } catch (error) {
-        logger.error("PsqlService::closeConnection: Error closing connection", {
-          error,
-        });
-      }
-      this.connection = null;
-    }
-  }
 }

package/src/services/reporting-service/logger.ts

@@ -78,20 +78,95 @@ const logger = createLogger({
 
 // Function to reconfigure the logger once CoreConfiguration is available
 export const configureLogger = (logLevel: string, nodeEnv: string) => {
-  // Remove existing transports
+  // Remove existing transports (safely): close any DailyRotateFile streams first
+  try {
+    const existingFileTransports = (logger.transports || []).filter(
+      (t: any) => t instanceof DailyRotateFile
+    );
+    for (const t of existingFileTransports) {
+      const s = (t as any).logStream;
+      if (s && typeof s.end === "function") {
+        try {
+          s.end();
+        } catch {}
+      }
+    }
+  } catch {}
+
   logger.clear();
 
   // Add file transport
-  logger.add(
-    new DailyRotateFile({
-      filename: path.join(logDirectory, "%DATE%.log"),
-      datePattern: "YYYY-MM-DD",
-      zippedArchive: true,
-      maxSize: "20m",
-      maxFiles: "14d",
-      format: logFormat,
-    })
-  );
+  const fileTransport = new DailyRotateFile({
+    filename: path.join(logDirectory, "%DATE%.log"),
+    datePattern: "YYYY-MM-DD",
+    zippedArchive: true,
+    maxSize: "20m",
+    maxFiles: "14d",
+    format: logFormat,
+  });
+  logger.add(fileTransport);
+
+  // Rotate-time mitigation for long-running single-process apps
+  let isRefreshing = false;
+  fileTransport.on("rotate", (_oldFilename: string, _newFilename: string) => {
+    if (isRefreshing) return;
+    isRefreshing = true;
+    (logger as any).silent = true; // gate writes during refresh to avoid write-after-end
+
+    try {
+      // Close all existing DailyRotateFile streams
+      const existing = (logger.transports || []).filter(
+        (t: any) => t instanceof DailyRotateFile
+      );
+      for (const t of existing) {
+        const s = (t as any).logStream;
+        if (s && typeof s.end === "function") {
+          try {
+            s.end();
+          } catch {}
+        }
+      }
+
+      // Refresh the file transport cleanly
+      logger.clear();
+      const refreshed = new DailyRotateFile({
+        filename: path.join(logDirectory, "%DATE%.log"),
+        datePattern: "YYYY-MM-DD",
+        zippedArchive: true,
+        maxSize: "20m",
+        maxFiles: "14d",
+        format: logFormat,
+      });
+
+      // Once new file stream is ready, resume writes
+      refreshed.on("new", () => {
+        (logger as any).silent = false;
+        isRefreshing = false;
+      });
+
+      logger.add(refreshed);
+
+      // Preserve console transport behavior in non-production
+      if (nodeEnv !== "production") {
+        logger.add(
+          new transports.Console({
+            format: format.combine(
+              format.timestamp(),
+              format.splat(),
+              baseFormat,
+              format.colorize({ all: true })
+            ),
+          })
+        );
+      }
+
+      logger.level = logLevel;
+    } catch {
+      // If anything goes wrong, resume writes to avoid permanent silence
+      (logger as any).silent = false;
+      isRefreshing = false;
+    }
+  });
 
   // Add console transport in non-production environments
   if (nodeEnv !== "production") {