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

package/dist/mm-erp-sdk.js

@@ -1,4266 +0,0 @@
-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 "./connector-factory-BaMIlES8.js";
-import Bree from "bree";
-import Graceful from "@ladjs/graceful";
-import { fileURLToPath } from "url";
-import sql from "mssql";
-import { z } from "zod";
-var ERPObjType = /* @__PURE__ */ ((ERPObjType2) => {
-  ERPObjType2[ERPObjType2["RESOURCES"] = 0] = "RESOURCES";
-  ERPObjType2[ERPObjType2["PARTS"] = 1] = "PARTS";
-  ERPObjType2[ERPObjType2["PART_OPERATION"] = 2] = "PART_OPERATION";
-  ERPObjType2[ERPObjType2["WORK_ORDERS"] = 3] = "WORK_ORDERS";
-  ERPObjType2[ERPObjType2["WORK_ORDER_OPERATIONS"] = 4] = "WORK_ORDER_OPERATIONS";
-  ERPObjType2[ERPObjType2["PERSONS"] = 5] = "PERSONS";
-  ERPObjType2[ERPObjType2["REASONS"] = 6] = "REASONS";
-  ERPObjType2[ERPObjType2["LABOR_TICKETS"] = 7] = "LABOR_TICKETS";
-  return ERPObjType2;
-})(ERPObjType || {});
-var Operator = /* @__PURE__ */ ((Operator2) => {
-  Operator2["eq"] = "eq";
-  Operator2["lt"] = "lt";
-  Operator2["lte"] = "lte";
-  Operator2["gt"] = "gt";
-  Operator2["gte"] = "gte";
-  return Operator2;
-})(Operator || {});
-const buildLogicalCondition = (conditions, operator) => {
-  return conditions.map(
-    (condition) => `${condition.field} ${condition.operator} '${condition.value}'`
-  ).join(` ${operator} `);
-};
-class MMReceiveLaborTicket {
-  constructor(data) {
-    Object.assign(this, data);
-  }
-  // Returns the closed date if it is a valid date, otherwise returns null
-  get workOrderOperationClosedDate() {
-    const closedDate = this.workOrderOperation?.closedDate;
-    return typeof closedDate === "string" && closedDate !== "" && !isNaN(Date.parse(closedDate)) ? closedDate : null;
-  }
-  set workOrderOperationClosedDate(value) {
-    if (this.workOrderOperation) {
-      this.workOrderOperation.closedDate = value;
-    }
-  }
-  // Returns 1 if the work order operation is closed (has a valid closed date), 0 otherwise
-  get workOrderOpIsClosed() {
-    return this.workOrderOperationClosedDate !== null ? 1 : 0;
-  }
-  /*Descriptions from machinemetrics.atlassian.net/wiki/spaces/DEVE/pages/842661901/MM+ERP+Schema+Descriptions*/
-  badParts;
-  // The number of parts produced that do not meet quality standards
-  clockIn;
-  // The timestamp when the work on this ticket started
-  clockOut;
-  // The timestamp when the work on this ticket ended
-  comment;
-  createdAt;
-  goodParts;
-  // The number of parts produced that meet quality standards
-  laborTicketId;
-  // The unique identifier for the labor ticket in the ERP
-  laborTicketRef;
-  // The unique identifier for the labor ticket in MM
-  lot;
-  // Refers to a material batch. If not available in the ERP, default to an empty string
-  personId;
-  // The person who did the work
-  reasons;
-  resourceId;
-  // The physical resource that did the work
-  sequenceNumber;
-  // Which sequence this operation is for in the order, associates back to a part_operation with the part_number from the work_order, and sequence_number from the op
-  split;
-  // Batch number if order split for staggered delivery. If not available in the ERP, default to an empty string
-  state;
-  // The current state of the labor ticket (e.g., "CLOSED/OPEN")
-  type;
-  // If the labor is production, setup, or indirect
-  syncedAt;
-  updatedAt;
-  workOrderId;
-  // The order this labor ticket corresponds to
-  workOrderOperation;
-  sub;
-  // Batch number for parts that had to be rerun. If not available in the ERP, default to an empty string
-  transactionDate;
-}
-class HTTPError extends Error {
-  constructor(message, status, code, data) {
-    super(message);
-    this.status = status;
-    this.code = code;
-    this.data = data;
-    this.name = "HTTPError";
-  }
-}
-class HTTPClientFactory {
-  static getInstance(config2) {
-    return new AxiosClient(config2.baseUrl, config2.retryAttempts);
-  }
-}
-class AxiosClient {
-  client = null;
-  retryAttempts;
-  isDestroyed = false;
-  inFlightControllers = /* @__PURE__ */ new Set();
-  pendingTimeouts = /* @__PURE__ */ new Set();
-  pendingSleepResolvers = /* @__PURE__ */ new Set();
-  /**
-   * Note regarding baseURL, from https://github.com/axios/axios
-   *   `baseURL` will be prepended to `url` unless `url` is absolute and option `allowAbsoluteUrls` is set to true (the default).
-   *   It can be convenient to set `baseURL` for an instance of axios to pass relative URLs to methods of that instance.
-   */
-  constructor(baseUrl, retryAttempts) {
-    this.client = axios.create({
-      baseURL: baseUrl,
-      timeout: 3e4,
-      headers: {
-        "Content-Type": "application/json"
-      }
-    });
-    this.retryAttempts = retryAttempts;
-  }
-  sleep(ms) {
-    return new Promise((resolve) => {
-      if (this.isDestroyed) {
-        resolve();
-        return;
-      }
-      const timeout = setTimeout(() => {
-        this.pendingTimeouts.delete(timeout);
-        this.pendingSleepResolvers.delete(resolve);
-        resolve();
-      }, ms);
-      this.pendingTimeouts.add(timeout);
-      this.pendingSleepResolvers.add(resolve);
-    });
-  }
-  async request(config2) {
-    if (this.isDestroyed || !this.client) {
-      throw new HTTPError("HTTP client has been destroyed", 500);
-    }
-    const controller = new AbortController();
-    this.inFlightControllers.add(controller);
-    const axiosConfig = {
-      method: config2.method,
-      url: config2.url,
-      headers: config2.headers,
-      data: config2.data,
-      params: config2.params,
-      signal: controller.signal
-    };
-    logger.info("HTTP request starting", {
-      url: config2.url,
-      method: config2.method,
-      baseURL: this.client.defaults.baseURL,
-      retryAttempts: this.retryAttempts
-    });
-    console.log("=== FULL URL DEBUG ===");
-    console.log("baseURL:", this.client.defaults.baseURL);
-    console.log("relative url:", config2.url);
-    console.log("full constructed URL:", (this.client.defaults.baseURL || "") + config2.url);
-    console.log("method:", config2.method);
-    let lastError;
-    try {
-      for (let attempt = 0; attempt <= this.retryAttempts; attempt++) {
-        try {
-          logger.info(`HTTP request attempt ${attempt + 1}/${this.retryAttempts + 1}`);
-          const response = await this.client.request(axiosConfig);
-          logger.info("HTTP request succeeded", { status: response.status });
-          return {
-            data: response.data,
-            status: response.status,
-            headers: response.headers
-          };
-        } catch (error) {
-          lastError = error;
-          const isAxiosErr = error instanceof AxiosError;
-          const code = isAxiosErr ? error.code : void 0;
-          const status = isAxiosErr ? error.response?.status : void 0;
-          const errorConstructor = error instanceof Error ? error.constructor.name : void 0;
-          const message = error instanceof Error ? error.message : String(error);
-          logger.info(`HTTP request attempt ${attempt + 1} failed`, {
-            errorType: typeof error,
-            errorConstructor,
-            isAxiosError: isAxiosErr,
-            message,
-            code,
-            status
-          });
-          if (error instanceof AxiosError && error.response?.status && error.response.status >= 400 && error.response.status < 500) {
-            logger.info("Not retrying due to 4xx client error");
-            break;
-          }
-          if (error instanceof AxiosError && error.code === "ERR_CANCELED") {
-            break;
-          }
-          if (attempt < this.retryAttempts) {
-            const waitTime = Math.pow(2, attempt) * 1e3;
-            logger.info(`Waiting ${waitTime}ms before retry`);
-            await this.sleep(waitTime);
-            if (this.isDestroyed) {
-              throw new HTTPError("HTTP client has been destroyed", 500);
-            }
-          }
-        }
-      }
-    } finally {
-      this.inFlightControllers.delete(controller);
-    }
-    logger.info("HTTP request failed after all retries, throwing error");
-    throw this.handleError(lastError, config2);
-  }
-  handleError(error, requestConfig) {
-    if (error instanceof AxiosError) {
-      const baseUrl = this.client?.defaults.baseURL || "";
-      const fullUrl = requestConfig ? `${baseUrl}${requestConfig.url}` : "Unknown URL";
-      const method = requestConfig?.method || "Unknown method";
-      const errorMessage = `${error.message} (${method} ${fullUrl})`;
-      return new HTTPError(
-        errorMessage,
-        error.response?.status || 500,
-        error.code,
-        error.response?.data
-      );
-    }
-    return new HTTPError(
-      error instanceof Error ? error.message : "Unknown error occurred",
-      500
-    );
-  }
-  async destroy() {
-    if (this.isDestroyed) return;
-    this.isDestroyed = true;
-    for (const c of this.inFlightControllers) {
-      try {
-        c.abort();
-      } catch {
-      }
-    }
-    this.inFlightControllers.clear();
-    for (const t of this.pendingTimeouts) {
-      clearTimeout(t);
-    }
-    this.pendingTimeouts.clear();
-    for (const resolve of this.pendingSleepResolvers) {
-      try {
-        resolve();
-      } catch {
-      }
-    }
-    this.pendingSleepResolvers.clear();
-    this.client = null;
-  }
-}
-class MMTokenManager {
-  token;
-  tokenExpiration;
-  baseUrl;
-  api;
-  constructor() {
-    const cached = getCachedMMToken();
-    this.token = cached?.token || "";
-    this.tokenExpiration = cached?.expiration ? new Date(cached.expiration) : null;
-    const config2 = CoreConfiguration.inst();
-    console.log("=== MMTOKEN MANAGER DEBUG ===");
-    console.log("config.mmApiBaseUrl:", config2.mmApiBaseUrl);
-    console.log("config object keys:", Object.keys(config2));
-    this.baseUrl = config2.mmApiBaseUrl;
-    console.log("this.baseUrl set to:", this.baseUrl);
-    console.log("=== END MMTOKEN MANAGER DEBUG ===");
-    this.api = HTTPClientFactory.getInstance({
-      baseUrl: this.baseUrl,
-      retryAttempts: config2.mmApiRetryAttempts
-    });
-  }
-  /**
-   * Checks if the current token is expired or will expire within the next minute
-   * @returns boolean indicating if token needs refresh
-   */
-  isTokenExpired() {
-    if (!this.tokenExpiration) return true;
-    const bufferTimeMS = 6e4;
-    const isExpired = this.tokenExpiration.getTime() - bufferTimeMS <= Date.now();
-    if (isExpired) {
-      logger.info("isTokenExpired: the api token from MM has expired");
-    }
-    return isExpired;
-  }
-  /**
-   * Safely extracts expiration time from JWT token
-   * @param token JWT token string
-   * @returns Date object representing token expiration, or null if cannot be determined
-   */
-  getTokenExpiration(token) {
-    try {
-      const parts = token.split(".");
-      if (parts.length !== 3) {
-        console.warn("Invalid JWT format: token does not have 3 parts");
-        return null;
-      }
-      const payload = Buffer.from(parts[1], "base64").toString("utf-8");
-      const decodedPayload = JSON.parse(payload);
-      if (typeof decodedPayload.exp !== "number") {
-        console.warn("JWT does not contain expiration time (exp claim)");
-        return null;
-      }
-      return new Date(decodedPayload.exp * 1e3);
-    } catch (error) {
-      console.warn("Error parsing JWT token:", error);
-      return null;
-    }
-  }
-  /**
-   * Gets a valid token, either from cache or by requesting a new one
-   * @returns Promise resolving to a valid token string
-   */
-  async getToken() {
-    if (this.token && !this.isTokenExpired()) {
-      return this.token;
-    }
-    const config2 = CoreConfiguration.inst();
-    const serviceToken = config2.mmApiAuthToken;
-    const tokenResponse = await this.api.request({
-      url: "/user-token",
-      method: "GET",
-      headers: {
-        Authorization: `Bearer ${serviceToken}`
-      }
-    });
-    this.token = tokenResponse.data;
-    this.tokenExpiration = this.getTokenExpiration(this.token);
-    setCachedMMToken({
-      token: this.token,
-      expiration: this.tokenExpiration?.getTime() || null
-    });
-    logger.info("getToken: the api token from MM has been refreshed");
-    return this.token;
-  }
-  /**
-   * Invalidates the current token, forcing a fresh fetch on next getToken() call
-   */
-  invalidateToken() {
-    this.token = "";
-    this.tokenExpiration = null;
-    setCachedMMToken({ token: "", expiration: null });
-  }
-}
-class GraphQLError extends Error {
-  constructor(message, errors) {
-    super(message);
-    this.errors = errors;
-    this.name = "GraphQLError";
-  }
-}
-class ErrorHandler {
-  /**
-   * Transforms any error into a standardized HTTPError or GraphQLError and throws it.
-   * Never returns - always throws an error.
-   *
-   * @throws {HTTPError|GraphQLError} Standardized error with appropriate details
-   */
-  static handle(error) {
-    if (error instanceof HTTPError) {
-      if (error.data && typeof error.data === "object" && "errors" in error.data) {
-        const graphqlError = new GraphQLError(
-          "GraphQL Error",
-          error.data.errors
-        );
-        logger.error("Error>>GraphQL", {
-          message: graphqlError.message,
-          errors: graphqlError.errors
-        });
-        throw graphqlError;
-      }
-      logger.error("Error>>HTTP", {
-        status: error.status,
-        message: error.message,
-        code: error.code,
-        data: error.data
-      });
-      throw error;
-    }
-    if (error instanceof AxiosError) {
-      if (error.response?.data?.errors) {
-        const graphqlError = new GraphQLError(
-          "GraphQL Error",
-          error.response.data.errors
-        );
-        logger.error("Error>>GraphQL", {
-          message: graphqlError.message,
-          errors: graphqlError.errors
-        });
-        throw graphqlError;
-      }
-      const httpError2 = new HTTPError(
-        error.message,
-        error.response?.status || 500,
-        error.code,
-        error.response?.data
-      );
-      logger.error("Error>>HTTP", {
-        status: httpError2.status,
-        message: httpError2.message,
-        code: httpError2.code,
-        data: httpError2.data
-      });
-      throw httpError2;
-    }
-    const httpError = new HTTPError(
-      error instanceof Error ? error.message : "An unknown error occurred",
-      500
-    );
-    logger.error("Error>>Unknown", {
-      message: httpError.message,
-      status: httpError.status
-    });
-    throw httpError;
-  }
-}
-const MAPPING = "MAPPING";
-const CHECKPOINTS = "CHECKPOINTS";
-const MACHINE_GROUPS = "MACHINE_GROUPS";
-const GRAPHQL = "GRAPHQL";
-var UrlBase = /* @__PURE__ */ ((UrlBase2) => {
-  UrlBase2["ErpApiSvcBase"] = "ErpApiSvcBase";
-  UrlBase2["ApiBase"] = "ApiBase";
-  return UrlBase2;
-})(UrlBase || {});
-class MMApiClient {
-  tokenMgr;
-  api;
-  baseUrls;
-  resourceURLs = {
-    [ERPObjType.RESOURCES]: "/erp/v1/resources",
-    [ERPObjType.PARTS]: "/erp/v1/parts",
-    [ERPObjType.PART_OPERATION]: "/erp/v1/part-operations",
-    [ERPObjType.WORK_ORDERS]: "/erp/v1/production-orders",
-    [ERPObjType.WORK_ORDER_OPERATIONS]: "/erp/v1/production-order-operations",
-    [ERPObjType.PERSONS]: "/erp/v1/persons",
-    [ERPObjType.REASONS]: "/erp/v1/reasons",
-    [ERPObjType.LABOR_TICKETS]: "/erp/v1/labor-tickets",
-    [MAPPING]: "/erp/v1/mapping",
-    [CHECKPOINTS]: "/erp/v1/checkpoints",
-    [MACHINE_GROUPS]: "/machine-groups",
-    [GRAPHQL]: "/proxy/graphql"
-  };
-  constructor() {
-    this.tokenMgr = new MMTokenManager();
-    this.baseUrls = {
-      [
-        "ErpApiSvcBase"
-        /* ErpApiSvcBase */
-      ]: CoreConfiguration.inst().mmERPSvcApiBaseUrl,
-      [
-        "ApiBase"
-        /* ApiBase */
-      ]: CoreConfiguration.inst().mmApiBaseUrl
-    };
-    this.api = HTTPClientFactory.getInstance({
-      baseUrl: "",
-      retryAttempts: CoreConfiguration.inst().mmApiRetryAttempts
-    });
-  }
-  //#region Private Methods
-  async executeWithAuthRetry(operation, options = {}) {
-    let token = options.token || await this.tokenMgr.getToken();
-    try {
-      return await operation(token);
-    } catch (error) {
-      const hasStatus = (err) => {
-        return typeof err === "object" && err !== null && "status" in err;
-      };
-      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();
-        token = await this.tokenMgr.getToken();
-        return await operation(token);
-      }
-      throw error;
-    }
-  }
-  /**
-   * Fetch data from the MM API, with an auth retry mechanism
-   * Auth Retry Level (executeWithAuthRetry)
-   *  - 401 (Unauthorized) and 403 (Forbidden) get special treatment
-   *  - These trigger a token refresh and one retry attempt
-   *  - If the retry still fails, the error is re-thrown
-   *
-   * HTTP Status Codes behavior:
-   *  - 2xx - Success, returns normally
-   *  - 4xx - Client errors, throws immediately
-   *  - 5xx - Server errors, retries then throws
-   *
-   * Flags:
-   */
-  async getData(path2, queryParams = {}, options = {}) {
-    try {
-      return await this.executeWithAuthRetry(async (token) => {
-        const baseUrl = options.baseUrl || "ErpApiSvcBase";
-        const params = new URLSearchParams({
-          ...queryParams,
-          ...baseUrl === "ErpApiSvcBase" ? { raw: "true" } : {}
-        });
-        const url = params.size > 0 ? `${path2}?${params.toString()}` : path2;
-        const fullUrl = this.baseUrls[baseUrl] + url;
-        const result = await this.api.request({
-          url: fullUrl,
-          method: "GET",
-          headers: {
-            Authorization: `Bearer ${token}`,
-            ...options.headers
-          }
-        });
-        return {
-          ...result.data,
-          httpStatus: result.status
-        };
-      }, options);
-    } catch (error) {
-      ErrorHandler.handle(error);
-    }
-  }
-  /**
-   * Send data to the MM API, with an auth retry mechanism
-   * Auth Retry Level (executeWithAuthRetry)
-   *  - 401 (Unauthorized) and 403 (Forbidden) get special treatment
-   *  - These trigger a token refresh and one retry attempt
-   *  - If the retry still fails, the error is re-thrown
-   *
-   * HTTP Status Codes behavior:
-   *  - 2xx - Success, returns normally
-   *  - 4xx - Client errors, throws immediately
-   *  - 5xx - Server errors, retries then throws
-   *
-   * Flags:
-   *  - 'raw' = true and 'dedupe' = true will be set for MM's ERP API url
-   */
-  async postData(path2, data = {}, queryParams = {}, options = {}) {
-    try {
-      return await this.executeWithAuthRetry(async (token) => {
-        const baseUrl = options.baseUrl || "ErpApiSvcBase";
-        const params = new URLSearchParams({
-          ...queryParams,
-          ...baseUrl === "ErpApiSvcBase" ? { dedupe: "true", raw: "true" } : {}
-        });
-        const url = params.size > 0 ? `${path2}?${params.toString()}` : path2;
-        const fullUrl = this.baseUrls[baseUrl] + url;
-        const request = {
-          url: fullUrl,
-          method: "POST",
-          data: JSON.stringify(data),
-          headers: {
-            Authorization: `Bearer ${token}`,
-            ...options.headers
-          }
-        };
-        const result = await this.api.request(request);
-        return {
-          ...result.data,
-          httpStatus: result.status
-        };
-      }, options);
-    } catch (error) {
-      ErrorHandler.handle(error);
-    }
-  }
-  /**
-   * Delete data from the MM API, with an auth retry mechanism
-   * Auth Retry Level (executeWithAuthRetry)
-   *  - 401 (Unauthorized) and 403 (Forbidden) get special treatment
-   *  - These trigger a token refresh and one retry attempt
-   *  - If the retry still fails, the error is re-thrown
-   *
-   * HTTP Status Codes behavior:
-   *  - 2xx - Success, returns normally
-   *  - 4xx - Client errors, throws immediately
-   *  - 5xx - Server errors, retries then throws
-   *
-   */
-  async deleteData(path2, data = {}, options = {}) {
-    try {
-      return await this.executeWithAuthRetry(async (token) => {
-        const baseUrl = options.baseUrl || "ErpApiSvcBase";
-        const params = new URLSearchParams({
-          ...baseUrl === "ErpApiSvcBase" ? { raw: "true" } : {}
-        });
-        const url = params.size > 0 ? `${path2}?${params.toString()}` : path2;
-        const fullUrl = this.baseUrls[baseUrl] + url;
-        const result = await this.api.request({
-          url: fullUrl,
-          method: "DELETE",
-          data,
-          headers: {
-            Authorization: `Bearer ${token}`,
-            ...options.headers
-          }
-        });
-        return {
-          ...result.data,
-          httpStatus: result.status
-        };
-      }, options);
-    } catch (error) {
-      ErrorHandler.handle(error);
-    }
-  }
-  /**
-   * Patch data to the MM API, with an auth retry mechanism
-   * Auth Retry Level (executeWithAuthRetry)
-   *  - 401 (Unauthorized) and 403 (Forbidden) get special treatment
-   *  - These trigger a token refresh and one retry attempt
-   *  - If the retry still fails, the error is re-thrown
-   *
-   * HTTP Status Codes behavior:
-   *  - 2xx - Success, returns normally
-   *  - 4xx - Client errors, throws immediately
-   *  - 5xx - Server errors, retries then throws
-   *
-   */
-  async patchData(path2, data = {}, options = {}) {
-    try {
-      return await this.executeWithAuthRetry(async (token) => {
-        const baseUrl = options.baseUrl || "ErpApiSvcBase";
-        const params = new URLSearchParams({
-          ...baseUrl === "ErpApiSvcBase" ? { raw: "true" } : {}
-        });
-        const url = params.size > 0 ? `${path2}?${params.toString()}` : path2;
-        const fullUrl = this.baseUrls[baseUrl] + url;
-        const request = {
-          url: fullUrl,
-          method: "PATCH",
-          data,
-          headers: {
-            Authorization: `Bearer ${token}`,
-            ...options.headers
-          }
-        };
-        const result = await this.api.request(request);
-        return {
-          ...result.data,
-          httpStatus: result.status
-        };
-      }, options);
-    } catch (error) {
-      ErrorHandler.handle(error);
-    }
-  }
-  async graphqlRequest(operationName, query) {
-    try {
-      return await this.postData(
-        this.resourceURLs[GRAPHQL],
-        { operationName, query },
-        {},
-        {
-          baseUrl: "ApiBase",
-          token: CoreConfiguration.inst().mmApiAuthToken,
-          headers: { "Content-Type": "application/json" }
-        }
-      );
-    } catch (error) {
-      ErrorHandler.handle(error);
-    }
-  }
-  /**
-   * Fetch a checkpoint for a specific system, table, and checkpoint type
-   * @param checkpoint The checkpoint to fetch
-   * @returns Promise with the checkpoint data
-   */
-  async fetchCheckpoint(checkpoint) {
-    const { system, table, checkpointType } = checkpoint;
-    return this.getData(this.resourceURLs[CHECKPOINTS], {
-      system,
-      table,
-      checkpointType
-    });
-  }
-  //#endregion private methods
-  //#region Public Methods
-  /**
-   * Send resources to the MM API
-   * @param resources Array of resources to send
-   * @returns Promise with the API response
-   */
-  async sendResourcesToMM(resources) {
-    return await this.postData(this.resourceURLs[ERPObjType.RESOURCES], {
-      data: resources.map((resource) => resource.toRESTApiObject())
-    });
-  }
-  /**
-   * Send parts to the MM API
-   * @param parts Array of parts to send
-   * @returns Promise with the API response
-   */
-  async sendPartsToMM(parts) {
-    return await this.postData(this.resourceURLs[ERPObjType.PARTS], {
-      data: parts.map((part) => part.toRESTApiObject())
-    });
-  }
-  /**
-   * Send part operations to the MM API
-   * @param operations Array of part operations to send
-   * @returns Promise with the API response
-   */
-  async sendPartOperationsToMM(operations) {
-    return await this.postData(this.resourceURLs[ERPObjType.PART_OPERATION], {
-      data: operations.map((operation) => operation.toRESTApiObject())
-    });
-  }
-  /**
-   * Send work orders to the MM API
-   * @param workOrders Array of work orders to send
-   * @returns Promise with the API response
-   */
-  async sendWorkOrdersToMM(workOrders) {
-    return await this.postData(this.resourceURLs[ERPObjType.WORK_ORDERS], {
-      data: workOrders.map((workOrder) => workOrder.toRESTApiObject())
-    });
-  }
-  /**
-   * Send work order operations to the MM API
-   * @param workOrderOperations Array of work order operations to send
-   * @returns Promise with the API response
-   */
-  async sendWorkOrderOperationsToMM(workOrderOperations) {
-    return await this.postData(
-      this.resourceURLs[ERPObjType.WORK_ORDER_OPERATIONS],
-      {
-        data: workOrderOperations.map(
-          (operation) => operation.toRESTApiObject()
-        )
-      }
-    );
-  }
-  /**
-   * Send persons to the MM API
-   * @param persons Array of persons to send
-   * @returns Promise with the API response
-   */
-  async sendPersonsToMM(persons) {
-    return await this.postData(this.resourceURLs[ERPObjType.PERSONS], {
-      data: persons.map((person) => person.toRESTApiObject())
-    });
-  }
-  /**
-   * Send reasons to the MM API
-   * @param reasons Array of reasons to send
-   * @returns Promise with the API response
-   */
-  async sendReasonsToMM(reasons) {
-    return await this.postData(this.resourceURLs[ERPObjType.REASONS], {
-      data: reasons.map((reason) => reason.toRESTApiObject())
-    });
-  }
-  /**
-   * Send labor tickets to the MM API
-   * @param laborTickets Array of labor tickets to send
-   * @returns Promise with the API response
-   */
-  async sendLaborTicketsToMM(laborTickets) {
-    return await this.postData(this.resourceURLs[ERPObjType.LABOR_TICKETS], {
-      data: laborTickets.map((ticket) => ticket.toRESTApiObject())
-    });
-  }
-  /**
-   * Delete labor tickets from the MM API
-   * @param laborTickets Array of labor ticket records to delete
-   * @returns Promise with the API response
-   */
-  async deleteLaborTickets(laborTickets) {
-    logger.debug("deleteLaborTickets:", { laborTickets });
-    return await this.deleteData(this.resourceURLs[ERPObjType.LABOR_TICKETS], {
-      laborTickets
-    });
-  }
-  /**
-   * Fetch transformed labor tickets from the MM API
-   * @returns Promise with the transformed labor tickets
-   */
-  async fetchTransformedLaborTickets() {
-    return await this.getData(
-      `${this.resourceURLs[ERPObjType.LABOR_TICKETS]}/export`
-    );
-  }
-  /**
-   * Fetch labor ticket updates from the MM API
-   * @param query Query parameters for filtering updates
-   * @returns Promise with an array of labor ticket updates
-   */
-  async fetchLaborTicketUpdates(query) {
-    const updates = await this.getData(
-      `${this.resourceURLs[ERPObjType.LABOR_TICKETS]}/export/updates`,
-      query
-    );
-    return updates.data.map((ticket) => new MMReceiveLaborTicket(ticket));
-  }
-  /**
-   * Fetch a checkpoint for a specific system, table, and checkpoint type
-   * @param checkpoint The checkpoint to fetch
-   * @returns Promise with the checkpoint data
-   */
-  async getCheckpoint(checkpoint) {
-    return await this.fetchCheckpoint(checkpoint);
-  }
-  /**
-   * Save a checkpoint to the MM API
-   * @param checkpoint The checkpoint to save
-   * @returns Promise with the API response
-   */
-  async saveCheckpoint(checkpoint) {
-    return await this.postData(this.resourceURLs[CHECKPOINTS], checkpoint);
-  }
-  /**
-   * Initialize a checkpoint for a specific system, table, and checkpoint type
-   * @param checkpoint The checkpoint to initialize
-   * @returns Promise with the checkpoint data
-   */
-  async initializeCheckpoint(checkpoint) {
-    const currentCheckpoint = await this.fetchCheckpoint(checkpoint);
-    logger.info("currentCheckpoint:", { currentCheckpoint });
-    logger.info("currentCheckpoint keys:", {
-      keys: Object.keys(currentCheckpoint || {})
-    });
-    const checkpointResponse = currentCheckpoint;
-    const hasCheckpointData = checkpointResponse && checkpointResponse.timestamp;
-    if (!hasCheckpointData) {
-      logger.info("No checkpoint data found, initializing checkpoint");
-      const saveCheckpoint = await this.saveCheckpoint(checkpoint);
-      logger.info("saveCheckpoint:", { saveCheckpoint });
-    } else {
-      logger.info("Existing checkpoint found:", {
-        timestamp: checkpointResponse.timestamp
-      });
-    }
-  }
-  /**
-   * Send data to MM API based on the object type
-   * @param type The type of ERP object to send
-   * @param objects Array of objects to send
-   * @returns Promise with the API response including affected rows count
-   */
-  async sendDataToMMByType(type, objects) {
-    switch (type) {
-      case ERPObjType.PERSONS:
-        return await this.sendPersonsToMM(
-          objects
-        );
-      case ERPObjType.RESOURCES:
-        return await this.sendResourcesToMM(
-          objects
-        );
-      case ERPObjType.PARTS:
-        return await this.sendPartsToMM(objects);
-      case ERPObjType.PART_OPERATION:
-        return await this.sendPartOperationsToMM(
-          objects
-        );
-      case ERPObjType.WORK_ORDERS:
-        return await this.sendWorkOrdersToMM(
-          objects
-        );
-      case ERPObjType.WORK_ORDER_OPERATIONS:
-        return await this.sendWorkOrderOperationsToMM(
-          objects
-        );
-      case ERPObjType.REASONS:
-        return await this.sendReasonsToMM(
-          objects
-        );
-      case ERPObjType.LABOR_TICKETS:
-        return await this.sendLaborTicketsToMM(
-          objects
-        );
-      default:
-        throw new Error(`Unsupported type: ${ERPObjType[type]}`);
-    }
-  }
-  /**
-   * Update the labor ticket ERP ID by laborTicketRef
-   * @param laborTicketRef The MM API labor ticket unique ID
-   * @param erpObjectId The ERP labor ticket ID to update
-   * @returns The updated labor ticket
-   */
-  async updateLaborTicketIdByRef(laborTicketRef, laborTicketId) {
-    return await this.patchData(
-      `${this.resourceURLs[ERPObjType.LABOR_TICKETS]}/${laborTicketRef}`,
-      { laborTicketId }
-    );
-  }
-  /**
-   * Add failed labor ticket refs to the MM API
-   * @param failedTicketRefs The failed labor ticket references
-   * @returns The response from the MM API
-   */
-  async addFailedLaborTicketRefs(system, failedTicketRefs) {
-    return await this.postData(
-      `${this.resourceURLs[ERPObjType.LABOR_TICKETS]}/failed`,
-      { failedTicketRefs },
-      { system }
-    );
-  }
-  async fetchFailedLaborTickets(system) {
-    const failedTickets = await this.getData(
-      `${this.resourceURLs[ERPObjType.LABOR_TICKETS]}/failed`,
-      { system }
-    );
-    return failedTickets.erpLaborTickets.map(
-      (ticket) => new MMReceiveLaborTicket(ticket)
-    );
-  }
-  /**
-   * Send connector logs to the MM API
-   * @param logEntry Single log entry to send
-   * @returns Promise with the API response
-   */
-  async sendConnectorLog(logEntry) {
-    return await this.postData(
-      "/connector/logs",
-      logEntry,
-      {},
-      {
-        baseUrl: "ApiBase"
-        /* ApiBase */
-      }
-    );
-  }
-  /**
-   * Send bulk connector logs to the MM API
-   * @param logs Array of log entries to send
-   * @returns Promise with the API response
-   */
-  async sendBulkConnectorLogs(logs) {
-    return await this.postData(
-      "/connector/logs",
-      { logs },
-      {},
-      {
-        baseUrl: "ApiBase"
-        /* ApiBase */
-      }
-    );
-  }
-  async deleteFailedLaborTicketIds(system, laborTicketRefs) {
-    return await this.postData(
-      `${this.resourceURLs[ERPObjType.LABOR_TICKETS]}/failed/remove`,
-      { laborTicketRefs },
-      { system }
-    );
-  }
-  /**
-   * Fetch machine groups from the MM API
-   * @returns Promise with the machine groups data
-   */
-  async fetchMachineGroups() {
-    return await this.getData(
-      this.resourceURLs[MACHINE_GROUPS],
-      {},
-      {
-        baseUrl: "ApiBase"
-        /* ApiBase */
-      }
-    );
-  }
-  /**
-   * Fetch resources using GraphQL
-   * @returns Promise with the resources data
-   */
-  async fetchResourcesFromGraphQL() {
-    return await this.graphqlRequest(
-      "getErpResources",
-      "query getErpResources { machineResource: erpResources { machineRef machineGroupId resourceId }}"
-    );
-  }
-  /**
-   * Cleanup all HTTP connections and resources
-   * Call this when the service is no longer needed
-   */
-  async destroy() {
-    await this.api.destroy();
-  }
-  //#endregion public methods
-}
-class MMSendPerson {
-  constructor(personId, firstName, lastName, isActive) {
-    this.personId = personId;
-    this.firstName = firstName;
-    this.lastName = lastName;
-    this.isActive = isActive;
-  }
-  toRESTApiObject() {
-    return {
-      personId: this.personId,
-      firstName: this.firstName,
-      lastName: this.lastName,
-      isActive: this.isActive ? "1" : "0"
-    };
-  }
-  static fromPlainObject(data) {
-    return new MMSendPerson(
-      data.personId || "",
-      data.firstName || "",
-      data.lastName || "",
-      data.isActive === "1"
-    );
-  }
-}
-class MMSendResource {
-  constructor(resourceId, name, isResourceGroup, description, type, productionBurdenRateHourly, setupBurdenRateHourly) {
-    this.resourceId = resourceId;
-    this.name = name;
-    this.isResourceGroup = isResourceGroup;
-    this.description = description;
-    this.type = type;
-    this.productionBurdenRateHourly = productionBurdenRateHourly;
-    this.setupBurdenRateHourly = setupBurdenRateHourly;
-  }
-  toRESTApiObject() {
-    return {
-      resourceId: this.resourceId,
-      name: this.name,
-      isResourceGroup: this.isResourceGroup ? "1" : "0",
-      description: this.description,
-      type: this.type,
-      productionBurdenRateHourly: this.productionBurdenRateHourly.toString(),
-      setupBurdenRateHourly: this.setupBurdenRateHourly.toString()
-    };
-  }
-  static fromPlainObject(data) {
-    return new MMSendResource(
-      data.resourceId || "",
-      data.name || "",
-      data.isResourceGroup === "1",
-      data.description || "",
-      data.type || "",
-      parseFloat(data.productionBurdenRateHourly || "0"),
-      parseFloat(data.setupBurdenRateHourly || "0")
-    );
-  }
-}
-class MMSendPart {
-  constructor(partNumber, partRevision, method) {
-    this.partNumber = partNumber;
-    this.partRevision = partRevision;
-    this.method = method;
-  }
-  toRESTApiObject() {
-    return {
-      partNumber: this.partNumber,
-      partRevision: this.partRevision,
-      method: this.method
-    };
-  }
-  static fromPlainObject(data) {
-    return new MMSendPart(
-      data.partNumber || "",
-      data.partRevision || "",
-      data.method || ""
-    );
-  }
-}
-class MMSendPartOperation {
-  constructor(partNumber, partRevision, method, sequenceNumber, resourceId, cycleTimeMs, setupTimeMs, description, quantityPerPart) {
-    this.partNumber = partNumber;
-    this.partRevision = partRevision;
-    this.method = method;
-    this.sequenceNumber = sequenceNumber;
-    this.resourceId = resourceId;
-    this.cycleTimeMs = cycleTimeMs;
-    this.setupTimeMs = setupTimeMs;
-    this.description = description;
-    this.quantityPerPart = quantityPerPart;
-  }
-  toRESTApiObject() {
-    return {
-      partNumber: this.partNumber,
-      partRevision: this.partRevision,
-      method: this.method,
-      sequenceNumber: this.sequenceNumber,
-      resourceId: this.resourceId,
-      cycleTimeMs: this.cycleTimeMs.toString(),
-      setupTimeMs: this.setupTimeMs.toString(),
-      description: this.description,
-      quantityPerPart: this.quantityPerPart.toString()
-    };
-  }
-  static fromPlainObject(data) {
-    return new MMSendPartOperation(
-      data.partNumber || "",
-      data.partRevision || "",
-      data.method || "",
-      data.sequenceNumber || "",
-      data.resourceId || "",
-      parseInt(data.cycleTimeMs || "0"),
-      parseInt(data.setupTimeMs || "0"),
-      data.description || "",
-      parseFloat(data.quantityPerPart || "1")
-    );
-  }
-}
-class MMSendWorkOrder {
-  constructor(workOrderId, lot, split, sub, status, dueDate, description, scheduledStartDate, scheduledEndDate, closedDate, quantityRequired, partNumber, partRevision, method) {
-    this.workOrderId = workOrderId;
-    this.lot = lot;
-    this.split = split;
-    this.sub = sub;
-    this.status = status;
-    this.dueDate = dueDate;
-    this.description = description;
-    this.scheduledStartDate = scheduledStartDate;
-    this.scheduledEndDate = scheduledEndDate;
-    this.closedDate = closedDate;
-    this.quantityRequired = quantityRequired;
-    this.partNumber = partNumber;
-    this.partRevision = partRevision;
-    this.method = method;
-  }
-  toRESTApiObject() {
-    return {
-      workOrderId: this.workOrderId,
-      lot: this.lot,
-      split: this.split,
-      sub: this.sub,
-      status: this.status,
-      dueDate: this.dueDate,
-      description: this.description,
-      scheduledStartDate: this.scheduledStartDate,
-      scheduledEndDate: this.scheduledEndDate,
-      closedDate: this.closedDate,
-      quantityRequired: this.quantityRequired.toString(),
-      partNumber: this.partNumber,
-      partRevision: this.partRevision,
-      method: this.method
-    };
-  }
-  static fromPlainObject(data) {
-    return new MMSendWorkOrder(
-      data.workOrderId || "",
-      data.lot || "",
-      data.split || "",
-      data.sub || "",
-      data.status || "",
-      data.dueDate ?? null,
-      data.description || "",
-      data.scheduledStartDate ?? null,
-      data.scheduledEndDate ?? null,
-      data.closedDate ?? null,
-      parseFloat(data.quantityRequired || "0"),
-      data.partNumber || "",
-      data.partRevision || "",
-      data.method || ""
-    );
-  }
-}
-class MMSendWorkOrderOperation {
-  constructor(workOrderId, lot, split, sub, sequenceNumber, resourceId, startQuantity, finishQuantity, expectedRejectRate, scheduledStartDate, scheduledFinishDate, closedDate, cycleTimeMs, setupTimeMs, productionburdenRateHourly, setupburdenRatehourly, operationType, quantityPerPart, status) {
-    this.workOrderId = workOrderId;
-    this.lot = lot;
-    this.split = split;
-    this.sub = sub;
-    this.sequenceNumber = sequenceNumber;
-    this.resourceId = resourceId;
-    this.startQuantity = startQuantity;
-    this.finishQuantity = finishQuantity;
-    this.expectedRejectRate = expectedRejectRate;
-    this.scheduledStartDate = scheduledStartDate;
-    this.scheduledFinishDate = scheduledFinishDate;
-    this.closedDate = closedDate;
-    this.cycleTimeMs = cycleTimeMs;
-    this.setupTimeMs = setupTimeMs;
-    this.productionburdenRateHourly = productionburdenRateHourly;
-    this.setupburdenRatehourly = setupburdenRatehourly;
-    this.operationType = operationType;
-    this.quantityPerPart = quantityPerPart;
-    this.status = status;
-  }
-  toRESTApiObject() {
-    return {
-      workOrderId: this.workOrderId,
-      lot: this.lot,
-      split: this.split,
-      sub: this.sub,
-      sequenceNumber: this.sequenceNumber,
-      resourceId: this.resourceId,
-      startQuantity: this.startQuantity.toString(),
-      finishQuantity: this.finishQuantity.toString(),
-      expectedRejectRate: this.expectedRejectRate.toString(),
-      scheduledStartDate: this.scheduledStartDate,
-      scheduledFinishDate: this.scheduledFinishDate,
-      closedDate: this.closedDate,
-      cycleTimeMs: this.cycleTimeMs.toString(),
-      setupTimeMs: this.setupTimeMs.toString(),
-      productionburdenRateHourly: this.productionburdenRateHourly.toString(),
-      setupburdenRatehourly: this.setupburdenRatehourly.toString(),
-      operationType: this.operationType,
-      quantityPerPart: this.quantityPerPart.toString(),
-      status: this.status
-    };
-  }
-  static fromPlainObject(data) {
-    return new MMSendWorkOrderOperation(
-      data.workOrderId || "",
-      data.lot || "",
-      data.split || "",
-      data.sub || "",
-      data.sequenceNumber || "",
-      data.resourceId || "",
-      parseFloat(data.startQuantity || "0"),
-      parseFloat(data.finishQuantity || "0"),
-      parseFloat(data.expectedRejectRate || "0"),
-      data.scheduledStartDate ?? null,
-      data.scheduledFinishDate ?? null,
-      data.closedDate ?? null,
-      parseInt(data.cycleTimeMs || "0"),
-      parseInt(data.setupTimeMs || "0"),
-      parseFloat(data.productionburdenRateHourly || "0"),
-      parseFloat(data.setupburdenRatehourly || "0"),
-      data.operationType || "",
-      parseFloat(data.quantityPerPart || "1"),
-      data.status || ""
-    );
-  }
-}
-class MMSendReason {
-  constructor(reasonId, category, code, description, entityType) {
-    this.reasonId = reasonId;
-    this.category = category;
-    this.code = code;
-    this.description = description;
-    this.entityType = entityType;
-  }
-  toRESTApiObject() {
-    return {
-      reasonId: this.reasonId,
-      category: this.category,
-      code: this.code,
-      description: this.description,
-      entityType: this.entityType
-    };
-  }
-  static fromPlainObject(data) {
-    return new MMSendReason(
-      data.reasonId || "",
-      data.category || "",
-      data.code || "",
-      data.description || "",
-      data.entityType || ""
-    );
-  }
-}
-class MMSendLaborTicket {
-  constructor(workOrderId, lot, split, sub, sequenceNumber, resourceId, personId, laborTicketId, transactionDate, clockIn, clockOut, goodParts, badParts, type, comment, state) {
-    this.workOrderId = workOrderId;
-    this.lot = lot;
-    this.split = split;
-    this.sub = sub;
-    this.sequenceNumber = sequenceNumber;
-    this.resourceId = resourceId;
-    this.personId = personId;
-    this.laborTicketId = laborTicketId;
-    this.transactionDate = transactionDate;
-    this.clockIn = clockIn;
-    this.clockOut = clockOut;
-    this.goodParts = goodParts;
-    this.badParts = badParts;
-    this.type = type;
-    this.comment = comment;
-    this.state = state;
-  }
-  toRESTApiObject() {
-    return {
-      workOrderId: this.workOrderId,
-      lot: this.lot,
-      split: this.split,
-      sub: this.sub,
-      sequenceNumber: this.sequenceNumber,
-      resourceId: this.resourceId,
-      personId: this.personId,
-      laborTicketId: this.laborTicketId,
-      transactionDate: this.transactionDate,
-      clockIn: this.clockIn,
-      clockOut: this.clockOut,
-      goodParts: this.goodParts.toString(),
-      badParts: this.badParts.toString(),
-      type: this.type,
-      comment: this.comment,
-      state: this.state
-    };
-  }
-  static fromPlainObject(data) {
-    return new MMSendLaborTicket(
-      data.workOrderId || "",
-      data.lot || "",
-      data.split || "",
-      data.sub || "",
-      data.sequenceNumber || "",
-      data.resourceId || "",
-      data.personId || "",
-      data.laborTicketId || "",
-      data.transactionDate ?? null,
-      data.clockIn ?? null,
-      data.clockOut ?? null,
-      parseInt(data.goodParts || "0"),
-      parseInt(data.badParts || "0"),
-      data.type || "",
-      data.comment || "",
-      data.state || ""
-    );
-  }
-}
-function getUniqueRows(data, fields, sortFields) {
-  const createCompositeKey = (item) => {
-    return fields.map((field) => String(item[field])).join("|");
-  };
-  const uniqueKeys = /* @__PURE__ */ new Set();
-  const uniqueRows = [];
-  data.forEach((item) => {
-    const key = createCompositeKey(item);
-    if (!uniqueKeys.has(key)) {
-      uniqueKeys.add(key);
-      uniqueRows.push(item);
-    }
-  });
-  if (sortFields && sortFields.length > 0) {
-    uniqueRows.sort((a2, b) => {
-      for (let i = 0; i < sortFields.length; i++) {
-        const field = sortFields[i];
-        if (a2[field] < b[field]) return -1;
-        if (a2[field] > b[field]) return 1;
-      }
-      return 0;
-    });
-  }
-  return uniqueRows || [];
-}
-const removeExtraneousFields = (recordset, retainFields) => {
-  const data = recordset.map((row) => {
-    const transformedRow = {};
-    Object.keys(row).forEach((key) => {
-      if (retainFields.includes(key)) {
-        transformedRow[key] = row[key]?.toString() || "";
-      }
-    });
-    return transformedRow;
-  }) || [];
-  return data;
-};
-const getPayloadWithoutIDField = (recordset, idField) => {
-  const data = recordset.map((row) => {
-    const transformedRow = {};
-    Object.keys(row).forEach((key) => {
-      if (!idField.includes(key)) {
-        transformedRow[key] = row[key]?.toString() || "";
-      }
-    });
-    return transformedRow;
-  }) || [];
-  return data;
-};
-const trimObjectValues = (obj) => {
-  return Object.keys(obj).reduce((acc, key) => {
-    const value = obj[key];
-    acc[key] = typeof value === "string" ? value.trim() : value;
-    return acc;
-  }, {});
-};
-const cleanupNumbers = (data) => {
-  data = data.toString().replace(/[^0-9\.]+/g, "");
-  return data;
-};
-const addNewFieldFromExternalSource = (data, externalSource, externalSourceFieldName, newFieldName, defaultValue = "-") => {
-  return data.map((current) => {
-    const cacheEntry = externalSource.find(
-      (existing) => existing[externalSourceFieldName] === current[externalSourceFieldName]
-    );
-    const newFieldValue = cacheEntry?.[newFieldName] || defaultValue;
-    return {
-      ...current,
-      [newFieldName]: newFieldValue
-    };
-  });
-};
-const addNewFieldFromLookupField = (data, externalSource, lookupField, currentField, newFieldName, defaultValue = "-") => {
-  return data.map((current) => {
-    const cacheEntry = externalSource.find(
-      (existing) => existing[lookupField] === current[currentField]
-    );
-    const newFieldValue = cacheEntry?.[currentField] || defaultValue;
-    return {
-      ...current,
-      [newFieldName]: newFieldValue
-    };
-  });
-};
-const getTimezoneOffset = async () => {
-  try {
-    const config2 = CoreConfiguration.inst();
-    const apiUrl = config2.mmApiBaseUrl;
-    const authToken = config2.mmApiAuthToken;
-    if (!apiUrl || !authToken) {
-      throw new Error("Missing required configuration for timezone fetch");
-    }
-    const client = HTTPClientFactory.getInstance({
-      baseUrl: apiUrl,
-      retryAttempts: config2.mmApiRetryAttempts
-    });
-    const response = await client.request({
-      url: "/accounts/current",
-      method: "GET",
-      headers: {
-        Authorization: `Bearer ${authToken}`
-      }
-    });
-    const userInfo = response.data;
-    if (!userInfo?.company?.timezone) {
-      throw new Error("Unable to retrieve company timezone from API");
-    }
-    const timezone = userInfo.company.timezone;
-    const date = /* @__PURE__ */ new Date();
-    const utcDate = new Date(date.toLocaleString("en-US", { timeZone: "UTC" }));
-    const tzDate = new Date(
-      date.toLocaleString("en-US", { timeZone: timezone })
-    );
-    const offset = (tzDate.getTime() - utcDate.getTime()) / 36e5;
-    return { offset, timezone };
-  } catch (error) {
-    throw new Error(
-      `Failed to get timezone offset: ${error instanceof Error ? error.message : "Unknown error"}`
-    );
-  }
-};
-const convertToLocalTime = (zuluTime, timezoneOffset) => {
-  if (!zuluTime) return void 0;
-  const date = new Date(zuluTime);
-  return new Date(date.getTime() + timezoneOffset * 60 * 60 * 1e3);
-};
-const formatDateWithTZOffset = (date, timezoneOffset) => {
-  if (!date) return void 0;
-  const isoDate = date.replace(" ", "T");
-  const sign = timezoneOffset >= 0 ? "+" : "-";
-  const absOffset = Math.abs(timezoneOffset);
-  const hours = Math.floor(absOffset).toString().padStart(2, "0");
-  const minutes = Math.floor(absOffset % 1 * 60).toString().padStart(2, "0");
-  return `${isoDate}${sign}${hours}:${minutes}`;
-};
-const toISOWithOffset = (date, timezoneOffset) => {
-  const sign = timezoneOffset >= 0 ? "+" : "-";
-  const abs = Math.abs(timezoneOffset);
-  const hours = Math.floor(abs);
-  const minutes = Math.round((abs - hours) * 60);
-  const pad2 = (n) => n.toString().padStart(2, "0");
-  const pad3 = (n) => n.toString().padStart(3, "0");
-  const yyyy = date.getUTCFullYear();
-  const MM = pad2(date.getUTCMonth() + 1);
-  const dd = pad2(date.getUTCDate());
-  const HH = pad2(date.getUTCHours());
-  const mm = pad2(date.getUTCMinutes());
-  const ss = pad2(date.getUTCSeconds());
-  const SSS = pad3(date.getUTCMilliseconds());
-  const off = `${sign}${pad2(hours)}:${pad2(minutes)}`;
-  return `${yyyy}-${MM}-${dd}T${HH}:${mm}:${ss}.${SSS}${off}`;
-};
-function calculateTimeDifferenceInHours(startTime, endTime, timezoneOffset) {
-  if (!startTime || !endTime) return 0;
-  const localStartTime = convertToLocalTime(startTime, timezoneOffset);
-  const localEndTime = convertToLocalTime(endTime, timezoneOffset);
-  if (!localStartTime || !localEndTime) return 0;
-  const startHours = localStartTime.getHours();
-  const startMinutes = localStartTime.getMinutes();
-  const startSeconds = localStartTime.getSeconds();
-  const endHours = localEndTime.getHours();
-  const endMinutes = localEndTime.getMinutes();
-  const endSeconds = localEndTime.getSeconds();
-  const startTotalSeconds = startHours * 3600 + startMinutes * 60 + startSeconds;
-  const endTotalSeconds = endHours * 3600 + endMinutes * 60 + endSeconds;
-  if (endTotalSeconds > startTotalSeconds) {
-    return Number(((endTotalSeconds - startTotalSeconds) / 3600).toFixed(3));
-  }
-  return 0;
-}
-const getSecondsOfDay = (timestamp) => {
-  if (!timestamp) return null;
-  const time = new Date(timestamp);
-  const utcHours = time.getUTCHours();
-  const utcMinutes = time.getUTCMinutes();
-  const utcSeconds = time.getUTCSeconds();
-  return (utcHours * 3600 + utcMinutes * 60 + utcSeconds).toString();
-};
-const applyTimezoneOffsetsToFields = (item, fields, timezoneOffset) => {
-  const transformed = { ...item };
-  fields.forEach((field) => {
-    if (transformed[field] && transformed[field].trim()) {
-      const formattedDate = formatDateWithTZOffset(
-        transformed[field],
-        timezoneOffset
-      );
-      transformed[field] = formattedDate || "";
-    } else {
-      transformed[field] = "";
-    }
-  });
-  return transformed;
-};
-const getTimezoneOffsetAndPersist = async (params = {
-  maxRetries: 36e3,
-  // Retry for 10 hours before giving up.
-  retryIntervalMs: 1e4
-}) => {
-  let success = false;
-  let retries = 0;
-  logger.info(
-    "Acquiring the timezone offset and timezone name from MachineMetrics and storing in cache"
-  );
-  while (!success && retries < params.maxRetries) {
-    try {
-      const { offset, timezone } = await getTimezoneOffset();
-      logger.info(`Timezone offset: ${offset} hours, timezone: ${timezone}`);
-      setTimezoneOffsetInCache(offset);
-      setTimezoneNameInCache(timezone);
-      success = true;
-    } catch (error) {
-      logger.error("Error getting timezone offset:", error);
-      logger.info(`Retrying in ${params.retryIntervalMs / 1e3} seconds...`);
-      await new Promise(
-        (resolve) => setTimeout(resolve, params.retryIntervalMs)
-      );
-      retries++;
-    }
-  }
-  if (!success) {
-    throw new Error(
-      `Failed to get the timezone offset after ${params.maxRetries} retries`
-    );
-  }
-};
-const DEFAULT_RECORD_TRACKING_TABLE_NAME = "record_tracking";
-class RecordTrackingManager {
-  db;
-  constructor() {
-    this.db = knex(config.local);
-  }
-  async updateRecord(record) {
-    if (record.lastValue && record.recordId) {
-      const recordUpdated = await this.db(DEFAULT_RECORD_TRACKING_TABLE_NAME).where({ entityType: record.entityType }).update(record);
-      if (recordUpdated < 1) {
-        await this.db(DEFAULT_RECORD_TRACKING_TABLE_NAME).insert(record);
-      }
-    }
-  }
-  async getTrackingRecord(type) {
-    return await this.db(DEFAULT_RECORD_TRACKING_TABLE_NAME).select("*").where({ entityType: type.toString() });
-  }
-  async destroy() {
-    return this.db.destroy();
-  }
-}
-class BatchCacheManager {
-  cacheManager;
-  constructor(options) {
-    this.cacheManager = new HashedCacheManager({
-      ttl: options?.ttl,
-      tableName: options?.tableName
-    });
-  }
-  /**
-   * Checks a batch of objects against the cache and separates them into duplicates and non-duplicates
-   * @param type The type of objects
-   * @param objects Array of objects to check
-   * @returns Object containing arrays of duplicate and non-duplicate objects
-   */
-  async dedupeBatch(type, objects) {
-    const result = {
-      duplicates: [],
-      nonDuplicates: []
-    };
-    for (const object of objects) {
-      const hasChanged = await this.cacheManager.hasChanged(type, object);
-      if (hasChanged) {
-        result.nonDuplicates.push(object);
-      } else {
-        result.duplicates.push(object);
-      }
-    }
-    return result;
-  }
-  /**
-   * Stores a batch of objects in the cache
-   * @param type The type of objects
-   * @param objects Array of objects to store
-   */
-  async storeBatch(type, objects) {
-    let totalInserted = 0;
-    for (const object of objects) {
-      if (await this.cacheManager.store(type, object)) {
-        totalInserted++;
-      }
-    }
-    return { totalInserted };
-  }
-  /**
-   * Removes objects from the cache
-   * @param type The type of objects
-   * @param objects Array of objects to remove
-   */
-  async removeObjects(type, objects) {
-    for (const object of objects) {
-      await this.cacheManager.removeRecord(type, object);
-    }
-  }
-  /**
-   * Gets all records of a specific type
-   */
-  async getRecordsByType(type) {
-    return this.cacheManager.getRecordsByType(type);
-  }
-  /**
-   * Removes all records of a specific type
-   */
-  async removeRecordsByType(type) {
-    return this.cacheManager.removeRecordsByType(type);
-  }
-  /**
-   * Clears all records from the cache
-   */
-  async clear() {
-    return this.cacheManager.clear();
-  }
-  /**
-   * Cleans up resources
-   */
-  async destroy() {
-    return this.cacheManager.destroy();
-  }
-}
-function convertLaborTicketToLocalTimezone(laborTicket, timezoneOffset) {
-  const timeFields = [
-    "clockIn",
-    "clockOut",
-    "transactionDate",
-    "createdAt",
-    "updatedAt",
-    "workOrderOperationClosedDate"
-  ];
-  timeFields.forEach((field) => {
-    const localTime = convertToLocalTime(laborTicket[field], timezoneOffset);
-    laborTicket[field] = localTime ? toISOWithOffset(localTime, timezoneOffset) : null;
-  });
-  return laborTicket;
-}
-class LaborTicketERPSynchronizer {
-  /**
-   * Synchronizes updated labor tickets from MachineMetrics to an ERP system
-   */
-  static async syncToERP(connectorType, connector) {
-    try {
-      const mmApiClient = new MMApiClient();
-      const failedLaborTicketRefs = [];
-      await mmApiClient.initializeCheckpoint({
-        system: connectorType,
-        table: "labor_tickets",
-        checkpointType: "export",
-        checkpointValue: {
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        }
-      });
-      const fallbackTimestamp = (/* @__PURE__ */ new Date()).toISOString();
-      const laborTicketsUpdates = await mmApiClient.fetchLaborTicketUpdates({
-        system: connectorType,
-        checkpointType: "export"
-      });
-      if (laborTicketsUpdates.length === 0) {
-        logger.info("syncLaborTicketsToERP:No updated labor tickets found");
-        return;
-      }
-      logger.info(
-        `ToERP: Found ${laborTicketsUpdates.length} Labor Ticket Ids and Refs to process`,
-        {
-          laborTickets: laborTicketsUpdates.map(
-            (ticket) => ({
-              ref: ticket.laborTicketRef,
-              id: ticket.laborTicketId
-            })
-          )
-        }
-      );
-      const mostRecentUpdate = laborTicketsUpdates.reduce(
-        (latest, ticket) => {
-          if (!latest || !ticket.updatedAt) return latest;
-          return new Date(ticket.updatedAt) > new Date(latest) ? ticket.updatedAt : latest;
-        },
-        null
-      );
-      await Promise.all(
-        laborTicketsUpdates.map(async (laborTicket) => {
-          if (!laborTicket.laborTicketRef) {
-            logger.error(
-              "syncLaborTicketsToERP: laborTicketRef is not set for laborTicket pulled from MM:",
-              { laborTicket }
-            );
-            return void 0;
-          }
-          try {
-            return await this.processLaborTicket(
-              connector,
-              mmApiClient,
-              laborTicket
-            );
-          } catch (error) {
-            failedLaborTicketRefs.push(laborTicket.laborTicketRef);
-            logger.error(
-              `syncLaborTicketsToERP: Error processing laborTicketRef ${laborTicket.laborTicketRef}:`,
-              { error }
-            );
-            return void 0;
-          }
-        })
-      );
-      logger.info(
-        `syncLaborTicketsToERP: ${failedLaborTicketRefs.length} failed labor ticket ids`
-      );
-      if (failedLaborTicketRefs.length > 0) {
-        logger.info(
-          `syncLaborTicketsToERP: Reporting ${failedLaborTicketRefs.length} labor ticket failures:`,
-          {
-            failedLaborTicketRefs
-          }
-        );
-        const addFailedResult = await mmApiClient.addFailedLaborTicketRefs(
-          connectorType,
-          failedLaborTicketRefs
-        );
-        logger.info("syncLaborTicketsToERP: addFailedResult:", {
-          addFailedResult
-        });
-      }
-      mmApiClient.saveCheckpoint({
-        system: connectorType,
-        table: "labor_tickets",
-        checkpointType: "export",
-        checkpointValue: {
-          timestamp: mostRecentUpdate || fallbackTimestamp
-        }
-      });
-    } catch (error) {
-      logger.error("syncLaborTicketsToERP: Error:", error);
-    }
-  }
-  /**
-   * Retries labor tickets that have failed to be created or updated in the ERP during the sync
-   */
-  static async retryFailed(connectorType, connector) {
-    try {
-      const mmApiClient = new MMApiClient();
-      const successLaborTicketIds = [];
-      const laborTickets = await mmApiClient.fetchFailedLaborTickets(connectorType);
-      if (laborTickets.length === 0) {
-        logger.info("retryFailedLaborTickets: No failed labor tickets found");
-        return;
-      }
-      logger.info(
-        "retryFailedLaborTickets: Failed Labor Tickets count:" + laborTickets.length
-      );
-      await Promise.all(
-        laborTickets.map(async (laborTicket) => {
-          if (!laborTicket.laborTicketRef) {
-            logger.error(
-              "retryFailedLaborTickets: laborTicketRef is not set for laborTicket pulled from MM:",
-              { laborTicket }
-            );
-            return void 0;
-          }
-          try {
-            const laborTicketResult = await this.processLaborTicket(
-              connector,
-              mmApiClient,
-              laborTicket
-            );
-            successLaborTicketIds.push(laborTicket.laborTicketRef);
-            return laborTicketResult;
-          } catch (error) {
-            logger.error(
-              "retryFailedLaborTickets: Error processing laborTicketRef:",
-              { laborTicketRef: laborTicket.laborTicketRef, error }
-            );
-            return void 0;
-          }
-        })
-      );
-      if (successLaborTicketIds.length > 0) {
-        logger.info("Deleting failed labor ticket ids:", {
-          successLaborTicketIds
-        });
-        const deleteFailedResult = await mmApiClient.deleteFailedLaborTicketIds(
-          connectorType,
-          successLaborTicketIds
-        );
-        logger.info("deleteFailedResult:", { deleteFailedResult });
-      }
-    } catch (error) {
-      logger.error("retryFailedLaborTickets: Error:", error);
-    }
-  }
-  // ============================================================================
-  // PRIVATE HELPER METHODS
-  // ============================================================================
-  static async writeLaborTicketIdToMM(mmApiClient, laborTicket, laborTicketResult) {
-    const updateRefAPIResponse = await mmApiClient.updateLaborTicketIdByRef(
-      laborTicket.laborTicketRef,
-      laborTicketResult.laborTicketId
-    );
-    logger.info(
-      `Updated laborTicketId ${laborTicketResult.laborTicketId} for laborTicketRef ${laborTicket.laborTicketRef} in MM:`,
-      { updateRefAPIResponse }
-    );
-  }
-  static async processLaborTicket(connector, mmApiClient, laborTicket) {
-    let laborTicketResult;
-    laborTicketResult = convertLaborTicketToLocalTimezone(
-      laborTicket,
-      getCachedTimezoneOffset()
-    );
-    logger.info(
-      `processing laborTicket, id=${laborTicket.laborTicketId}, ref=${laborTicket.laborTicketRef}`
-    );
-    logger.debug({ laborTicket });
-    if (!laborTicket.laborTicketId) {
-      const { laborTicket: laborTicketResult2, erpUid } = await connector.createLaborTicketInERP(laborTicket);
-      laborTicketResult2.laborTicketId = erpUid;
-      await this.writeLaborTicketIdToMM(
-        mmApiClient,
-        laborTicket,
-        laborTicketResult2
-      );
-    } else {
-      laborTicketResult = await connector.updateLaborTicketInERP(laborTicket);
-    }
-    logger.info("ToERP: laborTicket update result:", {
-      laborTicketResult: laborTicketResult || "Failed to create/update labor ticket",
-      laborTicketRef: laborTicket.laborTicketRef,
-      operation: laborTicket.laborTicketId ? "update" : "create"
-    });
-    return laborTicketResult;
-  }
-}
-class EntityTransformer {
-  // ============================================================================
-  // PUBLIC INTERFACE METHODS
-  // ============================================================================
-  /**
-   * Extracts the primary key from a record based on entity type
-   * @param entityType The type of entity being processed
-   * @param record The record to extract primary key from
-   * @returns A string representation of the primary key
-   * @throws Error if primary key fields are missing or invalid
-   */
-  static extractPrimaryKey(entityType, record) {
-    switch (entityType) {
-      case ERPObjType.PERSONS:
-        return this.extractPersonKey(record);
-      case ERPObjType.RESOURCES:
-        return this.extractResourceKey(record);
-      case ERPObjType.PARTS:
-        return this.extractPartKey(record);
-      case ERPObjType.PART_OPERATION:
-        return this.extractPartOperationKey(record);
-      case ERPObjType.WORK_ORDERS:
-        return this.extractWorkOrderKey(record);
-      case ERPObjType.WORK_ORDER_OPERATIONS:
-        return this.extractWorkOrderOperationKey(record);
-      case ERPObjType.LABOR_TICKETS:
-        return this.extractLaborTicketKey(record);
-      case ERPObjType.REASONS:
-        return this.extractReasonKey(record);
-      default:
-        throw new Error(
-          `Unsupported entity type for primary key extraction: ${entityType}`
-        );
-    }
-  }
-  /**
-   * Reconstructs a typed object from plain data based on entity type
-   * @param entityType The type of entity being processed
-   * @param plainData The plain data object containing entity fields
-   * @returns A properly typed IToRESTApiObject instance
-   * @throws Error if the entity type is not supported
-   */
-  static reconstructFromPlainData(entityType, plainData) {
-    switch (entityType) {
-      case ERPObjType.PERSONS:
-        return this.reconstructPerson(plainData);
-      case ERPObjType.RESOURCES:
-        return this.reconstructResource(plainData);
-      case ERPObjType.PARTS:
-        return this.reconstructPart(plainData);
-      case ERPObjType.PART_OPERATION:
-        return this.reconstructPartOperation(plainData);
-      case ERPObjType.WORK_ORDERS:
-        return this.reconstructWorkOrder(plainData);
-      case ERPObjType.WORK_ORDER_OPERATIONS:
-        return this.reconstructWorkOrderOperation(plainData);
-      case ERPObjType.LABOR_TICKETS:
-        return this.reconstructLaborTicket(plainData);
-      case ERPObjType.REASONS:
-        return this.reconstructReason(plainData);
-      default:
-        throw new Error(
-          `Unsupported entity type for reconstruction: ${entityType}`
-        );
-    }
-  }
-  /**
-   * Reconstructs multiple typed objects from plain data based on entity type
-   * @param entityType The type of entity being processed
-   * @param plainDataArray Array of plain data objects containing entity fields
-   * @returns Array of properly typed IToRESTApiObject instances
-   */
-  static reconstructMultipleFromPlainData(entityType, plainDataArray) {
-    return plainDataArray.map(
-      (plainData) => this.reconstructFromPlainData(entityType, plainData)
-    );
-  }
-  // ============================================================================
-  // PRIVATE ENTITY-SPECIFIC KEY EXTRACTION METHODS
-  // ============================================================================
-  static extractPersonKey(record) {
-    const restApiObject = record.toRESTApiObject();
-    return this.validateAndExtractKey(restApiObject, ["personId"], "PERSONS", [
-      "personId"
-    ]);
-  }
-  static extractResourceKey(record) {
-    const restApiObject = record.toRESTApiObject();
-    return this.validateAndExtractKey(
-      restApiObject,
-      ["resourceId"],
-      "RESOURCES",
-      ["resourceId"]
-    );
-  }
-  static extractPartKey(record) {
-    const restApiObject = record.toRESTApiObject();
-    return this.validateAndExtractKey(
-      restApiObject,
-      ["partNumber", "partRevision", "method"],
-      "PARTS",
-      ["partNumber"]
-    );
-  }
-  static extractPartOperationKey(record) {
-    const restApiObject = record.toRESTApiObject();
-    return this.validateAndExtractKey(
-      restApiObject,
-      ["partNumber", "partRevision", "method", "sequenceNumber"],
-      "PART_OPERATION",
-      ["partNumber", "sequenceNumber"]
-    );
-  }
-  static extractWorkOrderKey(record) {
-    const restApiObject = record.toRESTApiObject();
-    return this.validateAndExtractKey(
-      restApiObject,
-      ["workOrderId", "lot", "split", "sub"],
-      "WORK_ORDERS",
-      ["workOrderId"]
-    );
-  }
-  static extractWorkOrderOperationKey(record) {
-    const restApiObject = record.toRESTApiObject();
-    return this.validateAndExtractKey(
-      restApiObject,
-      ["workOrderId", "lot", "split", "sub", "sequenceNumber"],
-      "WORK_ORDER_OPERATIONS",
-      ["workOrderId", "sequenceNumber"]
-    );
-  }
-  static extractLaborTicketKey(record) {
-    const restApiObject = record.toRESTApiObject();
-    if (restApiObject.laborTicketId) {
-      return this.validateAndExtractKey(
-        restApiObject,
-        ["laborTicketId"],
-        "LABOR_TICKETS",
-        ["laborTicketId"]
-      );
-    } else {
-      return this.validateAndExtractKey(
-        restApiObject,
-        [
-          "workOrderId",
-          "lot",
-          "split",
-          "sub",
-          "sequenceNumber",
-          "resourceId",
-          "personId"
-        ],
-        "LABOR_TICKETS",
-        ["workOrderId", "sequenceNumber", "resourceId", "personId"]
-      );
-    }
-  }
-  static extractReasonKey(record) {
-    const restApiObject = record.toRESTApiObject();
-    return this.validateAndExtractKey(restApiObject, ["reasonId"], "REASONS", [
-      "reasonId"
-    ]);
-  }
-  // ============================================================================
-  // PRIVATE ENTITY-SPECIFIC RECONSTRUCTION METHODS
-  // ============================================================================
-  static reconstructPerson(plainData) {
-    return MMSendPerson.fromPlainObject(plainData);
-  }
-  static reconstructResource(plainData) {
-    return MMSendResource.fromPlainObject(plainData);
-  }
-  static reconstructPart(plainData) {
-    return MMSendPart.fromPlainObject(plainData);
-  }
-  static reconstructPartOperation(plainData) {
-    return MMSendPartOperation.fromPlainObject(plainData);
-  }
-  static reconstructWorkOrder(plainData) {
-    return MMSendWorkOrder.fromPlainObject(plainData);
-  }
-  static reconstructWorkOrderOperation(plainData) {
-    return MMSendWorkOrderOperation.fromPlainObject(plainData);
-  }
-  static reconstructLaborTicket(plainData) {
-    return MMSendLaborTicket.fromPlainObject(plainData);
-  }
-  static reconstructReason(plainData) {
-    return MMSendReason.fromPlainObject(plainData);
-  }
-  // ============================================================================
-  // SHARED UTILITY METHODS
-  // ============================================================================
-  /**
-   * Helper method to validate and extract primary key components
-   * @param restApiObject The REST API object representation
-   * @param keyFields The fields that make up the primary key
-   * @param entityTypeName The entity type name for error messages
-   * @param requiredFields The fields that must be non-empty (others can be empty)
-   * @returns Combined primary key string
-   * @throws Error if any required field is missing or null
-   */
-  static validateAndExtractKey(restApiObject, keyFields, entityTypeName, requiredFields) {
-    const keyValues = [];
-    for (const field of keyFields) {
-      const value = restApiObject[field];
-      if (requiredFields.includes(field)) {
-        if (value === null || value === void 0 || value === "") {
-          throw new Error(
-            `Primary key field '${field}' is missing or empty for entity type ${entityTypeName}`
-          );
-        }
-      }
-      keyValues.push(value || "");
-    }
-    return keyValues.join("|");
-  }
-}
-class ErrorProcessor {
-  /**
-   * Creates a set of primary keys for all failed records from batch errors
-   * @param entityType The type of entity being processed
-   * @param batchErrors Array of batch errors containing failed entities
-   * @returns Set of primary keys for failed records
-   */
-  static createFailedRecordKeySet(entityType, batchErrors) {
-    const failedKeySet = /* @__PURE__ */ new Set();
-    batchErrors.forEach((batchError) => {
-      batchError.affectedEntities.forEach((affectedEntity) => {
-        try {
-          const primaryKey = EntityTransformer.extractPrimaryKey(
-            entityType,
-            affectedEntity
-          );
-          failedKeySet.add(primaryKey);
-        } catch (error) {
-          logger.warn(
-            `Failed to extract primary key from error entity: ${error}`
-          );
-        }
-      });
-    });
-    return failedKeySet;
-  }
-  /**
-   * Filters out failed records, returning only successful ones
-   * @param entityType The type of entity being processed
-   * @param allRecords All records (typed objects) that were sent to the API
-   * @param failedKeySet Set of primary keys for records that failed
-   * @returns Array of records that succeeded
-   */
-  static filterSuccessfulRecords(entityType, allRecords, failedKeySet) {
-    const successfulRecords = [];
-    allRecords.forEach((record) => {
-      try {
-        const primaryKey = EntityTransformer.extractPrimaryKey(
-          entityType,
-          record
-        );
-        if (!failedKeySet.has(primaryKey)) {
-          successfulRecords.push(record);
-        }
-      } catch (error) {
-        logger.warn(
-          `Failed to extract primary key from record during filtering: ${error}`
-        );
-      }
-    });
-    return successfulRecords;
-  }
-  /**
-   * Orchestrates the caching of successful records on partial failure
-   * @param entityType The type of entity being processed
-   * @param toProcess All records that were sent to the API (all are now guaranteed to be typed objects)
-   * @param batchErrors Array of batch errors containing failed entities
-   * @param batchCacheManager The cache manager instance
-   */
-  static async cacheSuccessfulRecordsOnPartialFailure(entityType, toProcess, batchErrors, batchCacheManager) {
-    const failedKeySet = this.createFailedRecordKeySet(entityType, batchErrors);
-    const successfulRecords = this.filterSuccessfulRecords(
-      entityType,
-      toProcess,
-      failedKeySet
-    );
-    logger.info(
-      `Caching ${successfulRecords.length} successful records out of ${toProcess.length} total records`
-    );
-    if (successfulRecords.length > 0) {
-      await batchCacheManager.storeBatch(entityType, successfulRecords);
-    }
-  }
-  /**
-   * Extracts error count and batch errors from MM API response for partial failures (HTTP 207)
-   * This supports all entities, including the slightly different format for labor tickets.
-   * In case of labor tickets, the updateErrors and insertErrors arrays are combined into affectedEntities.
-   * @param mmApiResponse The full MM API response object
-   * @param entityType The type of entity being processed (determines response structure)
-   * @returns Object containing errorCount and batchErrors
-   * See MM207NonLaborTicketResponse and MM207LaborTicketResponse for response structure details
-   */
-  static extractErrorDetails(mmApiResponse, entityType) {
-    const data = mmApiResponse.data;
-    let allErrors = [];
-    if (entityType === ERPObjType.LABOR_TICKETS) {
-      const updateErrors = data?.updateErrors || [];
-      const insertErrors = data?.insertErrors || [];
-      if (!data?.updateErrors && !data?.insertErrors) {
-        logger.warn(
-          "Labor tickets partial success response missing both updateErrors and insertErrors arrays"
-        );
-      }
-      allErrors = [...updateErrors, ...insertErrors];
-    } else {
-      const errors = data?.errors || [];
-      if (!data?.errors) {
-        logger.warn(
-          `${entityType} partial success response missing errors array`
-        );
-      }
-      allErrors = errors;
-    }
-    const batchErrors = allErrors.filter(
-      (error) => {
-        return error.batchData && error.batchData.length > 0;
-      }
-    ).map(
-      (error) => {
-        const typedErrorEntities = (error.batchData || []).map((entity) => {
-          if (typeof entity === "object" && entity !== null && "toRESTApiObject" in entity && typeof entity.toRESTApiObject === "function") {
-            return entity;
-          } else {
-            return EntityTransformer.reconstructFromPlainData(
-              entityType,
-              entity
-            );
-          }
-        });
-        return {
-          message: error.message,
-          affectedEntities: typedErrorEntities
-        };
-      }
-    );
-    const errorCount = batchErrors.reduce((total, batchError) => {
-      return total + batchError.affectedEntities.length;
-    }, 0);
-    return {
-      errorCount,
-      batchErrors
-    };
-  }
-  /**
-   * Extracts error details from a 500 HTTP exception when it contains structured error data
-   * @param exception The caught exception from MM API call
-   * @param entityType The type of entity being processed
-   * @returns Object containing errorCount and batchErrors, or null if not a structured 500 error
-   * See MM500NonLaborTicketException and MM500LaborTicketException for exception structure details
-   */
-  static extractErrorDetailsFrom500Exception(exception, entityType) {
-    try {
-      const ex = exception;
-      const data = ex?.data;
-      logger.info(
-        "writeEntitiesToMM: Analyzing 500 exception structure for diagnostic purposes",
-        {
-          status: ex?.status,
-          code: ex?.code,
-          hasResponseData: !!data,
-          responseDataKeys: data ? Object.keys(data) : [],
-          errorMessage: data?.error,
-          hasMessageObject: !!data?.message,
-          messageObjectKeys: data?.message ? Object.keys(data.message) : [],
-          entityType,
-          exceptionType: typeof exception,
-          exceptionKeys: ex ? Object.keys(ex) : []
-        }
-      );
-      if (ex?.status !== 500 || typeof data?.error !== "string" || !data.error.startsWith("Failed to import")) {
-        logger.info(
-          "writeEntitiesToMM: Not a structured 500 error - will re-throw exception as-is",
-          {
-            status: ex?.status,
-            errorMessage: data?.error,
-            expectedStatus: 500,
-            expectedMessagePrefix: "Failed to import"
-          }
-        );
-        return null;
-      }
-      logger.info(
-        "writeEntitiesToMM: Detected structured 500 error - extracting error details"
-      );
-      const messageObject = data?.message;
-      if (!messageObject) {
-        logger.warn(
-          "writeEntitiesToMM: Structured 500 error missing message object"
-        );
-        return null;
-      }
-      let allErrors = [];
-      if (entityType === ERPObjType.LABOR_TICKETS) {
-        const updateErrors = Array.isArray(messageObject?.updateErrors) ? messageObject.updateErrors : [];
-        const insertErrors = Array.isArray(messageObject?.insertErrors) ? messageObject.insertErrors : [];
-        logger.info("writeEntitiesToMM: Processing labor tickets 500 error", {
-          updateErrorsCount: updateErrors.length,
-          insertErrorsCount: insertErrors.length
-        });
-        if (updateErrors.length === 0 && insertErrors.length === 0) {
-          logger.warn(
-            "writeEntitiesToMM: Labor tickets 500 error missing both updateErrors and insertErrors arrays"
-          );
-        }
-        allErrors = [...updateErrors, ...insertErrors];
-      } else {
-        const errors = Array.isArray(messageObject?.errors) ? messageObject.errors : [];
-        logger.info("writeEntitiesToMM: Processing regular entity 500 error", {
-          errorsCount: errors.length
-        });
-        if (errors.length === 0) {
-          logger.warn(
-            `writeEntitiesToMM: ${entityType} 500 error missing errors array`
-          );
-        }
-        allErrors = errors;
-      }
-      const batchErrors = allErrors.filter((error) => {
-        const err = error;
-        return Array.isArray(err?.batchData) && err.batchData.length > 0;
-      }).map((error) => {
-        const err = error;
-        const batchData = err?.batchData;
-        const typedErrorEntities = (batchData || []).map((entity) => {
-          if (typeof entity === "object" && entity !== null && "toRESTApiObject" in entity && typeof entity.toRESTApiObject === "function") {
-            return entity;
-          } else {
-            return EntityTransformer.reconstructFromPlainData(
-              entityType,
-              entity
-            );
-          }
-        });
-        return {
-          message: typeof err?.message === "string" ? err.message : "Unknown error",
-          affectedEntities: typedErrorEntities
-        };
-      });
-      const errorCount = batchErrors.reduce((total, batchError) => {
-        return total + batchError.affectedEntities.length;
-      }, 0);
-      logger.info("writeEntitiesToMM: Extracted 500 error details", {
-        batchErrorsCount: batchErrors.length,
-        totalErrorCount: errorCount,
-        entityType
-      });
-      return {
-        errorCount,
-        batchErrors
-      };
-    } catch (error) {
-      logger.error(
-        "writeEntitiesToMM: Failed to parse 500 exception structure safely",
-        {
-          error: error instanceof Error ? error.message : String(error),
-          exceptionType: typeof exception,
-          entityType
-        }
-      );
-      return null;
-    }
-  }
-}
-class MMEntityProcessor {
-  /**
-   * Writes entities to MM API with deduplication and caching
-   */
-  static async writeEntities(entityType, mmRecords, batchCacheManager) {
-    const { toProcess, result } = await this._prepareAndDedupe(
-      entityType,
-      mmRecords,
-      batchCacheManager
-    );
-    if (toProcess.length === 0) {
-      result.message = "All records were deduplicated locally - no records sent to MM API";
-      return result;
-    }
-    let mmApiResponse;
-    try {
-      mmApiResponse = await this._sendToAPI(entityType, toProcess);
-    } catch (exception) {
-      this._handleException(exception, entityType, result);
-    }
-    return await this._handleResponse(
-      mmApiResponse,
-      entityType,
-      toProcess,
-      result,
-      batchCacheManager
-    );
-  }
-  // ============================================================================
-  // PRIVATE HELPER METHODS
-  // ============================================================================
-  /**
-   * Deduplicates records against cache
-   * Returns the records to process and the result object
-   * If the batchCacheManager is provided, the records are deduplicated against the cache
-   * If the batchCacheManager is not provided, the records are not deduplicated
-   */
-  static async _prepareAndDedupe(entityType, mmRecords, batchCacheManager) {
-    let toProcess = [];
-    const result = {
-      message: "",
-      upsertedEntities: 0,
-      localDedupeCount: 0,
-      apiDedupeCount: 0
-    };
-    if (batchCacheManager) {
-      const { nonDuplicates, duplicates } = await batchCacheManager.dedupeBatch(entityType, mmRecords);
-      toProcess = nonDuplicates;
-      result.localDedupeCount = duplicates.length;
-    } else {
-      toProcess = mmRecords;
-    }
-    return { toProcess, result };
-  }
-  /**
-   * Sends records to MM API
-   */
-  static async _sendToAPI(entityType, toProcess) {
-    const mmApiClient = new MMApiClient();
-    switch (entityType) {
-      case ERPObjType.PERSONS:
-        return await mmApiClient.sendPersonsToMM(toProcess);
-      case ERPObjType.RESOURCES:
-        return await mmApiClient.sendResourcesToMM(
-          toProcess
-        );
-      case ERPObjType.PARTS:
-        return await mmApiClient.sendPartsToMM(toProcess);
-      case ERPObjType.PART_OPERATION:
-        return await mmApiClient.sendPartOperationsToMM(
-          toProcess
-        );
-      case ERPObjType.WORK_ORDERS:
-        return await mmApiClient.sendWorkOrdersToMM(
-          toProcess
-        );
-      case ERPObjType.WORK_ORDER_OPERATIONS:
-        return await mmApiClient.sendWorkOrderOperationsToMM(
-          toProcess
-        );
-      case ERPObjType.LABOR_TICKETS:
-        return await mmApiClient.sendLaborTicketsToMM(
-          toProcess
-        );
-      case ERPObjType.REASONS:
-        return await mmApiClient.sendReasonsToMM(toProcess);
-      default:
-        throw new Error(`Unknown entity type: ${entityType}`);
-    }
-  }
-  /**
-   * Handles exceptions from API calls, converting structured 500 errors to MMBatchValidationError
-   * @throws MMBatchValidationError for structured 500 errors
-   * @throws The original exception for all other errors
-   */
-  static _handleException(exception, entityType, result) {
-    const structuredCompleteErrorSet = ErrorProcessor.extractErrorDetailsFrom500Exception(exception, entityType);
-    if (structuredCompleteErrorSet) {
-      const ex = exception;
-      const data = ex?.data;
-      const errorMessage = typeof data?.error === "string" ? data.error : "All entities failed to import";
-      throw new MMBatchValidationError({
-        message: errorMessage,
-        upsertedEntities: 0,
-        localDedupeCount: result.localDedupeCount,
-        apiDedupeCount: 0,
-        errorCount: structuredCompleteErrorSet.errorCount,
-        httpStatus: exception.status,
-        batchErrors: structuredCompleteErrorSet.batchErrors
-      });
-    }
-    throw exception;
-  }
-  /**
-   * Handles the MM API response based on HTTP status code, caching successful records
-   * and throwing exceptions for partial failures
-   *
-   * @returns The final result for success cases
-   * @throws MMBatchValidationError for partial success cases
-   * @throws Error for unknown status codes
-   */
-  static async _handleResponse(mmApiResponse, entityType, toProcess, result, batchCacheManager) {
-    if (mmApiResponse.httpStatus === 200) {
-      if (batchCacheManager) {
-        await batchCacheManager.storeBatch(entityType, toProcess);
-      }
-      if (entityType === ERPObjType.LABOR_TICKETS) {
-        const success = mmApiResponse;
-        result.message = success.message || "Entities processed successfully";
-        result.upsertedEntities = (success.updated || 0) + (success.inserted || 0);
-      } else {
-        const success = mmApiResponse;
-        result.message = success.message || "Entities processed successfully";
-        result.upsertedEntities = success.affectedRows || 0;
-      }
-      result.apiDedupeCount = toProcess.length - result.upsertedEntities;
-      return result;
-    } else if (mmApiResponse.httpStatus === 207) {
-      const partialResponse = mmApiResponse;
-      const { errorCount, batchErrors } = ErrorProcessor.extractErrorDetails(
-        partialResponse,
-        entityType
-      );
-      if (batchCacheManager) {
-        await ErrorProcessor.cacheSuccessfulRecordsOnPartialFailure(
-          entityType,
-          toProcess,
-          batchErrors,
-          batchCacheManager
-        );
-      }
-      let upsertedEntities = 0;
-      if (entityType === ERPObjType.LABOR_TICKETS) {
-        const partial = partialResponse;
-        upsertedEntities = (partial.data.updated || 0) + (partial.data.inserted || 0);
-      } else {
-        const partial = partialResponse;
-        upsertedEntities = partial.data.affectedRows || 0;
-      }
-      throw new MMBatchValidationError({
-        message: partialResponse.message || "Entities processed with partial failures",
-        upsertedEntities,
-        localDedupeCount: result.localDedupeCount,
-        apiDedupeCount: toProcess.length - upsertedEntities - errorCount,
-        errorCount,
-        httpStatus: mmApiResponse.httpStatus,
-        batchErrors
-      });
-    } else {
-      throw new Error(
-        `writeEntitiesToMM: Unknown HTTP status code: ${mmApiResponse.httpStatus}. An exception was expected.`
-      );
-    }
-  }
-}
-class MMBatchValidationError extends Error {
-  upsertedEntities;
-  localDedupeCount;
-  apiDedupeCount;
-  errorCount;
-  httpStatus;
-  batchErrors;
-  constructor(options) {
-    super(options.message);
-    this.name = "MMBatchValidationError";
-    this.upsertedEntities = options.upsertedEntities;
-    this.localDedupeCount = options.localDedupeCount;
-    this.apiDedupeCount = options.apiDedupeCount;
-    this.errorCount = options.errorCount;
-    this.httpStatus = options.httpStatus;
-    this.batchErrors = options.batchErrors;
-  }
-}
-class StandardProcessDrivers {
-  /**
-   * Synchronizes updated labor tickets from MachineMetrics to an ERP system:
-   *
-   * Initializes a checkpoint that tracks the last time labor tickets were synced,
-   * fetches labor tickets from MM and converts them to the company timezone,
-   * creates or updates the labor ticket in the ERP via connector-specific implementations,
-   * updates the labor ticket id in MM on newly created labor tickets,
-   * and saves the checkpoint
-   */
-  static async syncLaborTicketsToERP(connectorType, connector) {
-    return LaborTicketERPSynchronizer.syncToERP(connectorType, connector);
-  }
-  /**
-   * Retries labor tickets that have failed to be created or updated in the ERP during the sync:
-   *
-   * Fetches failed labor tickets from MM, processes them, and updates the labor ticket id in MM.
-   * If the labor ticket is successfully created or updated, it is added to the list of successful labor ticket ids,
-   * which are then deleted from the list of failed labor ticket ids.
-   */
-  static async retryFailedLaborTickets(connectorType, connector) {
-    return LaborTicketERPSynchronizer.retryFailed(connectorType, connector);
-  }
-  /**
-   * Writes a batch of records to MM for a specific entity type by:
-   * 1. Deduplicating against cached records (localDedupeCount)
-   * 2. Sending non-duplicate records to the MM API (apiDedupeCount)
-   * 3. Storing successful records in cache
-   *
-   * An example usage pattern including comprehensive error handling:
-   * ```
-   * try {
-   *   const result = await StandardProcessDrivers.writeEntitiesToMM(
-   *     'WorkOrders',
-   *     workOrderRecords,
-   *     batchCacheManager
-   *   );
-   *
-   *   // HTTP 200 - Complete success
-   *   console.log(`✅ Success: ${result.message}`);
-   *   console.log(`📊 Metrics: ${result.upsertedEntities} upserted, ${result.localDedupeCount} locally deduplicated, ${result.apiDedupeCount} API deduplicated`);
-   *
-   * } catch (error) {
-   *   if (error instanceof MMBatchValidationError) {
-   *     // HTTP 207 - Partial success with some batches failing due to validation errors
-   *     // HTTP 500 - A specific type representing complete failure due to validation issues;
-   *     //            other 500 types represent failure due to other issues and are not converted to MMBatchValidationError
-   *     // Note: Each batch error contains ALL entities from the failing batch, not necessarily just the failed ones
-   *
-   *     console.log(`⚠️  Batch processing completed with errors (HTTP ${error.httpStatus})`);
-   *     console.log(`📊 Metrics: ${error.upsertedEntities} upserted, ${error.localDedupeCount} locally deduplicated, ${error.apiDedupeCount} API deduplicated`);
-   *     console.log(`❌ Error count: ${error.errorCount}`);
-   *
-   *     // Process specific batch errors for retry or logging
-   *     error.batchErrors.forEach((batchError, index) => {
-   *       console.log(`Batch ${index + 1} error: ${batchError.message}`);
-   *       console.log(`All entities in failing batch:`, batchError.affectedEntities);
-   *
-   *       // Example: Queue entire failing batch for retry (contains both successful and failed entities)
-   *       await queueForRetry(batchError.affectedEntities);
-   *     });
-   *
-   *     // Decide whether to continue or halt based on httpStatus
-   *     if (error.httpStatus === 207) {
-   *       // Partial success - some batches processed successfully, others failed
-   *       console.log('⚠️  Continuing with partial success');
-   *     } else if (error.httpStatus === 500) {
-   *       // Complete failure - all batches failed due to validation issues
-   *       console.log('🛑 Complete failure - no records processed');
-   *       throw error; // Re-throw if complete failure should halt the process
-   *     }
-   *
-   *   } else {
-   *     // Other underlying errors (network issues, authentication, etc.)
-   *     console.error('🚨 Unexpected error during MM API call:', error);
-   *
-   *     // Example: Check for specific error types
-   *     if (error.message?.includes('authentication')) {
-   *       console.error('🔐 Authentication issue - check MM API credentials');
-   *     } else if (error.message?.includes('network') || error.code === 'ECONNREFUSED') {
-   *       console.error('🌐 Network connectivity issue - check MM API endpoint');
-   *     }
-   *
-   *     throw error; // Re-throw for upstream handling
-   *   }
-   * }
-   * ```
-   *
-   * @param entityType The type of entity being processed
-   * @param mmRecords The records to process
-   * @param batchCacheManager The batch cache manager instance; pass in null if caching is not desired
-   *
-   * @returns WriteEntitiesToMMResult on complete success (HTTP 200)
-   * @throws MMBatchValidationError on partial success (HTTP 207) or complete failure (HTTP 500) with structured error details
-   * @throws Error on other underlying issues (network, authentication, etc.)
-   */
-  static async writeEntitiesToMM(entityType, mmRecords, batchCacheManager) {
-    return MMEntityProcessor.writeEntities(
-      entityType,
-      mmRecords,
-      batchCacheManager
-    );
-  }
-  /**
-   * Writes a batch of Work Order related entities to MM maintaining referential integrity by:
-   * 1. Processing parts first (base entities)
-   * 2. Processing part operations (depends on parts)
-   * 3. Processing work orders (depends on parts)
-   * 4. Processing work order operations (depends on work orders and part operations)
-   *
-   * This ensures all foreign key constraints are satisfied and prevents referential integrity errors.
-   *
-   * @param workOrderBatch The batch containing all related entities
-   * @param batchCacheManager The batch cache manager instance; pass in null if caching is not desired
-   *
-   * @returns Combined results from all entity processing
-   * @throws MMBatchValidationError on partial success or complete failure with structured error details
-   * @throws Error on other underlying issues (network, authentication, etc.)
-   */
-  static async writeWorkOrderBatchToMM(workOrderBatch, batchCacheManager) {
-    const partsResult = await MMEntityProcessor.writeEntities(
-      ERPObjType.PARTS,
-      workOrderBatch.parts,
-      batchCacheManager
-    );
-    const partOperationsResult = await MMEntityProcessor.writeEntities(
-      ERPObjType.PART_OPERATION,
-      workOrderBatch.partOperations,
-      batchCacheManager
-    );
-    const workOrdersResult = await MMEntityProcessor.writeEntities(
-      ERPObjType.WORK_ORDERS,
-      workOrderBatch.workOrders,
-      batchCacheManager
-    );
-    const workOrderOperationsResult = await MMEntityProcessor.writeEntities(
-      ERPObjType.WORK_ORDER_OPERATIONS,
-      workOrderBatch.workOrderOperations,
-      batchCacheManager
-    );
-    return {
-      parts: partsResult,
-      partOperations: partOperationsResult,
-      workOrders: workOrdersResult,
-      workOrderOperations: workOrderOperationsResult
-    };
-  }
-  /**
-   * Processes flattened work order data and syncs it to MM maintaining referential integrity.
-   *
-   * This method expects flattened data where each row contains both work order and operation information
-   * with camelCase field names matching the GraphQL schema. It will automatically extract and deduplicate
-   * parts, part operations, work orders, and work order operations, then process them in the correct order
-   * to maintain referential integrity.
-   *
-   * @param flattenedData Array of flattened rows containing both work order and operation data (camelCase fields)
-   * @param batchCacheManager The batch cache manager instance; pass in null if caching is not desired
-   *
-   * @returns Combined results from all entity processing with detailed logging information
-   * @throws MMBatchValidationError on partial success or complete failure with structured error details
-   * @throws Error on other underlying issues (network, authentication, etc.)
-   */
-  static async syncWorkOrderBatchFromFlattened(flattenedData, batchCacheManager) {
-    if (!flattenedData || flattenedData.length === 0) {
-      throw new Error("No flattened work order data provided");
-    }
-    const uniqueParts = /* @__PURE__ */ new Map();
-    const uniquePartOperations = /* @__PURE__ */ new Map();
-    const uniqueWorkOrders = /* @__PURE__ */ new Map();
-    const workOrderOperations = [];
-    for (const row of flattenedData) {
-      const partKey = `${row.partNumber}|${row.partRevision}|${row.method}`;
-      if (!uniqueParts.has(partKey)) {
-        uniqueParts.set(partKey, {
-          partNumber: row.partNumber,
-          // → partNumber
-          partRevision: row.partRevision,
-          // → partRevision
-          method: row.method
-          // → method
-        });
-      }
-      const partOpKey = `${row.partNumber}|${row.partRevision}|${row.method}|${row.sequenceNumber}`;
-      if (!uniquePartOperations.has(partOpKey)) {
-        uniquePartOperations.set(partOpKey, {
-          partNumber: row.partNumber,
-          // → partNumber
-          partRevision: row.partRevision,
-          // → partRevision
-          method: row.method,
-          // → method
-          sequenceNumber: row.sequenceNumber,
-          // → sequenceNumber
-          resourceId: row.resourceId,
-          // → resourceId
-          cycleTimeMs: row.cycleTimeMs,
-          // → cycleTimeMs
-          setupTimeMs: row.setupTimeMs,
-          // → setupTimeMs
-          description: row.operationDescription || "",
-          // → description
-          quantityPerPart: row.quantityPerPart || 1
-          // → quantityPerPart
-        });
-      }
-      const workOrderKey = row.workOrderId;
-      if (!uniqueWorkOrders.has(workOrderKey)) {
-        uniqueWorkOrders.set(workOrderKey, {
-          workOrderId: row.workOrderId,
-          // → workOrderId
-          lot: row.lot,
-          // → lot
-          split: row.split,
-          // → split
-          sub: row.sub,
-          // → sub
-          status: row.status,
-          // → status
-          dueDate: row.dueDate,
-          // → dueDate
-          description: row.description,
-          // → description
-          scheduledStartDate: row.scheduledStartDate,
-          // → scheduledStartDate
-          scheduledEndDate: row.scheduledEndDate,
-          // → scheduledEndDate
-          closedDate: row.closedDate,
-          // → closedDate
-          quantityRequired: row.quantityRequired,
-          // → quantityRequired
-          partNumber: row.partNumber,
-          // → partNumber
-          partRevision: row.partRevision,
-          // → partRevision
-          method: row.method
-          // → method
-        });
-      }
-      workOrderOperations.push({
-        workOrderId: row.workOrderId,
-        // → workOrderId
-        lot: row.lot,
-        // → lot
-        split: row.split,
-        // → split
-        sub: row.sub,
-        // → sub
-        sequenceNumber: row.sequenceNumber,
-        // → sequenceNumber
-        resourceId: row.resourceId,
-        // → resourceId
-        startQuantity: row.startQuantity,
-        // → startQuantity
-        finishQuantity: row.finishQuantity,
-        // → finishQuantity
-        expectedRejectRate: row.expectedRejectRate,
-        // → expectedRejectRate
-        scheduledStartDate: row.opScheduledStartDate,
-        // → scheduledStartDate
-        scheduledFinishDate: row.opScheduledFinishDate,
-        // → scheduledFinishDate
-        closedDate: row.opClosedDate,
-        // → closedDate
-        cycleTimeMs: row.cycleTimeMs,
-        // → cycleTimeMs
-        setupTimeMs: row.setupTimeMs,
-        // → setupTimeMs
-        productionburdenRateHourly: row.productionburdenRateHourly,
-        // → productionburdenRateHourly
-        setupburdenRatehourly: row.setupburdenRatehourly,
-        // → setupburdenRatehourly
-        operationType: row.operationType,
-        // → operationType
-        quantityPerPart: row.quantityPerPart,
-        // → quantityPerPart
-        status: row.opStatus || row.status
-        // → status
-      });
-    }
-    const parts = Array.from(uniqueParts.values()).map(
-      (item) => new MMSendPart(
-        item.partNumber || "",
-        // partNumber
-        item.partRevision || "",
-        // partRevision
-        item.method || "Standard"
-        // method
-      )
-    );
-    const partOperations = Array.from(uniquePartOperations.values()).map(
-      (item) => new MMSendPartOperation(
-        item.partNumber || "",
-        // partNumber
-        item.partRevision || "",
-        // partRevision
-        item.method || "Standard",
-        // method
-        item.sequenceNumber?.toString() || "",
-        // sequenceNumber
-        item.resourceId?.toString() || "",
-        // resourceId
-        item.cycleTimeMs || 0,
-        // cycleTimeMs
-        item.setupTimeMs || 0,
-        // setupTimeMs
-        item.description || "",
-        // description
-        item.quantityPerPart || 1
-        // quantityPerPart
-      )
-    );
-    const transformedWorkOrders = Array.from(uniqueWorkOrders.values()).map(
-      (item) => new MMSendWorkOrder(
-        item.workOrderId?.toString() || "",
-        // workOrderId
-        item.lot || "",
-        // lot
-        item.split || "",
-        // split
-        item.sub || "",
-        // sub
-        item.status || "Open",
-        // status
-        item.dueDate ? new Date(item.dueDate).toISOString() : null,
-        // dueDate
-        item.description || "",
-        // description
-        item.scheduledStartDate ? new Date(item.scheduledStartDate).toISOString() : null,
-        // scheduledStartDate
-        item.scheduledEndDate ? new Date(item.scheduledEndDate).toISOString() : null,
-        // scheduledEndDate
-        item.closedDate ? new Date(item.closedDate).toISOString() : null,
-        // closedDate
-        item.quantityRequired || 0,
-        // quantityRequired
-        item.partNumber || "",
-        // partNumber
-        item.partRevision || "",
-        // partRevision
-        item.method || "Standard"
-        // method
-      )
-    );
-    const transformedWorkOrderOperations = workOrderOperations.map(
-      (item) => new MMSendWorkOrderOperation(
-        item.workOrderId?.toString() || "",
-        // workOrderId
-        item.lot || "",
-        // lot
-        item.split || "",
-        // split
-        item.sub || "",
-        // sub
-        item.sequenceNumber?.toString() || "",
-        // sequenceNumber
-        item.resourceId?.toString() || "",
-        // resourceId
-        item.startQuantity || 0,
-        // startQuantity
-        item.finishQuantity || 0,
-        // finishQuantity
-        item.expectedRejectRate || 0,
-        // expectedRejectRate
-        item.scheduledStartDate ? new Date(item.scheduledStartDate).toISOString() : null,
-        // scheduledStartDate
-        item.scheduledFinishDate ? new Date(item.scheduledFinishDate).toISOString() : null,
-        // scheduledFinishDate
-        item.closedDate ? new Date(item.closedDate).toISOString() : null,
-        // closedDate
-        item.cycleTimeMs || 0,
-        // cycleTimeMs
-        item.setupTimeMs || 0,
-        // setupTimeMs
-        parseFloat(item.productionburdenRateHourly || "0"),
-        // productionburdenRateHourly
-        parseFloat(item.setupburdenRatehourly || "0"),
-        // setupburdenRatehourly
-        item.operationType || "Production",
-        // operationType
-        item.quantityPerPart || 1,
-        // quantityPerPart
-        item.status || "Open"
-        // status
-      )
-    );
-    const partsResult = await MMEntityProcessor.writeEntities(
-      ERPObjType.PARTS,
-      parts,
-      batchCacheManager
-    );
-    const partOperationsResult = await MMEntityProcessor.writeEntities(
-      ERPObjType.PART_OPERATION,
-      partOperations,
-      batchCacheManager
-    );
-    const workOrdersResult = await MMEntityProcessor.writeEntities(
-      ERPObjType.WORK_ORDERS,
-      transformedWorkOrders,
-      batchCacheManager
-    );
-    const workOrderOperationsResult = await MMEntityProcessor.writeEntities(
-      ERPObjType.WORK_ORDER_OPERATIONS,
-      transformedWorkOrderOperations,
-      batchCacheManager
-    );
-    return {
-      parts: partsResult,
-      partOperations: partOperationsResult,
-      workOrders: workOrdersResult,
-      workOrderOperations: workOrderOperationsResult
-    };
-  }
-}
-const DEFAULT_RETRY_ATTEMPTS$1 = 0;
-const DEFAULT_PAGINATION_LIMIT = 100;
-class RestAPIService {
-  client;
-  config;
-  paginationLimit;
-  constructor(config2, retryAttempts, paginationLimit) {
-    this.config = config2;
-    this.paginationLimit = paginationLimit ?? DEFAULT_PAGINATION_LIMIT;
-    this.client = HTTPClientFactory.getInstance({
-      baseUrl: config2.apiUrl,
-      retryAttempts: retryAttempts ?? DEFAULT_RETRY_ATTEMPTS$1
-    });
-  }
-  //#region Get Request Helpers
-  async getHeaders() {
-    const token = await this.config.getAuthToken();
-    return {
-      "Content-Type": "application/json",
-      Accept: "application/json",
-      ...token ? { Authorization: `Bearer ${token}` } : {}
-    };
-  }
-  buildQueryParams(query = {}) {
-    const { limit, nextPage, filter } = query;
-    const queryParams = {};
-    if (limit) {
-      queryParams.take = limit.toString();
-    }
-    if (nextPage) {
-      queryParams.skip = nextPage;
-    }
-    if (filter) {
-      if (filter.in) {
-        filter.in.forEach((filterIn) => {
-          const query2 = filterIn.value.join("|");
-          queryParams[`${filterIn.field}[in]`] = query2;
-        });
-      }
-      if (filter.and) {
-        queryParams["filter[and]"] = buildLogicalCondition(filter.and, "and");
-      }
-      if (filter.or) {
-        queryParams["filter[or]"] = buildLogicalCondition(filter.or, "or");
-      }
-    }
-    return new URLSearchParams(queryParams);
-  }
-  /**
-   * Builds pagination metadata for API responses
-   * @param limit - Optional limit for this specific request. If not provided, uses the service's default pagination limit
-   * @param nextPage - Optional next page token
-   * @param previousPage - Optional previous page token
-   * @param dataLength - Number of items in the current response
-   * @param totalCount - Total number of items available
-   * @returns Pagination metadata including count, limit, and page tokens
-   */
-  buildPagination(limit, nextPage, previousPage, dataLength = 0, totalCount) {
-    const paging = {
-      count: totalCount || 0,
-      limit: limit || this.paginationLimit,
-      nextPage: void 0,
-      previousPage
-    };
-    if (limit) {
-      paging.limit = limit;
-      const currentSkip = parseInt(nextPage || "0");
-      if (dataLength > 0 && (!totalCount || currentSkip + limit < totalCount)) {
-        paging.nextPage = `${currentSkip + limit}`;
-      }
-    }
-    return paging;
-  }
-  buildUrl(endpoint, queryParams) {
-    const pathParts = [this.config.apiUrl || ""];
-    pathParts.push(endpoint);
-    const path2 = pathParts.filter(Boolean).join("/");
-    return queryParams ? `${path2}?${queryParams.toString()}` : path2;
-  }
-  //#endregion get request helpers
-  async get(endpoint, query = {}) {
-    try {
-      const params = this.buildQueryParams(query);
-      const url = this.buildUrl(endpoint, params);
-      const headers = await this.getHeaders();
-      const response = await this.client.request({
-        method: "GET",
-        url,
-        headers
-      });
-      const paging = this.buildPagination(
-        query.limit,
-        query.nextPage,
-        query.previousPage,
-        response.data.Data?.length,
-        response.data.TotalCount
-      );
-      return {
-        data: response.data.Data || [],
-        metadata: {
-          pagination: paging
-        }
-      };
-    } catch (error) {
-      ErrorHandler.handle(error);
-    }
-  }
-  async patch(endpoint, id, data) {
-    try {
-      const url = this.buildUrl(`${endpoint}/${id}`);
-      const headers = await this.getHeaders();
-      const response = await this.client.request({
-        method: "PATCH",
-        url,
-        data,
-        headers
-      });
-      return {
-        data: response.data
-      };
-    } catch (error) {
-      ErrorHandler.handle(error);
-    }
-  }
-  async post(endpoint, data) {
-    try {
-      const url = this.buildUrl(endpoint);
-      const headers = await this.getHeaders();
-      const response = await this.client.request({
-        method: "POST",
-        url,
-        data,
-        headers
-      });
-      return {
-        data: response.data
-      };
-    } catch (error) {
-      ErrorHandler.handle(error);
-    }
-  }
-  /**
-   * Cleanup all HTTP connections and resources
-   * Call this when the service is no longer needed
-   */
-  async destroy() {
-    await this.client.destroy();
-  }
-}
-function getERPAPITypeFromEntity(entity, entityMap) {
-  const entry = Object.entries(entityMap).find(
-    ([_, value]) => value.entity === entity
-  );
-  return entry ? Number(entry[0]) : void 0;
-}
-const isNonEmptyString = (v) => typeof v === "string" && v.trim().length > 0;
-function getErrorType(error) {
-  if (error && typeof error === "object") {
-    const o = error;
-    if (isNonEmptyString(o.code)) return o.code;
-    if (isNonEmptyString(o.name)) return o.name;
-    const ctorName = o.constructor?.name;
-    if (isNonEmptyString(ctorName) && ctorName !== "Object") return ctorName;
-  }
-  return "Error";
-}
-class LogEntry {
-  level;
-  message;
-  dedupeKey;
-  eventTime;
-  constructor(params) {
-    this.level = params.level;
-    this.message = params.message;
-    this.dedupeKey = params.dedupeKey;
-    this.eventTime = Date.now();
-  }
-}
-function isLogResponse(value) {
-  if (value === null || typeof value !== "object") return false;
-  const v = value;
-  if (typeof v.message !== "string") return false;
-  if ("processed" in v && typeof v.processed !== "number") return false;
-  return true;
-}
-class MMConnectorLogger {
-  MAX_MSG_LEN = 2e3;
-  mmApiClient;
-  deduper;
-  source;
-  constructor(source, deduper) {
-    if (source.length < 1 || source.length > 64) {
-      throw new Error("source must be 1-64 characters");
-    }
-    this.mmApiClient = new MMApiClient();
-    this.deduper = deduper;
-    this.source = source;
-  }
-  // Deduplication helpers are delegated to injected FileLogDeduper
-  /**
-   * Send a single log entry to the MM cloud with deduplication.
-   * 
-   * The deduplication is handled by the injected LogDeduper.
-   * If no deduper is injected, the log entry is sent without deduplication.
-   * 
-   * The standard deduper, FileLogDeduper, stores the deduplication state in a file, 
-   * allowing deduplication across jobs, 
-   * 
-   * @param logEntry - The log entry to send
-   * @returns Promise resolving to the API response or null if suppressed
-   * @throws HTTPError if the request fails or Error if the log entry is invalid
-   */
-  async sendLog(logEntry) {
-    this.validateLogEntry(logEntry);
-    const now = Date.now();
-    let messageToSend = logEntry.message;
-    if (this.deduper) {
-      const decision = await this.deduper.decide(logEntry, now);
-      if (decision === null) return null;
-      messageToSend = decision;
-    }
-    try {
-      const logEntryToSend = {
-        source: this.source,
-        level: logEntry.level,
-        message: messageToSend
-      };
-      const response = await this.mmApiClient.sendConnectorLog(logEntryToSend);
-      if (this.deduper) {
-        await this.deduper.onSuccess(logEntry, now);
-      }
-      if (!isLogResponse(response)) {
-        logger.warn("Unexpected success response format from MM API for connector log", { response });
-        return { message: "Unexpected success response format when sending log" };
-      }
-      return { message: response.message };
-    } catch (error) {
-      logger.error("Failed to send log to MM cloud", {
-        level: logEntry.level,
-        error: error instanceof Error ? error.message : "Unknown error"
-      });
-      throw error;
-    }
-  }
-  /**
-   * @throws Error if validation fails
-   */
-  validateLogEntry(logEntry) {
-    const allowedLevels = ["info", "warn", "error"];
-    if (!logEntry.level || !allowedLevels.includes(logEntry.level)) {
-      throw new Error(`level must be one of: ${allowedLevels.join(", ")}`);
-    }
-    if (!logEntry.message || typeof logEntry.message !== "string") {
-      throw new Error("message is required and must be a string");
-    }
-    logEntry.message = logEntry.message.slice(0, this.MAX_MSG_LEN);
-    if (!logEntry.dedupeKey || typeof logEntry.dedupeKey !== "string") {
-      throw new Error("dedupeKey is required and must be a string");
-    }
-    if (logEntry.dedupeKey.trim().length < 1) {
-      throw new Error("dedupeKey must be a non-empty string");
-    }
-  }
-  /**
-   * Retry all failed transmissions silently
-   * This method attempts to retry all messages that failed to transmit
-   * and removes them from the failed list if successful, else leaves them for the client to retry
-   * 
-   * Expected usage is by a client to call this as part of its own retry mechanism
-   */
-  async retryFailedTransmissions() {
-    if (!this.deduper || !this.deduper.retryFailedTransmissions) {
-      return;
-    }
-    await this.deduper.retryFailedTransmissions(async (entry, message) => {
-      await this.mmApiClient.sendConnectorLog({
-        source: this.source,
-        level: entry.level,
-        message
-      });
-    });
-  }
-  /**
-   * Clean up resources
-   */
-  async destroy() {
-    await this.mmApiClient.destroy();
-  }
-}
-class FileLogDeduper {
-  storeFilePath;
-  windowMs;
-  ttlMs;
-  sweepIntervalMs;
-  lastSweepTsMs;
-  DEFAULT_WINDOW_TEN_MINS = 600;
-  DEFAULT_TTL_ONE_HOUR = 3600;
-  DEFAULT_SWEEP_INTERVAL_FIVE_MINS = 300;
-  DEFAULT_STORE_FILE_PATH = path.join("/tmp", "log-deduplication.json");
-  /**
-   * Ctor.
-   * @param storeFilePath:         The path to the file where the deduplication store is stored; recommended is to use the default
-   * @param windowSeconds:         Suppression window. Duplicates within this period are suppressed.
-   * @param ttlSeconds:            Eviction TTL. Store entries for keys inactive beyond this are removed. Enforced to be ≥ windowSeconds.
-   * @param sweepIntervalSeconds:  Efficiency parameter. How often (min interval) to run opportunistic eviction; retry always sweeps
-   *                               The sweep is lazy, used only when the store is accessed
-   */
-  constructor({
-    storeFilePath = this.DEFAULT_STORE_FILE_PATH,
-    windowSeconds = this.DEFAULT_WINDOW_TEN_MINS,
-    ttlSeconds = this.DEFAULT_TTL_ONE_HOUR,
-    sweepIntervalSeconds = this.DEFAULT_SWEEP_INTERVAL_FIVE_MINS
-  } = {}) {
-    this.storeFilePath = storeFilePath;
-    this.windowMs = Math.max(1, windowSeconds) * 1e3;
-    this.ttlMs = Math.max(this.windowMs, Math.max(1, ttlSeconds) * 1e3);
-    this.sweepIntervalMs = Math.max(1, sweepIntervalSeconds) * 1e3;
-    this.lastSweepTsMs = 0;
-    this.ensureStoreFileExists();
-  }
-  /** 
-   * Deduplication gating function
-   * Returns the formatted message to send, or null to suppress
-   * Decision is based on the dedupeKey and the time of the entry
-  */
-  async decide(entry, now) {
-    if (!entry.dedupeKey || typeof entry.dedupeKey !== "string" || entry.dedupeKey.trim().length === 0) {
-      throw new Error("dedupeKey is required and must be a non-empty string");
-    }
-    const key = entry.dedupeKey;
-    return this.withLock(async () => {
-      const store = this.readStore();
-      if (now - this.lastSweepTsMs >= this.sweepIntervalMs) {
-        this.evictExpiredInStore(store, now);
-        this.lastSweepTsMs = now;
-        this.writeStore(store);
-      }
-      const existing = store[key];
-      if (existing) {
-        const withinWindow = existing.lastTransmitted > 0 && existing.lastTransmitted + this.windowMs > now;
-        if (withinWindow) {
-          store[key] = {
-            ...existing,
-            suppressedCount: existing.suppressedCount + 1,
-            firstUnsentEventTs: existing.suppressedCount === 0 ? entry.eventTime ?? now : existing.firstUnsentEventTs,
-            lastEventTs: entry.eventTime ?? now,
-            level: entry.level,
-            message: entry.message
-          };
-          this.writeStore(store);
-          return null;
-        }
-        const messageToSend2 = this.formatMessage(entry.message, entry.eventTime ?? now, existing.suppressedCount, existing.firstUnsentEventTs);
-        store[key] = {
-          ...existing,
-          suppressedCount: 0,
-          firstUnsentEventTs: 0,
-          lastEventTs: entry.eventTime ?? now,
-          level: entry.level,
-          message: entry.message
-        };
-        this.writeStore(store);
-        return messageToSend2;
-      }
-      const messageToSend = this.formatMessage(entry.message, entry.eventTime ?? now, 0);
-      store[key] = {
-        lastTransmitted: 0,
-        suppressedCount: 0,
-        firstUnsentEventTs: entry.eventTime ?? now,
-        lastEventTs: entry.eventTime ?? now,
-        level: entry.level,
-        message: entry.message
-      };
-      this.writeStore(store);
-      return messageToSend;
-    });
-  }
-  async onSuccess(entry, now) {
-    if (!entry.dedupeKey || typeof entry.dedupeKey !== "string" || entry.dedupeKey.trim().length === 0) {
-      throw new Error("dedupeKey is required and must be a non-empty string");
-    }
-    const key = entry.dedupeKey;
-    await this.withLock(async () => {
-      const store = this.readStore();
-      const existing = store[key];
-      if (existing) {
-        store[key] = {
-          ...existing,
-          lastTransmitted: now,
-          firstUnsentEventTs: 0,
-          suppressedCount: 0
-        };
-        this.writeStore(store);
-      }
-    });
-  }
-  async retryFailedTransmissions(send) {
-    const now = Date.now();
-    const entries = await this.withLock(async () => {
-      const store = this.readStore();
-      this.evictExpiredInStore(store, now);
-      this.lastSweepTsMs = now;
-      this.writeStore(store);
-      return Object.entries(store).filter(([, rec]) => rec.lastTransmitted === 0).map(([key, rec]) => ({ key, rec }));
-    });
-    for (const { key, rec } of entries) {
-      try {
-        const message = this.formatMessage(rec.message, rec.lastEventTs, rec.suppressedCount, rec.firstUnsentEventTs);
-        await send({ level: rec.level, message: rec.message, dedupeKey: key, eventTime: rec.lastEventTs }, message);
-        await this.withLock(async () => {
-          const store = this.readStore();
-          const current = store[key];
-          if (current) {
-            store[key] = {
-              ...current,
-              lastTransmitted: Date.now(),
-              suppressedCount: 0
-            };
-            this.writeStore(store);
-          }
-        });
-      } catch (err) {
-        logger.error("Failed to retry failed transmission", { key, rec, error: err });
-        return;
-      }
-    }
-  }
-  // --- Internals ---
-  ensureStoreFileExists() {
-    try {
-      if (!fs.existsSync(this.storeFilePath)) {
-        fs.writeFileSync(this.storeFilePath, JSON.stringify({}), "utf-8");
-      }
-    } catch {
-    }
-  }
-  readStore() {
-    try {
-      if (!fs.existsSync(this.storeFilePath)) return {};
-      const content = fs.readFileSync(this.storeFilePath, "utf-8");
-      return content ? JSON.parse(content) : {};
-    } catch {
-      return {};
-    }
-  }
-  writeStore(store) {
-    try {
-      fs.writeFileSync(this.storeFilePath, JSON.stringify(store, null, 2), "utf-8");
-    } catch {
-    }
-  }
-  formatMessage(message, eventTs, suppressedCount, firstUnsentEventTs) {
-    const timestamp = new Date(eventTs).toISOString();
-    const base = `${timestamp} | ${message}`;
-    if (suppressedCount > 0) {
-      const since = firstUnsentEventTs && firstUnsentEventTs > 0 ? ` since ${new Date(firstUnsentEventTs).toISOString()}` : "";
-      return `${base} (${suppressedCount} suppressed${since})`;
-    }
-    return base;
-  }
-  async withLock(fn) {
-    const lockPath = `${this.storeFilePath}.lock`;
-    const start = Date.now();
-    while (true) {
-      try {
-        const fd = fs.openSync(lockPath, "wx");
-        try {
-          const result = await fn();
-          return result;
-        } finally {
-          try {
-            fs.closeSync(fd);
-          } catch {
-          }
-          try {
-            fs.unlinkSync(lockPath);
-          } catch {
-          }
-        }
-      } catch {
-        if (Date.now() - start > 3e3) {
-          return await fn();
-        }
-        await new Promise((resolve) => setTimeout(resolve, 50));
-      }
-    }
-  }
-  /**
-   * Evict expired entries from the store based on the TTL and the key's last transmitted time
-   */
-  evictExpiredInStore(store, now) {
-    const keys = Object.keys(store);
-    if (keys.length === 0) return;
-    for (const key of keys) {
-      const rec = store[key];
-      const referenceTs = rec.lastTransmitted > 0 ? rec.lastTransmitted : rec.lastEventTs;
-      if (now - referenceTs > this.ttlMs) {
-        delete store[key];
-      }
-    }
-  }
-}
-class ApplicationInitializer {
-  /**
-   * Performs all necessary application initialization tasks
-   * This should be called before starting any services or jobs
-   */
-  static async initialize() {
-    try {
-      logger.info(
-        "\n================================INITIALIZING APPLICATION================================\n"
-      );
-      const coreConfig = CoreConfiguration.inst();
-      logger.info("Core Configuration loaded:", coreConfig.toSafeLogObject());
-      logger.info("Performing database startup checks...");
-      await SQLiteCoordinator.performStartupCheck();
-      logger.info("Database startup checks completed successfully");
-      logger.info("Running database migrations...");
-      await ApplicationInitializer.runMigrations();
-      logger.info("Database migrations completed successfully");
-      await getTimezoneOffsetAndPersist();
-      logger.info(
-        "\n================================APPLICATION INITIALIZATION COMPLETED================================\n"
-      );
-    } catch (error) {
-      logger.error("Critical initialization failure. Exiting.", error);
-      process.exitCode = 1;
-    }
-  }
-  /**
-   * Runs database migrations to ensure all required tables exist
-   */
-  static async runMigrations() {
-    const db = knex(config.local);
-    try {
-      await db.migrate.latest();
-    } catch (error) {
-      logger.error("Error running migrations:", error);
-      throw error;
-    } finally {
-      await db.destroy();
-    }
-  }
-}
-const DEFAULT_RETRY_ATTEMPTS = 0;
-class GraphQLService {
-  client;
-  config;
-  endpoint;
-  constructor(config2, endpoint, retryAttempts) {
-    this.config = config2;
-    this.endpoint = endpoint ? endpoint.startsWith("/") ? endpoint : `/${endpoint}` : "";
-    this.client = HTTPClientFactory.getInstance({
-      baseUrl: config2.apiUrl,
-      retryAttempts: retryAttempts ?? DEFAULT_RETRY_ATTEMPTS
-    });
-  }
-  async getHeaders() {
-    const token = await this.config.getAuthToken();
-    return {
-      "Content-Type": "application/json",
-      Accept: "application/json",
-      ...token ? { Authorization: `Bearer ${token}` } : {}
-    };
-  }
-  /**
-     * Handles a GraphQL response, properly handling both successful responses
-     * and GraphQL-level errors (which come in a 200 HTTP response)
-     * 
-     * From the GraphQL specification (https://spec.graphql.org/draft/#sec-Errors):
-  >  *     "When a GraphQL server encounters an error, it should return a response with a 
-  >  *      top-level "errors" field containing the error information. The response may still contain
-     *      a partial result in the "data" field if the error occurred after some data was already resolved."
-     * 
-     * And specifically about HTTP status codes:
-     *     "A server should return a 200 status code when a GraphQL operation successfully executes, including when  
-     *      the operation returns errors. A server should return a 400 status code when a GraphQL operation fails to execute."
-     */
-  handleGraphQLResponse(response) {
-    return {
-      data: response.data.data,
-      metadata: {
-        errors: response.data.errors,
-        extensions: response.data.extensions
-      }
-    };
-  }
-  /**
-   * Executes a GraphQL query
-   * @param query The GraphQL query string
-   * @param variables Optional variables for the query
-   * @returns The query result
-   * @throws {HTTPError} For HTTP/network errors only
-   */
-  async query(query, variables) {
-    try {
-      const headers = await this.getHeaders();
-      const response = await this.client.request({
-        method: "POST",
-        url: this.endpoint,
-        data: { query, variables },
-        headers
-      });
-      return this.handleGraphQLResponse(response);
-    } catch (error) {
-      ErrorHandler.handle(error);
-    }
-  }
-  /**
-   * Executes a GraphQL mutation
-   * @param mutation The GraphQL mutation string
-   * @param variables Optional variables for the mutation
-   * @returns The mutation result
-   * @throws {HTTPError} For HTTP/network errors only
-   */
-  async mutate(mutation, variables) {
-    try {
-      const headers = await this.getHeaders();
-      const response = await this.client.request({
-        method: "POST",
-        url: this.endpoint,
-        data: { query: mutation, variables },
-        headers
-      });
-      return this.handleGraphQLResponse(response);
-    } catch (error) {
-      ErrorHandler.handle(error);
-    }
-  }
-  /**
-   * Cleanup all HTTP connections and resources
-   * Call this when the service is no longer needed
-   */
-  async destroy() {
-    await this.client.destroy();
-  }
-}
-class OAuthClient {
-  constructor(config2) {
-    this.config = config2;
-  }
-  /**
-   * Requests an OAuth token using the client credentials flow.
-   * The request is sent as application/x-www-form-urlencoded.
-   * @returns A promise that resolves to the token response containing access_token and expires_in
-   * @throws Error if the token request fails
-   */
-  async getToken() {
-    const formData = new URLSearchParams({
-      grant_type: "client_credentials",
-      client_id: this.config.clientId,
-      client_secret: this.config.clientSecret,
-      scope: this.config.scope
-    });
-    const response = await fetch(this.config.authUrl, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded"
-      },
-      body: formData
-    });
-    if (!response.ok) {
-      throw new Error(`OAuth token request failed: ${response.statusText}`);
-    }
-    const data = await response.json();
-    if (data.token_type !== "Bearer") {
-      throw new Error(`Unexpected token type: ${data.token_type}`);
-    }
-    return data;
-  }
-}
-const runDataSyncService = async (connectorPath) => {
-  const config2 = CoreConfiguration.inst();
-  try {
-    const currentFileUrl = import.meta.url;
-    const currentFilePath = fileURLToPath(currentFileUrl);
-    const sdkDistPath = path.dirname(currentFilePath);
-    const jobsPath = path.join(
-      sdkDistPath,
-      "services",
-      "data-sync-service",
-      "jobs"
-    );
-    const bree = new Bree({
-      root: jobsPath,
-      logger,
-      worker: {
-        env: {
-          CONNECTOR_PATH: connectorPath,
-          // Pass through all required environment variables
-          MM_MAPPING_SERVICE_URL: process.env.MM_MAPPING_SERVICE_URL,
-          MM_MAPPING_AUTH_SERVICE_URL: process.env.MM_MAPPING_AUTH_SERVICE_URL,
-          MM_MAPPING_SERVICE_TOKEN: process.env.MM_MAPPING_SERVICE_TOKEN,
-          ERP_SYSTEM: process.env.ERP_SYSTEM,
-          LOG_LEVEL: process.env.LOG_LEVEL,
-          NODE_ENV: process.env.NODE_ENV,
-          RETRY_ATTEMPTS: process.env.RETRY_ATTEMPTS,
-          CACHE_TTL: process.env.CACHE_TTL,
-          // Pass through all other environment variables that might be needed
-          ...process.env
-        }
-      },
-      jobs: [
-        // {
-        //   name: 'run-migrations',        // Running this once on startup will create the tables in the sqlite database
-        // },
-        {
-          name: "from-erp",
-          timeout: "10s",
-          interval: config2.fromErpInterval
-        },
-        {
-          name: "to-erp",
-          //timeout: '3s',                  // Use timeout during development to see the job in action quickly
-          interval: config2.toErpInterval
-        },
-        {
-          name: "retry-failed-labor-tickets",
-          interval: config2.retryLaborTicketsInterval
-        },
-        {
-          name: "clean-up-expired-cache",
-          interval: config2.cacheExpirationCheckInterval
-        }
-      ]
-    });
-    logger.info(
-      "\n================================INITIATING DATA SYNC CYCLES (Bree)================================\n"
-    );
-    const jobsConfig = bree.config.jobs.map((job) => ({
-      name: job.name,
-      interval: job.interval,
-      timeout: job.timeout
-    }));
-    logger.info("JOBS CONFIGURATION:", { jobs: jobsConfig });
-    const graceful = new Graceful({ brees: [bree] });
-    graceful.listen();
-    (async () => {
-      await bree.start();
-    })();
-    bree.on("jobStarted", (job) => {
-      console.log("Job " + job.name + " started");
-    });
-    bree.on("jobCompleted", (job) => {
-      if (job.error) {
-        console.error("Job " + job.name + " failed:", job.error);
-      } else {
-        console.log("Job " + job.name + " completed successfully!");
-      }
-    });
-    bree.on("error", (error) => {
-      console.error("Bree error:", error);
-    });
-    logger.info(
-      "\n================================DATA SYNC CYCLES INITIATION COMPLETED================================\n"
-    );
-  } catch (error) {
-    logger.error("startUp: Error initiating data sync cycles:", error);
-  }
-};
-const SQLServerConfigSchema = z.object({
-  user: z.string().nonempty("User is required."),
-  password: z.string().nonempty("Password is required."),
-  database: z.string().nonempty("Database name is required."),
-  server: z.string().nonempty("Server is required."),
-  port: z.coerce.number().int().positive("Port must be a positive integer.").default(1433),
-  connectionTimeout: z.coerce.number().int().positive("Connection timeout must be a positive integer.").default(3e4),
-  requestTimeout: z.coerce.number().int().positive("Request timeout must be a positive integer.").default(6e4),
-  pool: z.object({
-    max: z.coerce.number().int().positive("Max pool size must be a positive integer.").default(10),
-    min: z.coerce.number().int().nonnegative("Min pool size must be a non-negative integer.").default(0),
-    idleTimeoutMillis: z.coerce.number().int().nonnegative("Idle timeout must be a non-negative integer.").default(3e4)
-  }),
-  options: z.object({
-    encrypt: z.coerce.boolean().default(false),
-    trustServerCertificate: z.coerce.boolean().default(false)
-  })
-});
-class SqlServerService {
-  connection = null;
-  config;
-  constructor(config2) {
-    this.config = config2;
-  }
-  async dispose() {
-    await this.closeConnection();
-  }
-  /**
-   * Execute a prepared statement and return the results
-   *
-   * @param statementToPrepare The SQL query to prepare
-   * @param params The parameters to bind to the prepared statement
-   * @param paging Optional paging parameters
-   * @returns The entities fetched from the database, along with paging information
-   */
-  async executePreparedStatement(statementToPrepare, params, paging) {
-    const connection = await this.openConnection();
-    const preparedStatement = new sql.PreparedStatement(connection);
-    Object.keys(params).forEach((key) => {
-      preparedStatement.input(key, sql.VarChar);
-    });
-    const finalQuery = paging?.limit !== void 0 ? `${statementToPrepare} OFFSET ${paging.offset || 0} ROWS FETCH NEXT ${paging.limit} ROWS ONLY` : statementToPrepare;
-    await preparedStatement.prepare(finalQuery);
-    let records;
-    try {
-      records = await preparedStatement.execute(params);
-    } catch (error) {
-      const errorInfo = error;
-      const errorMessage = "Error fetching data from ERP -> " + (errorInfo.cause ? `Cause: ${errorInfo.cause}. ` : "") + `Name: ${errorInfo.name}. Message: ${errorInfo.message}. Stack: ${errorInfo.stack}`;
-      throw new Error(errorMessage);
-    } finally {
-      try {
-        await preparedStatement.unprepare();
-      } catch (unprepareError) {
-        logger.error("Error during unprepare:", unprepareError);
-      }
-    }
-    const allRecords = SqlServerService.recordsetToRecords(records?.recordset);
-    const rowsFetched = records?.rowsAffected[0] || 0;
-    const pagedData = paging?.offset !== void 0 ? allRecords.slice(
-      paging.offset,
-      (paging.offset || 0) + (paging.limit || allRecords.length)
-    ) : allRecords;
-    return {
-      data: pagedData,
-      paging: {
-        count: rowsFetched,
-        limit: paging?.limit || 0,
-        offset: paging?.offset || 0,
-        nextPage: (() => {
-          const currentPageEnd = (paging?.offset || 0) + (paging?.limit || 0);
-          return paging?.limit && currentPageEnd < rowsFetched ? String(currentPageEnd) : void 0;
-        })(),
-        previousPage: paging?.offset ? String(Math.max(0, (paging.offset || 0) - (paging.limit || 10))) : void 0
-      }
-    };
-  }
-  /**
-   * Opens a connection to SQL Server
-   * Caches the connection so that it can be reused.
-   * On failure to connect, throws
-   */
-  async openConnection() {
-    if (this.connection?.connected) {
-      logger.debug("Reusing existing SQL Server connection");
-      return this.connection;
-    }
-    if (this.connection) {
-      logger.debug("Clearing disconnected SQL Server connection");
-      this.connection = null;
-    }
-    try {
-      logger.info("Opening new SQL Server connection");
-      const sqlConfig = SQLServerConfigSchema.parse({
-        user: this.config.username,
-        password: this.config.password,
-        database: this.config.database,
-        server: this.config.host,
-        port: parseInt(this.config.port),
-        connectionTimeout: parseInt(this.config.connectionTimeout),
-        requestTimeout: parseInt(this.config.requestTimeout),
-        pool: {
-          max: parseInt(this.config.poolMax),
-          min: parseInt(this.config.poolMin),
-          idleTimeoutMillis: parseInt(this.config.idleTimeoutMillis)
-        },
-        options: {
-          encrypt: this.config.encrypt,
-          trustServerCertificate: this.config.trustServer
-        }
-      });
-      this.connection = await sql.connect(sqlConfig);
-      return this.connection;
-    } catch (error) {
-      logger.error("SqlServerService>>openConnection>> Connection failed", {
-        error
-      });
-      throw new Error("SQL Server connection failed");
-    }
-  }
-  /**
-   * Transform a IRecordSet from a SQL query into an array of Record<string, string> instances.
-   * @param recordset IRecordSet from a SQL query
-   * @returns array of Record<string, string> instances
-   */
-  static recordsetToRecords(recordset) {
-    const data = recordset?.map((row) => {
-      const transformedRow = {};
-      Object.keys(row).forEach((key) => {
-        transformedRow[key] = row[key]?.toString() || "";
-      });
-      return transformedRow;
-    }) || [];
-    return data;
-  }
-  async closeConnection() {
-    if (this.connection?.connected) {
-      logger.info("Closing SQL Server connection");
-      try {
-        await this.connection.close();
-      } catch (error) {
-        logger.error(
-          "SqlServerService::closeConnection: Error closing connection",
-          {
-            error
-          }
-        );
-      }
-      this.connection = null;
-    }
-  }
-}
-class SQLTransactionManager {
-  constructor(connection) {
-    this.connection = connection;
-  }
-  /**
-   * Executes a transaction with the given operation and data, manages rollbacks
-   * @param operation The SQLTransactionOperation to execute
-   * @param data The sql input parameters to pass to the operation
-   * @param config The configuration for the transaction
-   * @returns The result of the operation; throws exceptions on failures
-   */
-  async executeTransaction(operation, data, config2 = {}) {
-    const transaction = new sql.Transaction(this.connection);
-    const isolationLevel = config2.isolationLevel || sql.ISOLATION_LEVEL.READ_COMMITTED;
-    try {
-      await transaction.begin(isolationLevel);
-      const result = await operation.execute(transaction, data);
-      await transaction.commit();
-      return result;
-    } catch (error) {
-      logger.error("Transaction error:", error);
-      try {
-        await transaction.rollback();
-      } catch (rollbackError) {
-        logger.error("Rollback error:", rollbackError);
-      }
-      throw error;
-    }
-  }
-}
-class SQLLaborTicketInsertOperation {
-  constructor(sqlQuery) {
-    this.sqlQuery = sqlQuery;
-  }
-  async execute(transaction, inputs) {
-    const request = transaction.request();
-    inputs.forEach((input) => {
-      request.input(input.name, input.type, input.value);
-    });
-    const result = await request.query(this.sqlQuery);
-    if (!result.recordset[0].NewRowUniqueId) {
-      throw new Error(
-        "No LaborTicketId generated by the labor ticket insert query: " + JSON.stringify(request.parameters, null, 2)
-      );
-    }
-    return result.recordset[0].NewRowUniqueId;
-  }
-}
-class SQLLaborTicketUpdateOperation {
-  constructor(sqlQuery) {
-    this.sqlQuery = sqlQuery;
-  }
-  async execute(transaction, inputs) {
-    const request = transaction.request();
-    inputs.forEach((input) => {
-      request.input(input.name, input.type, input.value);
-    });
-    const result = await request.query(this.sqlQuery);
-    return result.rowsAffected[0];
-  }
-}
-class SqlServerHelper {
-  /**
-   * Creates a new labor ticket in the SQL Server database
-   * Opens but does not close the connection
-   *
-   * @param sqlServerService  The SQL Server service to use for connections
-   * @param laborTicket       The labor ticket to create
-   * @param sqlInputs         The SQL query parameters
-   * @param insertQuery       The SQL query to execute for insertion
-   *
-   * @returns The processed labor ticket, with the ERP's laborTicketId set
-   * Throws exceptions on failures, including if the query does not return a laborTicketId
-   */
-  static async createLaborTicket(sqlServerService, laborTicket, sqlInputs, insertQuery) {
-    const connection = await sqlServerService.openConnection();
-    if (!connection) {
-      throw new Error(
-        "Unable to establish database connection to create labor ticket."
-      );
-    }
-    const transactionManager = new SQLTransactionManager(connection);
-    const laborTicketId = await transactionManager.executeTransaction(
-      new SQLLaborTicketInsertOperation(insertQuery),
-      sqlInputs
-    );
-    if (laborTicketId) {
-      laborTicket.laborTicketId = laborTicketId.toString();
-      return laborTicket;
-    } else {
-      throw new Error(
-        `The query did not return the labor ticket id for labor ticket ref: ${laborTicket.laborTicketRef}`
-      );
-    }
-  }
-  /**
-   * Updates an existing labor ticket in the SQL Server database
-   * Opens but does not close the connection
-   * @param sqlServerService  The SQL Server service to use for connections
-   * @param laborTicket       The labor ticket to update
-   * @param sqlInputs         The SQL query parameters
-   * @param updateQuery       The SQL query to execute for update
-   *
-   * @returns The processed labor ticket
-   * Throws exceptions on failures
-   */
-  static async updateLaborTicket(sqlServerService, laborTicket, sqlInputs, updateQuery) {
-    const connection = await sqlServerService.openConnection();
-    if (!connection) {
-      throw new Error(
-        "Unable to establish database connection to update labor ticket."
-      );
-    }
-    const transactionManager = new SQLTransactionManager(connection);
-    await transactionManager.executeTransaction(
-      new SQLLaborTicketUpdateOperation(updateQuery),
-      sqlInputs
-    );
-    return laborTicket;
-  }
-  /**
-   * Logs the SQL input parameters for debugging
-   */
-  static logQueryInputs(inputs) {
-    logger.info("SQL Input Variables:");
-    logger.info("----------------------------------------");
-    logger.info("Variable Name         | Value");
-    logger.info("----------------------------------------");
-    inputs.forEach((input) => {
-      logger.info(`${input.name.padEnd(20)} | ${input.value}`);
-    });
-    logger.info("----------------------------------------");
-  }
-}
-class PsqlService {
-  config;
-  static odbcModule = null;
-  static odbcLoadError = null;
-  constructor(config2) {
-    this.config = config2;
-  }
-  /**
-   * Dynamically load the ODBC module with lazy initialization and caching
-   * @throws Error with helpful message if ODBC package is not installed
-   */
-  static async getOdbc() {
-    if (this.odbcLoadError) {
-      throw this.odbcLoadError;
-    }
-    if (this.odbcModule) {
-      return this.odbcModule;
-    }
-    try {
-      const odbcImport = await import("odbc");
-      const odbc = odbcImport.default || odbcImport;
-      this.odbcModule = odbc;
-      return this.odbcModule;
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      this.odbcLoadError = new Error(
-        `ODBC package is required for PSQL service but is not installed or failed to load.
-Install it with: npm install odbc
-Also install OS-level dependencies, e.g. on Alpine Linux:
-  apk add --no-cache unixodbc unixodbc-dev python3 make g++
-For other Linux distributions, install unixodbc and unixodbc-dev packages.
-Original error: ${errorMessage}`
-      );
-      throw this.odbcLoadError;
-    }
-  }
-  // REMOVED: dispose() method - not needed anymore
-  // REMOVED: connection property - not needed anymore
-  // REMOVED: openConnection() method - not needed anymore
-  // REMOVED: closeConnection() method - not needed anymore
-  /**
-   * Build PSQL ODBC connection string
-   * CRITICAL: ServerName must use IP.PORT format (e.g., 10.4.0.11.1583)
-   */
-  buildConnectionString() {
-    const serverName = `${this.config.host}.${this.config.port}`;
-    return [
-      "Driver={Pervasive ODBC Interface}",
-      `ServerName=${serverName}`,
-      `DBQ=${this.config.database}`,
-      `UID=${this.config.username}`,
-      `PWD=${this.config.password}`,
-      "AutoDoubleQuote=0"
-    ].join(";") + ";";
-  }
-  /**
-   * Execute a query and return the results
-   * Creates a fresh connection for each query to avoid handle corruption
-   *
-   * SECURITY WARNING: This method executes the provided SQL string as-is.
-   * - Parameter binding is NOT implemented; the `params` argument is currently ignored.
-   * - Never concatenate untrusted/user-supplied input into `query`.
-   * - Doing so can result in SQL injection vulnerabilities and data exposure.
-   * If dynamic values are required, ensure they are strictly validated/escaped
-   * or implement proper parameterized execution before accepting untrusted input.
-   *
-   * @param query The SQL query to execute
-   * @param params Query parameters (currently unused for PSQL read operations)
-   * @param paging Optional paging parameters
-   * @returns The entities fetched from the database, along with paging information
-   */
-  async executePreparedStatement(query, params = {}, paging) {
-    const odbc = await PsqlService.getOdbc();
-    let connection = null;
-    try {
-      const connStr = this.buildConnectionString();
-      logger.debug("Creating fresh PSQL connection for query");
-      connection = await odbc.connect(connStr);
-      if (Object.keys(params).length > 0) {
-        logger.warn(
-          "PsqlService: Query parameters provided but parameter binding not yet implemented. Using direct query execution."
-        );
-      }
-      const records = await connection.query(query);
-      const allRecords = PsqlService.recordsetToRecords(records);
-      const rowsFetched = allRecords.length;
-      const pagedData = paging?.offset !== void 0 || paging?.limit !== void 0 ? allRecords.slice(
-        paging.offset || 0,
-        (paging.offset || 0) + (paging.limit || allRecords.length)
-      ) : allRecords;
-      return {
-        data: pagedData,
-        paging: {
-          count: rowsFetched,
-          limit: paging?.limit || 0,
-          offset: paging?.offset || 0,
-          nextPage: paging?.limit && (paging.offset || 0) + paging.limit < rowsFetched ? String((paging.offset || 0) + paging.limit) : void 0,
-          previousPage: paging?.offset ? String(Math.max(0, (paging.offset || 0) - (paging.limit || 10))) : void 0
-        }
-      };
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("ODBC package is required")) {
-        throw error;
-      }
-      const errorInfo = error;
-      logger.error("Error fetching data from PSQL", {
-        error: errorInfo.message,
-        odbcErrors: errorInfo.odbcErrors,
-        query: query.substring(0, 200)
-        // Log first 200 chars of query
-      });
-      throw this.handleOdbcError(errorInfo);
-    } finally {
-      if (connection) {
-        try {
-          await connection.close();
-          logger.debug("PSQL connection closed successfully");
-        } catch (err) {
-          logger.warn("Error closing PSQL connection (non-fatal)", {
-            error: err
-          });
-        }
-      }
-    }
-  }
-  /**
-   * Transform ODBC result set to array of Record<string, string> instances.
-   * IMPORTANT: PSQL CHAR fields are often padded with spaces - we trim them
-   */
-  static recordsetToRecords(recordset) {
-    if (!Array.isArray(recordset)) {
-      return [];
-    }
-    const data = recordset.map((row) => {
-      const transformedRow = {};
-      Object.keys(row).forEach((key) => {
-        const value = row[key];
-        transformedRow[key] = value !== null && value !== void 0 ? String(value).trim() : "";
-      });
-      return transformedRow;
-    });
-    return data;
-  }
-  /**
-   * Handle ODBC errors and provide meaningful messages
-   */
-  handleOdbcError(error) {
-    const odbcError = error.odbcErrors?.[0];
-    const errorCode = odbcError?.state;
-    const message = odbcError?.message || error.message;
-    switch (errorCode) {
-      case "08S01":
-        return new Error(
-          `PSQL connection failed. Check: 1) PVSW environment variable set to /usr/local/psql/etc/pvsw.ini, 2) Network connectivity to ports 1583/3351, 3) ODBC configuration files in /usr/local/psql/etc/ and /etc/. Original error: ${message}`
-        );
-      case "28000":
-        return new Error(
-          `PSQL authentication failed. Check username/password. Original error: ${message}`
-        );
-      case "42000":
-        return new Error(`PSQL SQL syntax error. Original error: ${message}`);
-      case "42S02":
-        return new Error(
-          `PSQL table or view not found. Check table names in query. Original error: ${message}`
-        );
-      default:
-        return new Error(`PSQL error (${errorCode || "unknown"}): ${message}`);
-    }
-  }
-}
-function formatPsqlDate(psqlDate) {
-  if (!psqlDate || psqlDate.trim().length !== 6 || psqlDate === "000000") {
-    return null;
-  }
-  try {
-    const year = parseInt(psqlDate.substring(0, 2), 10);
-    const month = parseInt(psqlDate.substring(2, 4), 10);
-    const day = parseInt(psqlDate.substring(4, 6), 10);
-    const fullYear = year + 2e3;
-    if (month < 1 || month > 12 || day < 1 || day > 31) {
-      return null;
-    }
-    const date = new Date(fullYear, month - 1, day);
-    if (date.getFullYear() !== fullYear || date.getMonth() !== month - 1 || date.getDate() !== day) {
-      return null;
-    }
-    return date.toISOString().split("T")[0];
-  } catch (error) {
-    return null;
-  }
-}
-function formatPsqlTime(psqlTime) {
-  if (!psqlTime) {
-    return null;
-  }
-  const trimmed = psqlTime.trim();
-  if (trimmed.length !== 4) {
-    return null;
-  }
-  try {
-    const hours = parseInt(trimmed.substring(0, 2), 10);
-    const minutes = parseInt(trimmed.substring(2, 4), 10);
-    if (isNaN(hours) || isNaN(minutes) || hours < 0 || hours > 23 || minutes < 0 || minutes > 59) {
-      return null;
-    }
-    const hoursStr = hours.toString().padStart(2, "0");
-    const minutesStr = minutes.toString().padStart(2, "0");
-    return `${hoursStr}:${minutesStr}:00`;
-  } catch (error) {
-    return null;
-  }
-}
-function combinePsqlDateTime(psqlDate, psqlTime) {
-  const date = formatPsqlDate(psqlDate);
-  const time = formatPsqlTime(psqlTime);
-  if (!date || !time) {
-    return null;
-  }
-  return `${date}T${time}`;
-}
-function isPsqlDateEmpty(psqlDate) {
-  return !psqlDate || psqlDate === "000000" || psqlDate.trim() === "";
-}
-function cleanPsqlCharField(value) {
-  if (value === null || value === void 0) {
-    return "";
-  }
-  return String(value).trim();
-}
-export {
-  ApplicationInitializer,
-  BatchCacheManager,
-  CoreConfiguration,
-  ERPObjType,
-  E as ErpApiConnectionParams,
-  ErrorHandler,
-  FileLogDeduper,
-  GraphQLError,
-  GraphQLService,
-  HTTPClientFactory,
-  HTTPError,
-  LogEntry,
-  MMApiClient,
-  MMBatchValidationError,
-  MMConnectorLogger,
-  MMReceiveLaborTicket,
-  MMSendLaborTicket,
-  MMSendPart,
-  MMSendPartOperation,
-  MMSendPerson,
-  MMSendReason,
-  MMSendResource,
-  MMSendWorkOrder,
-  MMSendWorkOrderOperation,
-  OAuthClient,
-  PsqlService,
-  RecordTrackingManager,
-  RestAPIService,
-  SqlServerHelper,
-  SqlServerService,
-  StandardProcessDrivers,
-  addNewFieldFromExternalSource,
-  addNewFieldFromLookupField,
-  applyTimezoneOffsetsToFields,
-  buildLogicalCondition,
-  cleanPsqlCharField,
-  cleanupNumbers,
-  combinePsqlDateTime,
-  convertToLocalTime,
-  formatDateWithTZOffset,
-  formatPsqlDate,
-  formatPsqlTime,
-  f as getCachedTimezoneName,
-  getCachedTimezoneOffset,
-  g as getErpApiConnectionParams,
-  getErrorType,
-  d as getInitialLoadComplete,
-  getPayloadWithoutIDField,
-  a as getSQLServerConfiguration,
-  getUniqueRows,
-  isPsqlDateEmpty,
-  config as knexDatabaseConfig,
-  logger,
-  removeExtraneousFields,
-  runDataSyncService,
-  e as setInitialLoadComplete,
-  trimObjectValues
-};
-//# sourceMappingURL=mm-erp-sdk.js.map