@machinemetrics/mm-erp-sdk 0.1.4 → 0.1.6-beta.0

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

@@ -0,0 +1,215 @@
+import odbc from "odbc";
+import { PsqlConfiguration } from "./configuration";
+import { ERPResponse } from "../../types/erp-types";
+import { OdbcErrorResponse } from "./internal/types/psql-types";
+import logger from "../reporting-service/logger";
+
+type PagingParams = {
+  limit?: number;
+  offset?: number;
+};
+
+export class PsqlService {
+  private connection: odbc.Connection | null = null;
+  private config: PsqlConfiguration;
+
+  constructor(config: PsqlConfiguration) {
+    this.config = config;
+  }
+
+  async dispose() {
+    await this.closeConnection();
+  }
+
+  /**
+   * 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 (
+      [
+        "Driver={Pervasive ODBC Interface}",
+        `ServerName=${serverName}`,
+        `DBQ=${this.config.database}`,
+        `UID=${this.config.username}`,
+        `PWD=${this.config.password}`,
+        "AutoDoubleQuote=0",
+      ].join(";") + ";"
+    );
+  }
+
+  /**
+   * Execute a query and return the results
+   * Interface matches SqlServerService for consistency
+   *
+   * @param query The SQL query to execute
+   * @param params Query parameters (currently unused for PSQL read operations)
+   * @param paging Optional paging parameters
+   * @returns The entities fetched from the database, along with paging information
+   */
+  public async executePreparedStatement(
+    query: string,
+    params: Record<string, string> = {},
+    paging?: PagingParams
+  ): Promise<ERPResponse | undefined> {
+    const connection = await this.openConnection();
+
+    let records;
+    try {
+      // For Phase 1 (read-only), we execute queries directly
+      // Phase 2 will add proper parameter binding for INSERT/UPDATE/DELETE
+      if (Object.keys(params).length > 0) {
+        logger.warn(
+          "PsqlService: Query parameters provided but parameter binding not yet implemented. " +
+            "Using direct query execution. This is acceptable for Phase 1 read operations."
+        );
+      }
+
+      records = await connection.query(query);
+    } catch (error) {
+      const errorInfo = error as OdbcErrorResponse;
+      logger.error("Error fetching data from PSQL", {
+        error: errorInfo.message,
+        odbcErrors: errorInfo.odbcErrors,
+      });
+
+      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);
+    }
+  }
+
+  /**
+   * 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)) {
+      return [];
+    }
+
+    const data: Record<string, string>[] = recordset.map((row) => {
+      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() : "";
+      });
+      return transformedRow;
+    });
+
+    return data;
+  }
+
+  /**
+   * Handle ODBC errors and provide meaningful messages
+   */
+  private handleOdbcError(error: OdbcErrorResponse): Error {
+    const odbcError = error.odbcErrors?.[0];
+    const errorCode = odbcError?.state;
+    const message = odbcError?.message || error.message;
+
+    switch (errorCode) {
+      case "08S01":
+        return new Error(
+          "PSQL connection failed. Check: " +
+            "1) PVSW environment variable set to /usr/local/psql/etc/pvsw.ini, " +
+            "2) Network connectivity to ports 1583/3351, " +
+            "3) ODBC configuration files in /usr/local/psql/etc/ and /etc/. " +
+            `Original error: ${message}`
+        );
+      case "28000":
+        return new Error(
+          `PSQL authentication failed. Check username/password. Original error: ${message}`
+        );
+      case "42000":
+        return new Error(`PSQL SQL syntax error. Original error: ${message}`);
+      case "42S02":
+        return new Error(
+          `PSQL table or view not found. Check table names in query. Original error: ${message}`
+        );
+      default:
+        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/types/erp-types.ts

@@ -7,6 +7,7 @@ export enum ERPType {
   PROSHOP = "PROSHOP",
   SYTELINE = "SYTELINE",
   TEMPLATE = "TEMPLATE",
+  GLOBALSHOP = "GLOBALSHOP",
 }
 
 export enum ERPObjType {