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

package/dist/mm-erp-sdk.js

@@ -1,18 +1,17 @@
-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 { C as CoreConfiguration, H as HashedCacheManager } from "./hashed-cache-manager-C1u9jQgY.js";
+import { E, g, a } from "./hashed-cache-manager-C1u9jQgY.js";
+import { l as logger } from "./logger-DW5fyhVS.js";
+import { g as getCachedMMToken, s as setCachedMMToken, a as setTimezoneOffsetInCache, b as setTimezoneNameInCache, c as getCachedTimezoneOffset, S as SQLiteCoordinator } from "./index-BkVlW0ZW.js";
+import { f, d, e } from "./index-BkVlW0ZW.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 { c as createConnectorFromPath } from "./connector-factory-BPm2GVVF.js";
+import "./connector-factory-BaMIlES8.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) => {
@@ -26,10 +25,6 @@ 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";
@@ -486,7 +481,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) || hasStatus(error) && error.status === 500 && typeof error.data?.error === "string" && error.data.error.includes("JWT");
+      const isAuthError = hasStatus(error) && (error.status === 401 || error.status === 403);
       if (isAuthError && !options.token) {
         logger.info("Retrying request with fresh token due to auth error");
         this.tokenMgr.invalidateToken();
@@ -810,17 +805,6 @@ 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
@@ -1334,65 +1318,6 @@ 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("|");
@@ -2573,10 +2498,6 @@ class MMEntityProcessor {
     }
   }
 }
-const mmEntityProcessor = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  MMEntityProcessor
-}, Symbol.toStringTag, { value: "Module" }));
 class MMBatchValidationError extends Error {
   upsertedEntities;
   localDedupeCount;
@@ -3174,146 +3095,6 @@ 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;
@@ -3819,497 +3600,9 @@ 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);
@@ -4952,8 +4245,6 @@ export {
   combinePsqlDateTime,
   convertToLocalTime,
   formatDateWithTZOffset,
-  formatError,
-  formatErrorForLogging,
   formatPsqlDate,
   formatPsqlTime,
   f as getCachedTimezoneName,