@machinemetrics/mm-erp-sdk 0.1.9 → 0.2.0-beta.1

package/src/services/caching-service/hashed-cache-manager.ts

@@ -1,11 +1,11 @@
 import knex, { Knex } from "knex";
-import config from "../../knexfile.js";
+import config from "../../knexfile";
 import stringify from "json-stable-stringify";
 import XXH from "xxhashjs";
-import { ERPObjType } from "../../types/erp-types.js";
-import { CacheMetrics } from "./index.js";
-import { CoreConfiguration } from "../data-sync-service/configuration-manager.js";
-import { logger } from "../reporting-service/index.js";
+import { ERPObjType } from "../../types/erp-types";
+import { CacheMetrics } from "./index";
+import { CoreConfiguration } from "../data-sync-service/configuration-manager";
+import { logger } from "../reporting-service";
 
 type HashedCacheManagerOptions = {
   ttl?: number;

package/src/services/caching-service/index.ts

@@ -1,4 +1,4 @@
-import { ERPObjType, ERPObject } from "../../types/erp-types.js";
+import { ERPObjType, ERPObject } from "../../types/erp-types";
 
 export interface CacheServiceConfig {
   tableName: string;

package/src/services/caching-service/record-tracking-manager.ts

@@ -1,6 +1,6 @@
 import knex, { Knex } from "knex";
-import config from "../../knexfile.js";
-import { ERPObjType } from "../../types/erp-types.js";
+import config from "../../knexfile";
+import { ERPObjType } from "../../types/erp-types";
 
 const DEFAULT_RECORD_TRACKING_TABLE_NAME = "record_tracking";
 

package/src/services/data-sync-service/configuration-manager.ts

@@ -1,6 +1,6 @@
 import "dotenv/config";
-import { configureLogger } from "../reporting-service/logger.js";
-import { SQLServerConfiguration } from "../sql-server-erp-service/configuration.js";
+import { configureLogger } from "../reporting-service/logger";
+import { SQLServerConfiguration } from "../sql-server-erp-service/configuration";
 
 export class CoreConfiguration {
   private static instance: CoreConfiguration;

package/src/services/data-sync-service/data-sync-service.ts

@@ -2,19 +2,23 @@ import Bree, { Job } from "bree";
 import Graceful from "@ladjs/graceful";
 import path from "path";
 import { fileURLToPath } from "url";
-import { CoreConfiguration } from "./configuration-manager.js";
-import logger from "../reporting-service/logger.js";
-
-type GracefulConstructor = new (config: { brees: Bree[] }) => {
-  listen: () => void;
-};
-
-const GracefulClass = Graceful as unknown as GracefulConstructor;
+import { CoreConfiguration } from "./configuration-manager";
+import logger from "../reporting-service/logger";
+import { createConnectorFromPath } from "../../utils/connector-factory";
+import { NatsLaborTicketListener } from "./nats-labor-ticket-listener";
 
 export const runDataSyncService = async (connectorPath: string) => {
   const config = CoreConfiguration.inst();
 
   try {
+    // Create connector instance
+    const connector = await createConnectorFromPath(connectorPath);
+
+    // Start NATS listener if enabled
+    if (process.env.NATS_ENABLED === "true") {
+      const natsListener = new NatsLaborTicketListener(connector);
+      await natsListener.start();
+    }
     // Find the SDK's node_modules directory and jobs path using ES module import
     const currentFileUrl = import.meta.url;
     const currentFilePath = fileURLToPath(currentFileUrl);
@@ -23,7 +27,12 @@ export const runDataSyncService = async (connectorPath: string) => {
     // Current: /path/to/sdk/dist/mm-erp-sdk.js.js
     // Target:  /path/to/sdk/dist/services/data-sync-service/jobs
     const sdkDistPath = path.dirname(currentFilePath);
-    const jobsPath = path.join(sdkDistPath, "jobs");
+    const jobsPath = path.join(
+      sdkDistPath,
+      "services",
+      "data-sync-service",
+      "jobs"
+    );
 
     const bree = new Bree({
       root: jobsPath,
@@ -79,7 +88,7 @@ export const runDataSyncService = async (connectorPath: string) => {
     }));
     logger.info("JOBS CONFIGURATION:", { jobs: jobsConfig });
 
-    const graceful = new GracefulClass({ brees: [bree] });
+    const graceful = new Graceful({ brees: [bree] });
     graceful.listen();
 
     (async () => {

package/src/services/data-sync-service/index.ts

@@ -1,11 +1,11 @@
 /**
  * Core data sync service functionality
  */
-export { runDataSyncService } from "./data-sync-service.js";
+export { runDataSyncService } from "./data-sync-service";
 
 /**
  * Configuration management for data sync
  */
-export { getSQLServerConfiguration } from "./configuration-manager.js";
+export { getSQLServerConfiguration } from "./configuration-manager";
 
-export { ErpApiConnectionParams, getErpApiConnectionParams } from "./configuration-manager.js";
+export { ErpApiConnectionParams, getErpApiConnectionParams } from "./configuration-manager";

package/src/services/data-sync-service/jobs/clean-up-expired-cache.ts

@@ -1,7 +1,7 @@
 import "dotenv/config";
-import { HashedCacheManager } from "../../caching-service/hashed-cache-manager.js";
-import { SQLiteCoordinator } from "../../sqlite-service/index.js";
-import logger from "../../../services/reporting-service/logger.js";
+import { HashedCacheManager } from "../../caching-service/hashed-cache-manager";
+import { SQLiteCoordinator } from "../../sqlite-service";
+import logger from "../../../services/reporting-service/logger";
 
 // Configure the logger with the correct log level
 logger.level = process.env.LOG_LEVEL || "info";

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

@@ -1,8 +1,8 @@
 import "dotenv/config";
 
-import logger from "../../../services/reporting-service/logger.js";
-import { SQLiteCoordinator } from "../../sqlite-service/index.js";
-import { createConnectorFromPath } from "../../../utils/connector-factory.js";
+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";
@@ -29,14 +29,9 @@ const main = async () => {
     await connector.syncFromERPCompleted();
     logger.info("==========Completed from-erp job cycle==========");
   } catch (error) {
-    const errorDetails = {
-      message: error instanceof Error ? error.message : String(error),
-      stack: error instanceof Error ? error.stack : undefined,
-      name: error instanceof Error ? error.name : undefined,
-      ...(error && typeof error === "object" ? error : {}), // Include all enumerable properties if it's an object
-    };
+    // Logger now handles circular references and error objects safely
     logger.error('Worker for job "from-erp" had an error', {
-      error: errorDetails,
+      error,
     });
 
     throw error; // Rethrow so Bree can handle it properly

package/src/services/data-sync-service/jobs/retry-failed-labor-tickets.ts

@@ -1,7 +1,7 @@
 import "dotenv/config";
 
-import logger from "../../../services/reporting-service/logger.js";
-import { createConnectorFromPath } from "../../../utils/connector-factory.js";
+import logger from "../../../services/reporting-service/logger";
+import { createConnectorFromPath } from "../../../utils/connector-factory";
 
 // Configure the logger with the correct log level
 logger.level = process.env.LOG_LEVEL || "info";

package/src/services/data-sync-service/jobs/run-migrations.ts

@@ -1,6 +1,6 @@
 import knex, { Knex } from "knex";
-import logger from "../../reporting-service/logger.js";
-import config from "../../../knexfile.js";
+import logger from "../../reporting-service/logger";
+import config from "../../../knexfile";
 
 // Configure the logger with the correct log level
 logger.level = process.env.LOG_LEVEL || "info";

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

@@ -1,7 +1,8 @@
 import "dotenv/config";
 
-import logger from "../../reporting-service/logger.js";
-import { createConnectorFromPath } from "../../../utils/connector-factory.js";
+import logger from "../../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";
@@ -21,7 +22,10 @@ const main = async () => {
     // Create a new connector instance for this job
     const connector = await createConnectorFromPath(connectorPath);
 
-    await connector.syncToERP();
+    await SQLiteCoordinator.executeWithLock("to-erp", async () => {
+      await connector.syncToERP();
+    });
+
     await connector.syncToERPCompleted();
 
     logger.info("==========Completed to-erp job cycle==========");

package/src/services/data-sync-service/nats-labor-ticket-listener.ts

@@ -0,0 +1,341 @@
+import logger from "../reporting-service/logger";
+import { formatError } from "../../utils/error-formatter";
+import { NatsService } from "../nats-service/nats-service";
+import { MMReceiveLaborTicket, MMApiClient, getCompanyInfo } from "../mm-api-service";
+import { SQLiteCoordinator } from "../sqlite-service";
+
+/**
+ * Manages NATS-based real-time labor ticket processing
+ */
+export class NatsLaborTicketListener {
+  private connector: any;
+  private natsService?: NatsService;
+
+  constructor(connector: any) {
+    this.connector = connector;
+  }
+
+  /**
+   * Start listening for labor ticket events via NATS
+   */
+  async start(): Promise<void> {
+    try {
+      // Fetch company info from MM API (includes locationRef)
+      const companyInfo = await getCompanyInfo();
+      const erpType = this.connector.type || "unknown";
+
+      logger.info("Starting NATS listener for labor tickets", {
+        locationRef: companyInfo.locationRef,
+        companyId: companyInfo.companyId,
+        erpType,
+        servers: process.env.NATS_SERVERS || "nats://localhost:4222",
+      });
+
+      this.natsService = new NatsService({
+        servers: process.env.NATS_SERVERS || "nats://localhost:4222",
+        name: `${erpType}-connector`,
+        locationRef: companyInfo.locationRef,
+        erpType,
+        enabled: true,
+        reconnect: true,
+        maxReconnectAttempts: -1,
+        reconnectTimeWait: 2000,
+      });
+
+      // Register health check handler
+      this.registerHealthCheckHandler(companyInfo.locationRef, erpType);
+
+      // Register labor ticket handler
+      this.registerLaborTicketHandler(companyInfo.locationRef, erpType);
+
+      // Connect to NATS
+      await this.natsService.connect();
+
+      logger.info("NATS listener started successfully", {
+        subject: `mm.14.${companyInfo.locationRef}.labor-ticket.*`,
+      });
+    } catch (error) {
+      logger.error("Failed to start NATS listener", { error });
+      // Don't throw - allow REST polling to continue
+    }
+  }
+
+  /**
+   * Register health check handler - responds immediately to let Dashboard know connector is online
+   */
+  private registerHealthCheckHandler(locationRef: string, erpType: string): void {
+    if (!this.natsService) return;
+
+    this.natsService.registerHandler({
+      subject: `mm.14.${locationRef}.erp.health`,
+      description: "Health check - responds immediately to indicate connector is online",
+      handler: {
+        handle: async () => {
+          logger.debug("Health check received, sending pong");
+          return {
+            status: "online",
+            timestamp: new Date().toISOString(),
+            locationRef,
+            erpType,
+          };
+        },
+      },
+    });
+  }
+
+  /**
+   * Register labor ticket processing handler
+   */
+  private registerLaborTicketHandler(locationRef: string, erpType: string): void {
+    if (!this.natsService) return;
+
+    this.natsService.registerHandler({
+      subject: `mm.14.${locationRef}.labor-ticket.*`,
+      description: "Process labor tickets in real-time from NATS",
+      handler: {
+        handle: async ({ data }: any, subject: string) => {
+          const action = subject.split(".").pop();
+          const { actionPayload } = data;
+          const startTime = Date.now();
+          const { laborTicketRef } = actionPayload;
+
+          logger.info("Received labor ticket via NATS", {
+            action,
+            requestId: data.requestId,
+            laborTicketRef,
+          });
+
+          // Use the same lock as to-erp job to prevent concurrent processing
+          return await SQLiteCoordinator.executeWithLock("to-erp", async () => {
+            try {
+              let laborTicketData;
+
+              if (laborTicketRef) {
+                // Fetch the full labor ticket data using the laborTicketRef
+                const mmApiClient = new MMApiClient();
+                const laborTicket = await mmApiClient.fetchLaborTicketByRef(laborTicketRef);
+
+                logger.info("Fetched labor ticket data from MM API", {
+                  laborTicketRef,
+                  laborTicketId: laborTicket.laborTicketId,
+                });
+
+                // Merge changed fields from actionPayload to ensure we process the actual changes
+                laborTicketData = {
+                  ...laborTicket,
+                  ...actionPayload,
+                };
+              } else {
+                // No laborTicketRef provided, use the actionPayload directly
+                logger.info("No laborTicketRef provided, using actionPayload directly", {
+                  requestId: data.requestId,
+                });
+
+                laborTicketData = actionPayload;
+              }
+
+              const mergedLaborTicket = new MMReceiveLaborTicket(laborTicketData);
+
+              // Process labor ticket: ERP operation first, then create MM entities with ERP ID
+              const result = await this.processLaborTicket(
+                mergedLaborTicket,
+                action || "unknown"
+              );
+
+              // Update checkpoint to prevent to-erp polling job from reprocessing this ticket
+              await this.updateCheckpoint(erpType, result);
+
+              // Return response with full labor ticket data for immediate frontend state update
+              return {
+                status: "success",
+                requestId: data.requestId,
+                action,
+                timestamp: new Date().toISOString(),
+                processingTimeMs: Date.now() - startTime,
+                laborTicketRef: result.laborTicketRef,
+                laborTicket: result.laborTicket,
+              };
+            } catch (error) {
+              // Check if error was already formatted in inner catch block
+              const formattedError = (error as any)?._formatted || formatError(error);
+
+              // Debug logging
+              logger.debug("Error details", {
+                hasFormatted: !!(error as any)?._formatted,
+                isAxiosError: (error as any)?.isAxiosError,
+                errorMessage: (error as any)?.message,
+                responseStatus: (error as any)?.response?.status,
+                responseData: (error as any)?.response?.data,
+              });
+
+              logger.error("Error handling labor ticket from NATS", {
+                error: formattedError.message,
+                code: formattedError.code,
+                requestId: data.requestId,
+                laborTicketRef,
+              });
+
+              return {
+                status: "error",
+                requestId: data.requestId,
+                action,
+                timestamp: new Date().toISOString(),
+                processingTimeMs: Date.now() - startTime,
+                error: {
+                  message: formattedError.message,
+                  code: formattedError.code,
+                  httpStatus: formattedError.httpStatus,
+                  metadata: formattedError.metadata,
+                  laborTicketRef,
+                },
+              };
+            }
+          });
+        },
+      },
+    });
+  }
+
+  /**
+   * Process labor ticket in ERP and then create MM entities with ERP ID attached
+   */
+  private async processLaborTicket(
+    laborTicket: MMReceiveLaborTicket,
+    action: string
+  ): Promise<{ laborTicketRef: string; laborTicket: any }> {
+    const { MMEntityProcessor } = await import("../../utils/standard-process-drivers/mm-entity-processor");
+    const { ERPObjType } = await import("../../types/erp-types");
+    const { MMSendLaborTicket } = await import("../mm-api-service");
+
+    logger.info("Processing labor ticket: ERP first, then MM creation", {
+      laborTicketRef: laborTicket.laborTicketRef,
+      action,
+      hasLaborTicketId: !!laborTicket.laborTicketId,
+    });
+
+    try {
+      let erpResult;
+
+      if (action === "create" || !laborTicket.laborTicketId) {
+        // Create new labor ticket in ERP
+        erpResult = await this.connector.createLaborTicketInERP(laborTicket);
+        logger.info("Successfully created labor ticket in ERP", {
+          laborTicketRef: laborTicket.laborTicketRef,
+          erpUid: erpResult.erpUid,
+        });
+      } else {
+        // Update existing labor ticket in ERP
+        erpResult = { laborTicket: await this.connector.updateLaborTicketInERP(laborTicket) };
+        logger.info("Successfully updated labor ticket in ERP", {
+          laborTicketRef: laborTicket.laborTicketRef,
+        });
+      }
+
+      // Now update MM entities with ERP ID attached
+      const laborTicketForMM = { ...laborTicket };
+      if (erpResult.erpUid) {
+        laborTicketForMM.laborTicketId = erpResult.erpUid;
+        
+        // If this was a create (no initial laborTicketId) with a laborTicketRef,
+        // patch the existing orphaned MM record with the new ERP ID first
+        if (!laborTicket.laborTicketId && laborTicketForMM.laborTicketRef) {
+          const mmApiClient = new MMApiClient();
+          await mmApiClient.updateLaborTicketIdByRef(
+            laborTicketForMM.laborTicketRef,
+            erpResult.erpUid
+          );
+          
+          logger.info("Patched existing MM labor ticket with new ERP ID", {
+            laborTicketRef: laborTicketForMM.laborTicketRef,
+            laborTicketId: erpResult.erpUid,
+          });
+        }
+      }
+
+      // Set state based on clockOut before writing to MM
+      laborTicketForMM.state = laborTicketForMM.clockOut ? "CLOSED" : "OPEN";
+
+      // Write all fields to MM (this updates the existing record now that it has laborTicketId)
+      const mmLaborTicket = MMSendLaborTicket.fromPlainObject(laborTicketForMM as any);
+
+      const mmResult = await MMEntityProcessor.writeEntities(
+        ERPObjType.LABOR_TICKETS,
+        [mmLaborTicket],
+        null // No caching for real-time operations
+      );
+
+      logger.info("Successfully updated MM entities after ERP operation", {
+        laborTicketRef: laborTicketForMM.laborTicketRef,
+        laborTicketId: laborTicketForMM.laborTicketId,
+        entitiesCreated: mmResult.upsertedEntities,
+      });
+
+      return {
+        laborTicketRef: laborTicketForMM.laborTicketRef!,
+        laborTicket: laborTicketForMM,
+      };
+    } catch (error) {
+      // Format error to preserve meaningful message
+      const formattedError = formatError(error);
+
+      logger.error("Failed to process labor ticket with MM creation", {
+        laborTicketRef: laborTicket.laborTicketRef,
+        action,
+        error: formattedError.message,
+        code: formattedError.code,
+      });
+
+      // Create enhanced error to propagate
+      const enhancedError: any = error;
+      enhancedError._formatted = formattedError;
+      throw enhancedError;
+    }
+  }
+
+  /**
+   * Update checkpoint to prevent to-erp polling job from reprocessing this ticket
+   * Only updates if the new timestamp is later than the current checkpoint (prevents moving backwards)
+   */
+  private async updateCheckpoint(
+    erpType: string,
+    result: { laborTicketRef: string; laborTicket: any }
+  ): Promise<void> {
+    const mmApiClient = new MMApiClient();
+    const currentCheckpoint = await mmApiClient.getCheckpoint({
+      system: erpType,
+      table: "labor_tickets",
+      checkpointType: "export",
+      checkpointValue: {
+        timestamp: "",
+      },
+    });
+
+    const currentTimestamp = (currentCheckpoint as any)?.timestamp;
+    const newTimestamp = result.laborTicket.updatedAt || new Date().toISOString();
+
+    // Only update checkpoint if new timestamp is later than current (prevents moving backwards)
+    if (!currentTimestamp || new Date(newTimestamp) > new Date(currentTimestamp)) {
+      await mmApiClient.saveCheckpoint({
+        system: erpType,
+        table: "labor_tickets",
+        checkpointType: "export",
+        checkpointValue: {
+          timestamp: newTimestamp,
+        },
+      });
+
+      logger.debug("Updated export checkpoint after NATS processing", {
+        laborTicketRef: result.laborTicketRef,
+        previousCheckpoint: currentTimestamp,
+        newCheckpoint: newTimestamp,
+      });
+    } else {
+      logger.debug("Skipped checkpoint update (timestamp not newer)", {
+        laborTicketRef: result.laborTicketRef,
+        currentCheckpoint: currentTimestamp,
+        ticketTimestamp: newTimestamp,
+      });
+    }
+  }
+}
+

package/src/services/erp-api-services/errors.ts

@@ -1,7 +1,7 @@
 import { AxiosError } from "axios";
-import logger from "../reporting-service/logger.js";
-import { GraphQLServerError } from "./graphql/types.js";
-import { HTTPError } from "../../utils/http-client.js";
+import logger from "../reporting-service/logger";
+import { GraphQLServerError } from "./graphql/types";
+import { HTTPError } from "../../utils/http-client";
 
 /**
  * Represents GraphQL specific errors (validation, missing fields, etc.)

package/src/services/erp-api-services/graphql/graphql-service.ts

@@ -2,11 +2,11 @@ import {
   HTTPClient,
   HTTPClientFactory,
   HTTPResponse,
-} from "../../../utils/http-client.js";
-import { GraphQLResponse } from "./types.js";
-import { ErrorHandler } from "../errors.js";
-import { APIResponse } from "../types.js";
-import { ERPApiConfig } from "../types.js";
+} from "../../../utils/http-client";
+import { GraphQLResponse } from "./types";
+import { ErrorHandler } from "../errors";
+import { APIResponse } from "../types";
+import { ERPApiConfig } from "../types";
 
 const DEFAULT_RETRY_ATTEMPTS = 0; // One try only, no retries
 

package/src/services/erp-api-services/index.ts

@@ -4,19 +4,19 @@
  */
 
 // REST API Service
-export { RestAPIService } from "./rest/rest-api-service.js";
-export type { QueryParams } from "./rest/get-query-params.js";
+export { RestAPIService } from "./rest/rest-api-service";
+export type { QueryParams } from "./rest/get-query-params";
 
 // GraphQL Service
-export { GraphQLService } from "./graphql/graphql-service.js";
-export type { GraphQLServerError } from './graphql/types.js';
+export { GraphQLService } from "./graphql/graphql-service";
+export type { GraphQLServerError } from './graphql/types';
 
 // OAuth Client
-export { OAuthClient } from './oauth-client.js'; 
-export type { OAuthConfig } from './oauth-client.js';
+export { OAuthClient } from './oauth-client'; 
+export type { OAuthConfig } from './oauth-client';
 
 // API Response
-export type { APIResponse } from './types.js';
+export type { APIResponse } from './types';
 
 // Error classes
-export { ErrorHandler, GraphQLError } from './errors.js';
+export { ErrorHandler, GraphQLError } from './errors';

package/src/services/erp-api-services/rest/rest-api-service.ts

@@ -1,11 +1,11 @@
-import { HTTPClient, HTTPClientFactory } from "../../../utils/http-client.js";
+import { HTTPClient, HTTPClientFactory } from "../../../utils/http-client";
 import {
   QueryParams,
   buildLogicalCondition,
   Pagination,
-} from "./get-query-params.js";
-import { ErrorHandler } from "../errors.js";
-import { APIResponse, ERPApiConfig } from "../types.js";
+} from "./get-query-params";
+import { ErrorHandler } from "../errors";
+import { APIResponse, ERPApiConfig } from "../types";
 
 const DEFAULT_RETRY_ATTEMPTS = 0; // One try only, no retries
 const DEFAULT_PAGINATION_LIMIT = 100; // Reasonable default for most APIs

package/src/services/erp-api-services/types.ts

@@ -1,5 +1,5 @@
-import { Pagination } from "./rest/get-query-params.js";
-import { GraphQLServerError } from "./graphql/types.js";
+import { Pagination } from "./rest/get-query-params";
+import { GraphQLServerError } from "./graphql/types";
 
 /**
  * Configuration for making API requests to an ERP system.