@machinemetrics/mm-erp-sdk 0.1.5-beta.0 → 0.1.5

package/dist/mm-erp-sdk.js

@@ -1,15 +1,16 @@
-import { C as CoreConfiguration, H as HashedCacheManager } from "./hashed-cache-manager-Ci59eC75.js";
-import { g, a } from "./hashed-cache-manager-Ci59eC75.js";
-import { l as logger } from "./logger-QG73MndU.js";
-import { g as getCachedMMToken, s as setCachedMMToken, a as setTimezoneOffsetInCache, b as getCachedTimezoneOffset, S as SQLiteCoordinator } from "./index-CXbOvFyf.js";
-import { c, d } from "./index-CXbOvFyf.js";
+import { C as CoreConfiguration, H as HashedCacheManager } from "./hashed-cache-manager-CzyFSt2B.js";
+import { E, g, a } from "./hashed-cache-manager-CzyFSt2B.js";
+import { l as logger } from "./logger-Db8CkwR6.js";
+import { g as getCachedMMToken, s as setCachedMMToken, a as setTimezoneOffsetInCache, b as getCachedTimezoneOffset, S as SQLiteCoordinator } from "./index-B9wo8pld.js";
+import { c, d } from "./index-B9wo8pld.js";
 import axios, { AxiosError } from "axios";
 import knex from "knex";
 import { c as config } from "./knexfile-1qKKIORB.js";
-import "./connector-factory-CQ8e7Tae.js";
+import fs from "fs";
+import path from "path";
+import "./connector-factory-C2czCs9v.js";
 import Bree from "bree";
 import Graceful from "@ladjs/graceful";
-import path from "path";
 import { fileURLToPath } from "url";
 import sql from "mssql";
 import { z } from "zod";
@@ -21,7 +22,6 @@ var ERPType = /* @__PURE__ */ ((ERPType2) => {
   ERPType2["PROSHOP"] = "PROSHOP";
   ERPType2["SYTELINE"] = "SYTELINE";
   ERPType2["TEMPLATE"] = "TEMPLATE";
-  ERPType2["GLOBALSHOP"] = "GLOBALSHOP";
   return ERPType2;
 })(ERPType || {});
 var ERPObjType = /* @__PURE__ */ ((ERPObjType2) => {
@@ -929,6 +929,38 @@ class MMApiClient {
       (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`,
@@ -1429,6 +1461,23 @@ const formatDateWithTZOffset = (date, timezoneOffset) => {
   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);
@@ -1611,7 +1660,7 @@ function convertLaborTicketToLocalTimezone(laborTicket, timezoneOffset) {
   ];
   timeFields.forEach((field) => {
     const localTime = convertToLocalTime(laborTicket[field], timezoneOffset);
-    laborTicket[field] = localTime?.toISOString() || null;
+    laborTicket[field] = localTime ? toISOWithOffset(localTime, timezoneOffset) : null;
   });
   return laborTicket;
 }
@@ -3042,6 +3091,353 @@ function getERPAPITypeFromEntity(entity, entityMap) {
   );
   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
@@ -3066,7 +3462,7 @@ class ApplicationInitializer {
       );
     } catch (error) {
       logger.error("Critical initialization failure. Exiting.", error);
-      process.exit(1);
+      process.exitCode = 1;
     }
   }
   /**
@@ -3592,10 +3988,18 @@ export {
   CoreConfiguration,
   ERPObjType,
   ERPType,
+  E as ErpApiConnectionParams,
   ErrorHandler,
+  FileLogDeduper,
+  GraphQLError,
   GraphQLService,
   HTTPClientFactory,
+  HTTPError,
+  LogEntry,
   MMApiClient,
+  MMBatchValidationError,
+  MMConnectorLogger,
+  MMReceiveLaborTicket,
   MMSendLaborTicket,
   MMSendPart,
   MMSendPartOperation,
@@ -3605,6 +4009,7 @@ export {
   MMSendWorkOrder,
   MMSendWorkOrderOperation,
   OAuthClient,
+  RecordTrackingManager,
   RestAPIService,
   SqlServerHelper,
   SqlServerService,
@@ -3618,10 +4023,12 @@ export {
   formatDateWithTZOffset,
   getCachedTimezoneOffset,
   g as getErpApiConnectionParams,
+  getErrorType,
   c as getInitialLoadComplete,
   getPayloadWithoutIDField,
   a as getSQLServerConfiguration,
   getUniqueRows,
+  config as knexDatabaseConfig,
   logger,
   removeExtraneousFields,
   runDataSyncService,