@machinemetrics/mm-erp-sdk 0.1.6-beta.2 → 0.1.7-beta.1

package/src/services/data-sync-service/jobs/from-erp.ts

@@ -7,6 +7,18 @@ import { createConnectorFromPath } from "../../../utils/connector-factory";
 // Configure the logger with the correct log level
 logger.level = process.env.LOG_LEVEL || "info";
 
+// Enable garbage collection on exit if available
+if (global.gc) {
+  process.on("exit", () => {
+    logger.debug("from-erp: Running garbage collection on exit");
+    try {
+      global.gc?.();
+    } catch (e) {
+      // Ignore GC errors
+    }
+  });
+}
+
 const main = async () => {
   try {
     logger.info('Worker for job "from-erp" online');
@@ -14,7 +26,7 @@ const main = async () => {
 
     // Get the connector path from the environment variable
     const connectorPath = process.env.CONNECTOR_PATH;
- 
+
     if (!connectorPath) {
       throw new Error("Connector path not provided in environment variables");
     }
@@ -28,6 +40,23 @@ const main = async () => {
 
     await connector.syncFromERPCompleted();
     logger.info("==========Completed from-erp job cycle==========");
+
+    // Cleanup before worker exit
+    logger.debug("from-erp: Starting cleanup sequence");
+
+    // Trigger garbage collection if available
+    if (global.gc) {
+      logger.debug("from-erp: Running manual garbage collection");
+      try {
+        global.gc?.();
+      } catch (e) {
+        logger.debug("from-erp: GC not available or failed");
+      }
+    }
+
+    // Small delay to allow any pending operations to complete
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    logger.debug("from-erp: Cleanup sequence completed");
   } catch (error) {
     const errorDetails = {
       message: error instanceof Error ? error.message : String(error),
@@ -46,10 +75,10 @@ const main = async () => {
 // Cross-platform module detection fix for Bree compatibility
 // Windows: process.argv[1] uses backslashes, import.meta.url uses forward slashes
 // Linux/Mac: both use forward slashes, so this normalization is safe
-const normalizedArgv1 = process.argv[1].replace(/\\/g, '/');
-const fileUrl = normalizedArgv1.startsWith('/') ? 
-  `file://${normalizedArgv1}` :  // Unix: file:// + /path = file:///path
-  `file:///${normalizedArgv1}`;  // Windows: file:/// + C:/path = file:///C:/path
+const normalizedArgv1 = process.argv[1].replace(/\\/g, "/");
+const fileUrl = normalizedArgv1.startsWith("/")
+  ? `file://${normalizedArgv1}` // Unix: file:// + /path = file:///path
+  : `file:///${normalizedArgv1}`; // Windows: file:/// + C:/path = file:///C:/path
 const isMainModule = import.meta.url === fileUrl;
 
 if (isMainModule) {
@@ -61,4 +90,4 @@ if (isMainModule) {
   }
 }
 
-export default main;
+export default main;

package/src/services/data-sync-service/jobs/to-erp.ts

@@ -1,11 +1,24 @@
 import "dotenv/config";
 
-import logger from "../../reporting-service/logger";
+import logger from "../../../services/reporting-service/logger";
+import { SQLiteCoordinator } from "../../sqlite-service";
 import { createConnectorFromPath } from "../../../utils/connector-factory";
 
 // Configure the logger with the correct log level
 logger.level = process.env.LOG_LEVEL || "info";
 
+// Enable garbage collection on exit if available
+if (global.gc) {
+  process.on("exit", () => {
+    logger.debug("to-erp: Running garbage collection on exit");
+    try {
+      global.gc?.();
+    } catch (e) {
+      // Ignore GC errors
+    }
+  });
+}
+
 const main = async () => {
   try {
     logger.info('Worker for job "to-erp" online');
@@ -25,6 +38,23 @@ const main = async () => {
     await connector.syncToERPCompleted();
 
     logger.info("==========Completed to-erp job cycle==========");
+
+    // Cleanup before worker exit
+    logger.debug("to-erp: Starting cleanup sequence");
+
+    // Trigger garbage collection if available
+    if (global.gc) {
+      logger.debug("to-erp: Running manual garbage collection");
+      try {
+        global.gc?.();
+      } catch (e) {
+        logger.debug("to-erp: GC not available or failed");
+      }
+    }
+
+    // Small delay to allow any pending operations to complete
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    logger.debug("to-erp: Cleanup sequence completed");
   } catch (error) {
     const errorDetails = {
       message: error instanceof Error ? error.message : String(error),
@@ -47,10 +77,10 @@ const main = async () => {
 // Cross-platform module detection fix for Bree compatibility
 // Windows: process.argv[1] uses backslashes, import.meta.url uses forward slashes
 // Linux/Mac: both use forward slashes, so this normalization is safe
-const normalizedArgv1 = process.argv[1].replace(/\\/g, '/');
-const fileUrl = normalizedArgv1.startsWith('/') ? 
-  `file://${normalizedArgv1}` :  // Unix: file:// + /path = file:///path
-  `file:///${normalizedArgv1}`;  // Windows: file:/// + C:/path = file:///C:/path
+const normalizedArgv1 = process.argv[1].replace(/\\/g, "/");
+const fileUrl = normalizedArgv1.startsWith("/")
+  ? `file://${normalizedArgv1}` // Unix: file:// + /path = file:///path
+  : `file:///${normalizedArgv1}`; // Windows: file:/// + C:/path = file:///C:/path
 const isMainModule = import.meta.url === fileUrl;
 
 if (isMainModule) {

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,178 @@
+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 config: PsqlConfiguration;
+
+  constructor(config: PsqlConfiguration) {
+    this.config = config;
+  }
+
+  // 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 {
+    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
+   * 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)
+   * @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> {
+    let connection: odbc.Connection | null = null;
+
+    try {
+      // 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. " +
+            "Using direct query execution. This is acceptable for Phase 1 read operations."
+        );
+      }
+
+      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);
+    } 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
+   */
+  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];
+        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}`);
+    }
+  }
+}

package/src/types/erp-types.ts

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

package/src/utils/standard-process-drivers/labor-ticket-erp-synchronizer.ts

@@ -57,8 +57,7 @@ export class LaborTicketERPSynchronizer {
       // the checkpoint to ensure there is no gap of time for the next sync.
       const mostRecentUpdate = laborTicketsUpdates.reduce(
         (latest: string | null, ticket: MMReceiveLaborTicket) => {
-          if (!ticket.updatedAt) return latest;
-          if (!latest) return ticket.updatedAt;
+          if (!latest || !ticket.updatedAt) return latest;
           return new Date(ticket.updatedAt) > new Date(latest)
             ? ticket.updatedAt
             : latest;