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

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-INiCs0JC.js";
+import { g, a } from "./hashed-cache-manager-INiCs0JC.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 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-DFv3ex0X.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";
@@ -928,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`,
@@ -3041,6 +3074,351 @@ 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
@@ -3592,9 +3970,12 @@ export {
   ERPObjType,
   ERPType,
   ErrorHandler,
+  FileLogDeduper,
   GraphQLService,
   HTTPClientFactory,
   MMApiClient,
+  MMBatchValidationError,
+  MMConnectorLogger,
   MMSendLaborTicket,
   MMSendPart,
   MMSendPartOperation,
@@ -3617,6 +3998,7 @@ export {
   formatDateWithTZOffset,
   getCachedTimezoneOffset,
   g as getErpApiConnectionParams,
+  getErrorType,
   c as getInitialLoadComplete,
   getPayloadWithoutIDField,
   a as getSQLServerConfiguration,