@machinemetrics/mm-erp-sdk 0.2.0-beta.0 → 0.2.0-beta.2

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.

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

@@ -0,0 +1,87 @@
+import { CoreConfiguration } from "../data-sync-service/configuration-manager";
+import { HTTPClientFactory } from "../../utils/http-client";
+import { logger } from "../reporting-service";
+
+// Cache for company info to avoid repeated API calls
+let companyInfoCache: {
+  timezone: string;
+  locationRef: string;
+  companyId: string;
+} | null = null;
+
+export interface CompanyInfo {
+  timezone: string;
+  locationRef: string;
+  companyId: string;
+}
+
+/**
+ * Fetches company information from /accounts/current endpoint
+ * Results are cached to avoid repeated API calls
+ * @returns Promise<CompanyInfo> Company information including timezone, locationRef, and companyId
+ * @throws Error if unable to fetch company information
+ */
+export const getCompanyInfo = async (): Promise<CompanyInfo> => {
+  // Return cached value if available
+  if (companyInfoCache) {
+    return companyInfoCache;
+  }
+
+  try {
+    // Get the configuration
+    const config = CoreConfiguration.inst();
+    const apiUrl = config.mmApiBaseUrl;
+    const authToken = config.mmApiAuthToken;
+
+    if (!apiUrl || !authToken) {
+      throw new Error("Missing required configuration for company info fetch");
+    }
+
+    // Create HTTP client
+    const client = HTTPClientFactory.getInstance({
+      baseUrl: apiUrl,
+      retryAttempts: config.mmApiRetryAttempts,
+    });
+
+    // Fetch user/company information from the API
+    const response = await client.request<{
+      company: {
+        timezone: string;
+        id: string;
+      };
+      locationRef: number;
+    }>({
+      url: "/accounts/current?includeLocation=true",
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${authToken}`,
+      },
+    });
+
+    const userInfo = response.data;
+    if (!userInfo?.company) {
+      throw new Error("Unable to retrieve company information from API");
+    }
+
+    // Debug: Log what we actually got from the API
+    logger.info("Fetched company info from /accounts/current", {
+      locationRef: userInfo.locationRef,
+      companyId: userInfo.company.id,
+      timezone: userInfo.company.timezone,
+    });
+
+    // Cache and return company info - locationRef is at top level, not in company
+    companyInfoCache = {
+      timezone: userInfo.company.timezone,
+      locationRef: String(userInfo.locationRef), // Convert number to string
+      companyId: userInfo.company.id,
+    };
+
+    return companyInfoCache;
+  } catch (error) {
+    throw new Error(
+      `Failed to get company info: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
+};
+

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

@@ -1,9 +1,9 @@
-import { MMApiClient } from "./mm-api-service.js";
+import { MMApiClient } from "./mm-api-service";
 import type {
   MMReceiveLaborTicket,
   MMReceiveLaborTicketReason,
   MMReceiveLaborTicketWorkOrderOperation,
-} from "./types/receive-types.js";
+} from "./types/receive-types";
 import {
   MMSendPerson,
   MMSendResource,
@@ -14,8 +14,8 @@ import {
   MMSendReason,
   MMSendLaborTicket,
   MMSendWorkOrderBatch,
-} from "./types/send-types.js";
-import type { IToRESTApiObject } from "./types/send-types.js";
+} from "./types/send-types";
+import type { IToRESTApiObject } from "./types/send-types";
 import type {
   MMApiBaseResponse,
   MM200NonLaborTicketResponse,
@@ -26,7 +26,9 @@ import type {
   MM500LaborTicketException,
   MMGraphQLResourceResponse,
   MMMachineGroupsResponse,
-} from "./types/mm-response-interfaces.js";
+} from "./types/mm-response-interfaces";
+import { getCompanyInfo } from "./company-info";
+import type { CompanyInfo } from "./company-info";
 
 /**
  * A class to manage interactions with the MM API
@@ -52,7 +54,7 @@ export type {
 /**
  * Types related of labor tickets received from the MM API
  */
-export { MMReceiveLaborTicket } from "./types/receive-types.js";
+export { MMReceiveLaborTicket } from "./types/receive-types";
 export type {
   MMReceiveLaborTicketReason,
   MMReceiveLaborTicketWorkOrderOperation,
@@ -81,3 +83,9 @@ export {
  * Batch interfaces for sending multiple related entities
  */
 export type { MMSendWorkOrderBatch };
+
+/**
+ * Company information utilities
+ */
+export { getCompanyInfo };
+export type { CompanyInfo };

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

@@ -1,22 +1,22 @@
-import logger from "../reporting-service/logger.js";
-import { ERPObjType } from "../../types/erp-types.js";
-import { MMReceiveLaborTicket } from "./types/receive-types.js";
-import { MMTokenManager } from "./token-mgr.js";
-import * as MM_SEND_TYPES from "./types/send-types.js";
+import logger from "../reporting-service/logger";
+import { ERPObjType } from "../../types/erp-types";
+import { MMReceiveLaborTicket } from "./types/receive-types";
+import { MMTokenManager } from "./token-mgr";
+import * as MM_SEND_TYPES from "./types/send-types";
 import {
   HTTPClient,
   HTTPMethod,
   HTTPRequestConfig,
   HTTPClientFactory,
-} from "../../utils/http-client.js";
-import { Checkpoint } from "./types/checkpoint.js";
-import { CoreConfiguration } from "../data-sync-service/configuration-manager.js";
-import { ErrorHandler } from "../erp-api-services/errors.js";
+} from "../../utils/http-client";
+import { Checkpoint } from "./types/checkpoint";
+import { CoreConfiguration } from "../data-sync-service/configuration-manager";
+import { ErrorHandler } from "../erp-api-services/errors";
 import {
   MMApiBaseResponse,
   MMGraphQLResourceResponse,
   MMMachineGroupsResponse,
-} from "./types/mm-response-interfaces.js";
+} from "./types/mm-response-interfaces";
 
 const MAPPING = "MAPPING";
 const CHECKPOINTS = "CHECKPOINTS";
@@ -80,9 +80,12 @@ export class MMApiClient {
         return typeof err === "object" && err !== null && "status" in err;
       };
 
-      // Check if this looks like an auth error - only retry on explicit auth status codes
+      // Check if this looks like an auth error - retry on auth status codes or JWT expiration errors
       const isAuthError =
-        hasStatus(error) && (error.status === 401 || error.status === 403);
+        hasStatus(error) && (error.status === 401 || error.status === 403) ||
+        (hasStatus(error) && error.status === 500 && 
+         typeof (error as any).data?.error === 'string' && 
+         (error as any).data.error.includes('JWT'));
 
       if (isAuthError && !options.token) {
         // Only retry if we used cached token
@@ -506,6 +509,20 @@ export class MMApiClient {
     return updates.data.map((ticket) => new MMReceiveLaborTicket(ticket));
   }
 
+  /**
+   * Fetch a single labor ticket by reference from the MM API
+   * @param laborTicketRef The labor ticket reference to fetch
+   * @returns Promise with the labor ticket data
+   */
+  async fetchLaborTicketByRef(
+    laborTicketRef: string
+  ): Promise<MMReceiveLaborTicket> {
+    const response = (await this.getData(
+      `${this.resourceURLs[ERPObjType.LABOR_TICKETS]}/${laborTicketRef}`
+    )) as { data: MMReceiveLaborTicket };
+    return new MMReceiveLaborTicket(response.data);
+  }
+
   /**
    * Fetch a checkpoint for a specific system, table, and checkpoint type
    * @param checkpoint The checkpoint to fetch
@@ -551,7 +568,7 @@ export class MMApiClient {
       logger.info("saveCheckpoint:", { saveCheckpoint });
     } else {
       logger.info("Existing checkpoint found:", {
-        checkpointTimestamp: checkpointResponse.timestamp,
+        timestamp: checkpointResponse.timestamp,
       });
     }
   }

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

@@ -1,10 +1,10 @@
 import {
   getCachedMMToken,
   setCachedMMToken,
-} from "../../utils/local-data-store/jobs-shared-data.js";
-import { HTTPClient, HTTPClientFactory } from "../../utils/http-client.js";
-import { CoreConfiguration } from "../data-sync-service/configuration-manager.js";
-import { logger } from "../reporting-service/index.js";
+} from "../../utils/local-data-store/jobs-shared-data";
+import { HTTPClient, HTTPClientFactory } from "../../utils/http-client";
+import { CoreConfiguration } from "../data-sync-service/configuration-manager";
+import { logger } from "../reporting-service";
 
 /**
  * Manages the MM API token with caching and expiration checking

package/src/services/mm-api-service/types/entity-transformer.ts

@@ -1,5 +1,5 @@
-import { ERPObjType } from "../../../types/erp-types.js";
-import { IToRESTApiObject } from "../index.js";
+import { ERPObjType } from "../../../types/erp-types";
+import { IToRESTApiObject } from "..";
 import {
   MMSendPerson,
   MMSendResource,
@@ -9,7 +9,7 @@ import {
   MMSendWorkOrderOperation,
   MMSendLaborTicket,
   MMSendReason,
-} from "../index.js";
+} from "..";
 
 /**
  * Utility class for transforming entities to/from non-typed and typed objects