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

package/src/services/mm-api-service/index.ts

@@ -52,8 +52,8 @@ export type {
 /**
  * Types related of labor tickets received from the MM API
  */
+export { MMReceiveLaborTicket } from "./types/receive-types";
 export type {
-  MMReceiveLaborTicket,
   MMReceiveLaborTicketReason,
   MMReceiveLaborTicketWorkOrderOperation,
 };

package/src/services/mm-api-service/mm-api-service.ts

@@ -646,6 +646,34 @@ export class MMApiClient {
     );
   }
 
+  /**
+   * Send connector logs to the MM API
+   * @param logEntry Single log entry to send
+   * @returns Promise with the API response
+   */
+  async sendConnectorLog(logEntry: { source: string; level: string; message: string }): Promise<MMApiBaseResponse> {
+    return await this.postData(
+      '/connector/logs',
+      logEntry,
+      {},
+      { baseUrl: UrlBase.ApiBase }
+    );
+  }
+
+  /**
+   * Send bulk connector logs to the MM API
+   * @param logs Array of log entries to send
+   * @returns Promise with the API response
+   */
+  async sendBulkConnectorLogs(logs: { source: string; level: string; message: string }[]): Promise<MMApiBaseResponse> {
+    return await this.postData(
+      '/connector/logs',
+      { logs },
+      {},
+      { baseUrl: UrlBase.ApiBase }
+    );
+  }
+
   async deleteFailedLaborTicketIds(
     system: ERPType,
     laborTicketRefs: string[]

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

@@ -0,0 +1,9 @@
+export interface PsqlConfiguration {
+  host: string;
+  port: string;
+  database: string;
+  username: string;
+  password: string;
+  connectionTimeout?: string;
+  requestTimeout?: string;
+}

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

@@ -0,0 +1,28 @@
+import { PsqlService } from "./psql-service";
+import { PsqlLaborTicketOperations } from "./internal/psql-labor-ticket-operations";
+
+/**
+ * A class to manage interactions with PSQL (Pervasive) databases via ODBC
+ */
+export { PsqlService };
+
+/**
+ * Labor ticket operations for PSQL (Phase 2)
+ */
+export { PsqlLaborTicketOperations };
+
+/**
+ * Configuration interface for PSQL connections
+ */
+export type { PsqlConfiguration } from "./configuration";
+
+/**
+ * Helper functions for PSQL data formatting
+ */
+export {
+  formatPsqlDate,
+  formatPsqlTime,
+  combinePsqlDateTime,
+  isPsqlDateEmpty,
+  cleanPsqlCharField,
+} from "./psql-helpers";

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

@@ -0,0 +1,13 @@
+import { z } from "zod";
+
+export const PsqlConfigSchema = z.object({
+  host: z.string().nonempty("Host is required."),
+  port: z.string().nonempty("Port is required."),
+  database: z.string().nonempty("Database name is required."),
+  username: z.string().nonempty("Username is required."),
+  password: z.string().nonempty("Password is required."),
+  connectionTimeout: z.string().optional().default("15000"),
+  requestTimeout: z.string().optional().default("15000"),
+});
+
+export type PsqlConfig = z.infer<typeof PsqlConfigSchema>;

package/src/services/psql-erp-service/internal/psql-labor-ticket-operations.ts

@@ -0,0 +1,58 @@
+/**
+ * PSQL Labor Ticket Operations
+ *
+ * Phase 2: This will handle INSERT/UPDATE/DELETE operations for labor tickets
+ * Phase 1: Placeholder - throws errors if called
+ */
+
+import { PsqlService } from "../psql-service";
+import { MMReceiveLaborTicket } from "../../../services/mm-api-service";
+import logger from "../../reporting-service/logger";
+
+export class PsqlLaborTicketOperations {
+  constructor(private service: PsqlService) {}
+
+  /**
+   * Create labor ticket in START_LABOR table
+   *
+   * Phase 2 Implementation Notes:
+   * - Will use prepared statements with parameter binding
+   * - Insert into START_LABOR table
+   * - Return GUID as erpUid
+   *
+   * @param laborTicket Labor ticket from MachineMetrics
+   * @returns Labor ticket and ERP unique ID
+   */
+  async createLaborTicket(
+    laborTicket: MMReceiveLaborTicket
+  ): Promise<{ laborTicket: MMReceiveLaborTicket; erpUid: string }> {
+    logger.warn(
+      "PsqlLaborTicketOperations.createLaborTicket not yet implemented (Phase 2)"
+    );
+    throw new Error(
+      "Labor ticket creation not implemented for PSQL. This is a Phase 2 feature."
+    );
+  }
+
+  /**
+   * Update labor ticket (move from START_LABOR to COMPLETED_LABOR)
+   *
+   * Phase 2 Implementation Notes:
+   * - Insert into COMPLETED_LABOR
+   * - Delete from START_LABOR
+   * - Should be done in a transaction
+   *
+   * @param laborTicket Labor ticket to update
+   * @returns Updated labor ticket
+   */
+  async updateLaborTicket(
+    laborTicket: MMReceiveLaborTicket
+  ): Promise<MMReceiveLaborTicket> {
+    logger.warn(
+      "PsqlLaborTicketOperations.updateLaborTicket not yet implemented (Phase 2)"
+    );
+    throw new Error(
+      "Labor ticket update not implemented for PSQL. This is a Phase 2 feature."
+    );
+  }
+}

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

@@ -0,0 +1,17 @@
+/**
+ * PSQL-specific type definitions
+ */
+
+export interface PsqlConnectionOptions {
+  connectionString: string;
+}
+
+export interface OdbcError {
+  state: string;
+  message: string;
+  code?: number;
+}
+
+export interface OdbcErrorResponse extends Error {
+  odbcErrors?: OdbcError[];
+}

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

@@ -0,0 +1,90 @@
+/**
+ * Helper functions for PSQL/Pervasive database operations
+ */
+
+/**
+ * Formats a date from PSQL YYMMDD format to ISO date string
+ * @param psqlDate Date in YYMMDD format (e.g., "250105" for Jan 5, 2025)
+ * @returns ISO date string (e.g., "2025-01-05") or null if invalid
+ */
+export function formatPsqlDate(psqlDate: string): string | null {
+  if (!psqlDate || psqlDate === "000000" || psqlDate.trim() === "") {
+    return null;
+  }
+
+  try {
+    const year = parseInt(psqlDate.substring(0, 2), 10);
+    const month = parseInt(psqlDate.substring(2, 4), 10);
+    const day = parseInt(psqlDate.substring(4, 6), 10);
+
+    // Convert 2-digit year to 4-digit (assuming 2000s)
+    const fullYear = year + 2000;
+
+    // Basic validation
+    if (month < 1 || month > 12 || day < 1 || day > 31) {
+      return null;
+    }
+
+    const date = new Date(fullYear, month - 1, day);
+    return date.toISOString().split("T")[0];
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Formats a time from PSQL HHMM format to HH:MM:SS
+ * @param psqlTime Time in HHMM format (e.g., "1430" for 2:30 PM)
+ * @returns Time string in HH:MM:SS format or null if invalid
+ */
+export function formatPsqlTime(psqlTime: string): string | null {
+  if (!psqlTime || psqlTime.trim() === "") {
+    return null;
+  }
+
+  try {
+    const hours = psqlTime.substring(0, 2);
+    const minutes = psqlTime.substring(2, 4);
+    return `${hours}:${minutes}:00`;
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Combines PSQL date and time into ISO datetime string
+ * @param psqlDate Date in YYMMDD format
+ * @param psqlTime Time in HHMM format
+ * @returns ISO datetime string or null if invalid
+ */
+export function combinePsqlDateTime(
+  psqlDate: string,
+  psqlTime: string
+): string | null {
+  const date = formatPsqlDate(psqlDate);
+  const time = formatPsqlTime(psqlTime);
+
+  if (!date || !time) {
+    return null;
+  }
+
+  return `${date}T${time}`;
+}
+
+/**
+ * Helper to check if a PSQL date is "empty" (000000 or blank)
+ */
+export function isPsqlDateEmpty(psqlDate: string): boolean {
+  return !psqlDate || psqlDate === "000000" || psqlDate.trim() === "";
+}
+
+/**
+ * Clean and trim PSQL CHAR field (removes trailing spaces)
+ * PSQL CHAR fields are fixed-width and padded with spaces
+ */
+export function cleanPsqlCharField(value: string | null | undefined): string {
+  if (value === null || value === undefined) {
+    return "";
+  }
+  return String(value).trim();
+}

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/utils/application-initializer.ts

@@ -41,7 +41,7 @@ export class ApplicationInitializer {
       );
     } catch (error) {
       logger.error("Critical initialization failure. Exiting.", error);
-      process.exit(1);
+      process.exitCode = 1;
     }
   }
 

package/src/utils/connector-factory.ts

@@ -1,5 +1,6 @@
 import { IERPConnector } from "../types/erp-connector";
 import logger from "../services/reporting-service/logger";
+import { pathToFileURL } from "url";
 
 /**
  * Helper function to dynamically import and create connector instance from a file path
@@ -10,8 +11,18 @@ export const createConnectorFromPath = async (
   connectorPath: string
 ): Promise<IERPConnector> => {
   try {
-    // Dynamic import the connector module
-    const connectorModule = await import(connectorPath);
+    // Some detailed debug logging to help with troubleshooting multi-platform connector paths
+    const pathParts = connectorPath.split('/');
+    const filename = pathParts[pathParts.length - 1];
+
+    logger.debug("createConnectorFromPath:", {
+      connectorPath,
+      pathParts,
+      filename,
+      finalImport: pathToFileURL(connectorPath).href,
+    });
+
+    const connectorModule = await import(pathToFileURL(connectorPath).href);
 
     // Get the default export or named export
     const ConnectorClass =
@@ -31,4 +42,4 @@ export const createConnectorFromPath = async (
     );
     throw error;
   }
-};
+};