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

package/dist/mm-erp-sdk.js

@@ -1,16 +1,15 @@
-import { C as CoreConfiguration, H as HashedCacheManager } from "./hashed-cache-manager-CtDhFqj6.js";
-import { E, g, a } from "./hashed-cache-manager-CtDhFqj6.js";
-import { l as logger } from "./logger-hqtl8hFM.js";
-import { g as getCachedMMToken, s as setCachedMMToken, a as setTimezoneOffsetInCache, b as getCachedTimezoneOffset, S as SQLiteCoordinator } from "./index-aci_wdcn.js";
-import { c, d } from "./index-aci_wdcn.js";
+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 axios, { AxiosError } from "axios";
 import knex from "knex";
 import { c as config } from "./knexfile-1qKKIORB.js";
-import fs from "fs";
-import path from "path";
-import "./connector-factory-13bvmpQB.js";
+import "./connector-factory-CQ8e7Tae.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";
@@ -22,6 +21,7 @@ var ERPType = /* @__PURE__ */ ((ERPType2) => {
   ERPType2["PROSHOP"] = "PROSHOP";
   ERPType2["SYTELINE"] = "SYTELINE";
   ERPType2["TEMPLATE"] = "TEMPLATE";
+  ERPType2["GLOBALSHOP"] = "GLOBALSHOP";
   return ERPType2;
 })(ERPType || {});
 var ERPObjType = /* @__PURE__ */ ((ERPObjType2) => {
@@ -929,38 +929,6 @@ 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`,
@@ -3074,351 +3042,6 @@ 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,
-            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);
-        store[key] = {
-          ...existing,
-          suppressedCount: 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
@@ -3969,18 +3592,10 @@ export {
   CoreConfiguration,
   ERPObjType,
   ERPType,
-  E as ErpApiConnectionParams,
   ErrorHandler,
-  FileLogDeduper,
-  GraphQLError,
   GraphQLService,
   HTTPClientFactory,
-  HTTPError,
-  LogEntry,
   MMApiClient,
-  MMBatchValidationError,
-  MMConnectorLogger,
-  MMReceiveLaborTicket,
   MMSendLaborTicket,
   MMSendPart,
   MMSendPartOperation,
@@ -3990,7 +3605,6 @@ export {
   MMSendWorkOrder,
   MMSendWorkOrderOperation,
   OAuthClient,
-  RecordTrackingManager,
   RestAPIService,
   SqlServerHelper,
   SqlServerService,
@@ -4004,12 +3618,10 @@ export {
   formatDateWithTZOffset,
   getCachedTimezoneOffset,
   g as getErpApiConnectionParams,
-  getErrorType,
   c as getInitialLoadComplete,
   getPayloadWithoutIDField,
   a as getSQLServerConfiguration,
   getUniqueRows,
-  config as knexDatabaseConfig,
   logger,
   removeExtraneousFields,
   runDataSyncService,