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

package/dist/mm-erp-sdk.js

@@ -1,17 +1,18 @@
-import { C as CoreConfiguration, H as HashedCacheManager } from "./hashed-cache-manager-DbG72eRm.js";
-import { E, g, a } from "./hashed-cache-manager-DbG72eRm.js";
-import { l as logger } from "./logger-DeKxCUPp.js";
-import { g as getCachedMMToken, s as setCachedMMToken, a as setTimezoneOffsetInCache, b as setTimezoneNameInCache, c as getCachedTimezoneOffset, S as SQLiteCoordinator } from "./index-Cq9tNcJT.js";
-import { f, d, e } from "./index-Cq9tNcJT.js";
+import { C as CoreConfiguration, H as HashedCacheManager } from "./hashed-cache-manager-B15NN8hK.js";
+import { E, g, a } from "./hashed-cache-manager-B15NN8hK.js";
+import { l as logger } from "./logger-BWw0_z9q.js";
+import { g as getCachedMMToken, s as setCachedMMToken, a as setTimezoneOffsetInCache, b as setTimezoneNameInCache, c as getCachedTimezoneOffset, S as SQLiteCoordinator } from "./index-D8qO1NyK.js";
+import { f, d, e } from "./index-D8qO1NyK.js";
 import axios, { AxiosError } from "axios";
 import knex from "knex";
 import { c as config } from "./knexfile-Bng2Ru9c.js";
 import fs from "fs";
 import path from "path";
-import "./connector-factory-BGykiICT.js";
+import { c as createConnectorFromPath } from "./connector-factory-BPm2GVVF.js";
 import Bree from "bree";
 import Graceful from "@ladjs/graceful";
 import { fileURLToPath } from "url";
+import { StringCodec, connect } from "nats";
 import sql from "mssql";
 import { z } from "zod";
 var ERPObjType = /* @__PURE__ */ ((ERPObjType2) => {
@@ -25,6 +26,10 @@ var ERPObjType = /* @__PURE__ */ ((ERPObjType2) => {
   ERPObjType2[ERPObjType2["LABOR_TICKETS"] = 7] = "LABOR_TICKETS";
   return ERPObjType2;
 })(ERPObjType || {});
+const erpTypes = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  ERPObjType
+}, Symbol.toStringTag, { value: "Module" }));
 var Operator = /* @__PURE__ */ ((Operator2) => {
   Operator2["eq"] = "eq";
   Operator2["lt"] = "lt";
@@ -481,7 +486,7 @@ class MMApiClient {
       const hasStatus = (err) => {
         return typeof err === "object" && err !== null && "status" in err;
       };
-      const isAuthError = hasStatus(error) && (error.status === 401 || error.status === 403);
+      const isAuthError = hasStatus(error) && (error.status === 401 || error.status === 403) || hasStatus(error) && error.status === 500 && typeof error.data?.error === "string" && error.data.error.includes("JWT");
       if (isAuthError && !options.token) {
         logger.info("Retrying request with fresh token due to auth error");
         this.tokenMgr.invalidateToken();
@@ -805,6 +810,17 @@ 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) {
+    const response = await this.getData(
+      `${this.resourceURLs[ERPObjType.LABOR_TICKETS]}/${laborTicketRef}`
+    );
+    return new MMReceiveLaborTicket(response.data);
+  }
   /**
    * Fetch a checkpoint for a specific system, table, and checkpoint type
    * @param checkpoint The checkpoint to fetch
@@ -840,7 +856,7 @@ class MMApiClient {
       logger.info("saveCheckpoint:", { saveCheckpoint });
     } else {
       logger.info("Existing checkpoint found:", {
-        checkpointTimestamp: checkpointResponse.timestamp
+        timestamp: checkpointResponse.timestamp
       });
     }
   }
@@ -1318,6 +1334,65 @@ class MMSendLaborTicket {
     );
   }
 }
+let companyInfoCache = null;
+const getCompanyInfo = async () => {
+  if (companyInfoCache) {
+    return companyInfoCache;
+  }
+  try {
+    const config2 = CoreConfiguration.inst();
+    const apiUrl = config2.mmApiBaseUrl;
+    const authToken = config2.mmApiAuthToken;
+    if (!apiUrl || !authToken) {
+      throw new Error("Missing required configuration for company info fetch");
+    }
+    const client = HTTPClientFactory.getInstance({
+      baseUrl: apiUrl,
+      retryAttempts: config2.mmApiRetryAttempts
+    });
+    const response = await client.request({
+      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");
+    }
+    logger.info("Fetched company info from /accounts/current", {
+      locationRef: userInfo.locationRef,
+      companyId: userInfo.company.id,
+      timezone: userInfo.company.timezone
+    });
+    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"}`
+    );
+  }
+};
+const index = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  MMApiClient,
+  MMReceiveLaborTicket,
+  MMSendLaborTicket,
+  MMSendPart,
+  MMSendPartOperation,
+  MMSendPerson,
+  MMSendReason,
+  MMSendResource,
+  MMSendWorkOrder,
+  MMSendWorkOrderOperation,
+  getCompanyInfo
+}, Symbol.toStringTag, { value: "Module" }));
 function getUniqueRows(data, fields, sortFields) {
   const createCompositeKey = (item) => {
     return fields.map((field) => String(item[field])).join("|");
@@ -1695,8 +1770,7 @@ class LaborTicketERPSynchronizer {
       );
       const mostRecentUpdate = laborTicketsUpdates.reduce(
         (latest, ticket) => {
-          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;
         },
         null
@@ -1752,9 +1826,6 @@ class LaborTicketERPSynchronizer {
           timestamp: mostRecentUpdate || fallbackTimestamp
         }
       });
-      logger.info("syncLaborTicketsToERP: Checkpoint saved:", {
-        checkpointTimestamp: mostRecentUpdate || fallbackTimestamp
-      });
     } catch (error) {
       logger.error("syncLaborTicketsToERP: Error:", error);
     }
@@ -2502,6 +2573,10 @@ class MMEntityProcessor {
     }
   }
 }
+const mmEntityProcessor = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  MMEntityProcessor
+}, Symbol.toStringTag, { value: "Module" }));
 class MMBatchValidationError extends Error {
   upsertedEntities;
   localDedupeCount;
@@ -3099,6 +3174,146 @@ function getErrorType(error) {
   }
   return "Error";
 }
+function formatError(error) {
+  if (!error) {
+    return {
+      message: "Unknown error occurred",
+      code: "UNKNOWN_ERROR"
+    };
+  }
+  if (error.isAxiosError || error.name === "AxiosError") {
+    return formatAxiosError(error);
+  }
+  if (error.message && error.code && typeof error.message === "string" && typeof error.code === "string" && !error.config) {
+    return error;
+  }
+  if (error instanceof Error) {
+    return {
+      message: error.message || "An error occurred",
+      code: "ERROR",
+      metadata: {
+        name: error.name
+      }
+    };
+  }
+  if (typeof error === "string") {
+    return {
+      message: error,
+      code: "ERROR"
+    };
+  }
+  const message = error.message || error.toString?.() || "Unknown error occurred";
+  return {
+    message: typeof message === "string" ? message : JSON.stringify(message),
+    code: error.code || "UNKNOWN_ERROR"
+  };
+}
+function formatAxiosError(error) {
+  const httpStatus = error.response?.status;
+  const method = error.config?.method?.toUpperCase();
+  const url = error.config?.url;
+  let message = error._extractedMessage;
+  if (!message) {
+    const extractedMessage = extractErrorMessage(error.response?.data);
+    message = extractedMessage || error.response?.statusText || error.message || "Request failed";
+  }
+  const code = categorizeHttpError(httpStatus);
+  const metadata = {
+    method,
+    url
+  };
+  if (httpStatus === 401 || httpStatus === 403) {
+    metadata.hint = "Check authentication credentials";
+  } else if (httpStatus === 404) {
+    metadata.hint = "Resource not found - check endpoint URL";
+  } else if (httpStatus && httpStatus >= 500) {
+    metadata.hint = "ERP system may be temporarily unavailable";
+  }
+  return {
+    message,
+    code,
+    httpStatus,
+    metadata
+  };
+}
+function extractErrorMessage(data) {
+  if (!data) return null;
+  const possibleFields = [
+    "ErrorMessage",
+    // Epicor
+    "error.message",
+    // Common REST format
+    "error",
+    // Simple format
+    "Message",
+    // .NET style
+    "message",
+    // JavaScript style
+    "errorMessage",
+    // Camel case
+    "error_message",
+    // Snake case
+    "errors[0].message",
+    // Array of errors
+    "title",
+    // Problem details format
+    "detail"
+    // Problem details format
+  ];
+  for (const field of possibleFields) {
+    const value = getNestedValue(data, field);
+    if (value && typeof value === "string") {
+      return value;
+    }
+  }
+  if (typeof data === "string") {
+    try {
+      const parsed = JSON.parse(data);
+      return extractErrorMessage(parsed);
+    } catch {
+      return data;
+    }
+  }
+  return null;
+}
+function getNestedValue(obj, path2) {
+  const parts = path2.split(".");
+  let current = obj;
+  for (const part of parts) {
+    const arrayMatch = part.match(/(\w+)\[(\d+)\]/);
+    if (arrayMatch) {
+      const [, key, index2] = arrayMatch;
+      current = current?.[key]?.[parseInt(index2, 10)];
+    } else {
+      current = current?.[part];
+    }
+    if (current === void 0 || current === null) {
+      return null;
+    }
+  }
+  return current;
+}
+function categorizeHttpError(status) {
+  if (!status) return "NETWORK_ERROR";
+  if (status === 400) return "VALIDATION_ERROR";
+  if (status === 401) return "AUTHENTICATION_ERROR";
+  if (status === 403) return "AUTHORIZATION_ERROR";
+  if (status === 404) return "NOT_FOUND";
+  if (status === 409) return "CONFLICT";
+  if (status === 422) return "VALIDATION_ERROR";
+  if (status === 429) return "RATE_LIMIT";
+  if (status >= 500) return "ERP_SERVER_ERROR";
+  if (status >= 400) return "CLIENT_ERROR";
+  return "HTTP_ERROR";
+}
+function formatErrorForLogging(error) {
+  const formatted = formatError(error);
+  let message = `[${formatted.code}] ${formatted.message}`;
+  if (formatted.httpStatus) {
+    message = `[${formatted.httpStatus}] ${message}`;
+  }
+  return message;
+}
 class LogEntry {
   level;
   message;
@@ -3604,9 +3819,497 @@ class OAuthClient {
     return data;
   }
 }
+const sc = StringCodec();
+class NatsService {
+  connection = null;
+  subscriptions = /* @__PURE__ */ new Map();
+  config;
+  handlers = [];
+  statusPublishTimer = null;
+  constructor(config2) {
+    this.config = config2;
+  }
+  /**
+   * Register a handler for a specific subject pattern
+   */
+  registerHandler(registration) {
+    logger.info("Registering NATS handler", {
+      subject: registration.subject,
+      description: registration.description
+    });
+    this.handlers.push(registration);
+  }
+  /**
+   * Connect to NATS and start all registered handlers
+   */
+  async connect() {
+    if (!this.config.enabled) {
+      logger.info("NATS is disabled, skipping connection");
+      return;
+    }
+    try {
+      logger.info("Connecting to NATS...", {
+        servers: this.config.servers,
+        name: this.config.name
+      });
+      this.connection = await connect({
+        servers: this.config.servers,
+        name: this.config.name,
+        reconnect: this.config.reconnect ?? true,
+        maxReconnectAttempts: this.config.maxReconnectAttempts ?? -1,
+        reconnectTimeWait: this.config.reconnectTimeWait ?? 2e3
+      });
+      logger.info("Connected to NATS", {
+        server: this.connection.getServer(),
+        clientId: this.connection.info?.client_id
+      });
+      for (const registration of this.handlers) {
+        await this.startHandler(registration);
+      }
+      this.startStatusPublishing();
+      this.monitorConnection();
+      this.setupShutdown();
+    } catch (error) {
+      logger.error("Failed to connect to NATS", { error });
+      throw error;
+    }
+  }
+  /**
+   * Start a single handler (subscribe to its subject)
+   */
+  async startHandler(registration) {
+    if (!this.connection) {
+      throw new Error("NATS connection not established");
+    }
+    const sub = this.connection.subscribe(registration.subject);
+    this.subscriptions.set(registration.subject, sub);
+    logger.info("Started NATS handler", {
+      subject: registration.subject,
+      description: registration.description
+    });
+    (async () => {
+      for await (const msg of sub) {
+        try {
+          const data = sc.decode(msg.data);
+          logger.info("Received NATS message", {
+            subject: msg.subject,
+            hasReply: !!msg.reply
+          });
+          let parsedData;
+          try {
+            parsedData = JSON.parse(data);
+          } catch {
+            parsedData = data;
+          }
+          const response = await registration.handler.handle(parsedData, msg.subject);
+          if (msg.reply && response !== void 0) {
+            const responseStr = JSON.stringify(response);
+            msg.respond(sc.encode(responseStr));
+            logger.info("Sent reply", { replySubject: msg.reply });
+          }
+        } catch (error) {
+          logger.error("Error handling NATS message", {
+            subject: msg.subject,
+            error
+          });
+          if (msg.reply) {
+            const errorResponse = {
+              status: "error",
+              error: {
+                message: error instanceof Error ? error.message : "Unknown error",
+                code: "HANDLER_ERROR"
+              }
+            };
+            msg.respond(sc.encode(JSON.stringify(errorResponse)));
+          }
+        }
+      }
+    })();
+  }
+  /**
+   * Publish a message to a subject (for pub/sub)
+   */
+  async publish(subject, data) {
+    if (!this.connection) {
+      throw new Error("NATS connection not established");
+    }
+    const message = typeof data === "string" ? data : JSON.stringify(data);
+    this.connection.publish(subject, sc.encode(message));
+    logger.info("Published NATS message", { subject });
+  }
+  /**
+   * Send a request and wait for reply (for request-reply)
+   */
+  async request(subject, data, timeoutMs = 3e4) {
+    if (!this.connection) {
+      throw new Error("NATS connection not established");
+    }
+    const message = typeof data === "string" ? data : JSON.stringify(data);
+    const response = await this.connection.request(
+      subject,
+      sc.encode(message),
+      { timeout: timeoutMs }
+    );
+    const responseData = sc.decode(response.data);
+    try {
+      return JSON.parse(responseData);
+    } catch {
+      return responseData;
+    }
+  }
+  /**
+   * Check if connected to NATS
+   */
+  isConnected() {
+    return this.connection !== null && !this.connection.isClosed();
+  }
+  /**
+   * Start automatic status publishing (every 30 seconds)
+   */
+  startStatusPublishing() {
+    logger.info("Starting status publishing (every 30 seconds)");
+    this.publishStatus();
+    this.statusPublishTimer = setInterval(() => {
+      this.publishStatus();
+    }, 3e4);
+  }
+  /**
+   * Publish connector status
+   */
+  async publishStatus() {
+    try {
+      const status = {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        locationRef: this.config.locationRef,
+        erpType: this.config.erpType,
+        natsConnected: this.isConnected()
+      };
+      await this.publish(
+        `mm.14.${this.config.locationRef}.erp.status`,
+        status
+      );
+      logger.debug("Published connector status");
+    } catch (error) {
+      logger.error("Failed to publish status", { error });
+    }
+  }
+  /**
+   * Monitor connection status
+   */
+  monitorConnection() {
+    if (!this.connection) return;
+    (async () => {
+      for await (const status of this.connection.status()) {
+        if (status.type !== "pingTimer") {
+          logger.info("NATS connection status", {
+            type: status.type,
+            data: status.data
+          });
+        }
+      }
+    })();
+  }
+  /**
+   * Setup graceful shutdown
+   */
+  setupShutdown() {
+    const shutdown = async () => {
+      logger.info("Shutting down NATS service...");
+      await this.disconnect();
+      process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+  }
+  /**
+   * Disconnect from NATS
+   */
+  async disconnect() {
+    if (this.statusPublishTimer) {
+      clearInterval(this.statusPublishTimer);
+      this.statusPublishTimer = null;
+    }
+    if (this.connection) {
+      await this.connection.drain();
+      this.connection = null;
+      this.subscriptions.clear();
+      logger.info("Disconnected from NATS");
+    }
+  }
+  /**
+   * Get the location reference
+   */
+  getLocationRef() {
+    return this.config.locationRef;
+  }
+}
+class NatsLaborTicketListener {
+  connector;
+  natsService;
+  constructor(connector) {
+    this.connector = connector;
+  }
+  /**
+   * Start listening for labor ticket events via NATS
+   */
+  async start() {
+    try {
+      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: 2e3
+      });
+      this.registerHealthCheckHandler(companyInfo.locationRef, erpType);
+      this.registerLaborTicketHandler(companyInfo.locationRef, erpType);
+      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 });
+    }
+  }
+  /**
+   * Register health check handler - responds immediately to let Dashboard know connector is online
+   */
+  registerHealthCheckHandler(locationRef, erpType) {
+    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: (/* @__PURE__ */ new Date()).toISOString(),
+            locationRef,
+            erpType
+          };
+        }
+      }
+    });
+  }
+  /**
+   * Register labor ticket processing handler
+   */
+  registerLaborTicketHandler(locationRef, erpType) {
+    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 }, subject) => {
+          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
+          });
+          return await SQLiteCoordinator.executeWithLock("to-erp", async () => {
+            try {
+              let laborTicketData;
+              if (laborTicketRef) {
+                const mmApiClient = new MMApiClient();
+                const laborTicket = await mmApiClient.fetchLaborTicketByRef(laborTicketRef);
+                logger.info("Fetched labor ticket data from MM API", {
+                  laborTicketRef,
+                  laborTicketId: laborTicket.laborTicketId
+                });
+                laborTicketData = {
+                  ...laborTicket,
+                  ...actionPayload
+                };
+              } else {
+                logger.info("No laborTicketRef provided, using actionPayload directly", {
+                  requestId: data.requestId
+                });
+                laborTicketData = actionPayload;
+              }
+              const mergedLaborTicket = new MMReceiveLaborTicket(laborTicketData);
+              const result = await this.processLaborTicket(
+                mergedLaborTicket,
+                action || "unknown"
+              );
+              await this.updateCheckpoint(erpType, result);
+              return {
+                status: "success",
+                requestId: data.requestId,
+                action,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                processingTimeMs: Date.now() - startTime,
+                laborTicketRef: result.laborTicketRef,
+                laborTicket: result.laborTicket
+              };
+            } catch (error) {
+              const formattedError = error?._formatted || formatError(error);
+              logger.debug("Error details", {
+                hasFormatted: !!error?._formatted,
+                isAxiosError: error?.isAxiosError,
+                errorMessage: error?.message,
+                responseStatus: error?.response?.status,
+                responseData: error?.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: (/* @__PURE__ */ 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
+   */
+  async processLaborTicket(laborTicket, action) {
+    const { MMEntityProcessor: MMEntityProcessor2 } = await Promise.resolve().then(() => mmEntityProcessor);
+    const { ERPObjType: ERPObjType2 } = await Promise.resolve().then(() => erpTypes);
+    const { MMSendLaborTicket: MMSendLaborTicket2 } = await Promise.resolve().then(() => index);
+    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) {
+        erpResult = await this.connector.createLaborTicketInERP(laborTicket);
+        logger.info("Successfully created labor ticket in ERP", {
+          laborTicketRef: laborTicket.laborTicketRef,
+          erpUid: erpResult.erpUid
+        });
+      } else {
+        erpResult = { laborTicket: await this.connector.updateLaborTicketInERP(laborTicket) };
+        logger.info("Successfully updated labor ticket in ERP", {
+          laborTicketRef: laborTicket.laborTicketRef
+        });
+      }
+      const laborTicketForMM = { ...laborTicket };
+      if (erpResult.erpUid) {
+        laborTicketForMM.laborTicketId = erpResult.erpUid;
+        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
+          });
+        }
+      }
+      laborTicketForMM.state = laborTicketForMM.clockOut ? "CLOSED" : "OPEN";
+      const mmLaborTicket = MMSendLaborTicket2.fromPlainObject(laborTicketForMM);
+      const mmResult = await MMEntityProcessor2.writeEntities(
+        ERPObjType2.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) {
+      const formattedError = formatError(error);
+      logger.error("Failed to process labor ticket with MM creation", {
+        laborTicketRef: laborTicket.laborTicketRef,
+        action,
+        error: formattedError.message,
+        code: formattedError.code
+      });
+      const enhancedError = 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)
+   */
+  async updateCheckpoint(erpType, result) {
+    const mmApiClient = new MMApiClient();
+    const currentCheckpoint = await mmApiClient.getCheckpoint({
+      system: erpType,
+      table: "labor_tickets",
+      checkpointType: "export",
+      checkpointValue: {
+        timestamp: ""
+      }
+    });
+    const currentTimestamp = currentCheckpoint?.timestamp;
+    const newTimestamp = result.laborTicket.updatedAt || (/* @__PURE__ */ new Date()).toISOString();
+    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
+      });
+    }
+  }
+}
 const runDataSyncService = async (connectorPath) => {
   const config2 = CoreConfiguration.inst();
   try {
+    const connector = await createConnectorFromPath(connectorPath);
+    if (process.env.NATS_ENABLED === "true") {
+      const natsListener = new NatsLaborTicketListener(connector);
+      await natsListener.start();
+    }
     const currentFileUrl = import.meta.url;
     const currentFilePath = fileURLToPath(currentFileUrl);
     const sdkDistPath = path.dirname(currentFilePath);
@@ -4249,6 +4952,8 @@ export {
   combinePsqlDateTime,
   convertToLocalTime,
   formatDateWithTZOffset,
+  formatError,
+  formatErrorForLogging,
   formatPsqlDate,
   formatPsqlTime,
   f as getCachedTimezoneName,