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

package/src/services/mm-api-service/company-info.ts

@@ -0,0 +1,87 @@
+import { CoreConfiguration } from "../data-sync-service/configuration-manager";
+import { HTTPClientFactory } from "../../utils/http-client";
+import { logger } from "../reporting-service";
+
+// Cache for company info to avoid repeated API calls
+let companyInfoCache: {
+  timezone: string;
+  locationRef: string;
+  companyId: string;
+} | null = null;
+
+export interface CompanyInfo {
+  timezone: string;
+  locationRef: string;
+  companyId: string;
+}
+
+/**
+ * Fetches company information from /accounts/current endpoint
+ * Results are cached to avoid repeated API calls
+ * @returns Promise<CompanyInfo> Company information including timezone, locationRef, and companyId
+ * @throws Error if unable to fetch company information
+ */
+export const getCompanyInfo = async (): Promise<CompanyInfo> => {
+  // Return cached value if available
+  if (companyInfoCache) {
+    return companyInfoCache;
+  }
+
+  try {
+    // Get the configuration
+    const config = CoreConfiguration.inst();
+    const apiUrl = config.mmApiBaseUrl;
+    const authToken = config.mmApiAuthToken;
+
+    if (!apiUrl || !authToken) {
+      throw new Error("Missing required configuration for company info fetch");
+    }
+
+    // Create HTTP client
+    const client = HTTPClientFactory.getInstance({
+      baseUrl: apiUrl,
+      retryAttempts: config.mmApiRetryAttempts,
+    });
+
+    // Fetch user/company information from the API
+    const response = await client.request<{
+      company: {
+        timezone: string;
+        id: string;
+      };
+      locationRef: number;
+    }>({
+      url: "/accounts/current?includeLocation=true",
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${authToken}`,
+      },
+    });
+
+    const userInfo = response.data;
+    if (!userInfo?.company) {
+      throw new Error("Unable to retrieve company information from API");
+    }
+
+    // Debug: Log what we actually got from the API
+    logger.info("Fetched company info from /accounts/current", {
+      locationRef: userInfo.locationRef,
+      companyId: userInfo.company.id,
+      timezone: userInfo.company.timezone,
+    });
+
+    // Cache and return company info - locationRef is at top level, not in company
+    companyInfoCache = {
+      timezone: userInfo.company.timezone,
+      locationRef: String(userInfo.locationRef), // Convert number to string
+      companyId: userInfo.company.id,
+    };
+
+    return companyInfoCache;
+  } catch (error) {
+    throw new Error(
+      `Failed to get company info: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
+};
+

package/src/services/mm-api-service/index.ts

@@ -1,9 +1,9 @@
-import { MMApiClient } from "./mm-api-service.js";
+import { MMApiClient } from "./mm-api-service";
 import type {
   MMReceiveLaborTicket,
   MMReceiveLaborTicketReason,
   MMReceiveLaborTicketWorkOrderOperation,
-} from "./types/receive-types.js";
+} from "./types/receive-types";
 import {
   MMSendPerson,
   MMSendResource,
@@ -14,8 +14,8 @@ import {
   MMSendReason,
   MMSendLaborTicket,
   MMSendWorkOrderBatch,
-} from "./types/send-types.js";
-import type { IToRESTApiObject } from "./types/send-types.js";
+} from "./types/send-types";
+import type { IToRESTApiObject } from "./types/send-types";
 import type {
   MMApiBaseResponse,
   MM200NonLaborTicketResponse,
@@ -26,7 +26,9 @@ import type {
   MM500LaborTicketException,
   MMGraphQLResourceResponse,
   MMMachineGroupsResponse,
-} from "./types/mm-response-interfaces.js";
+} from "./types/mm-response-interfaces";
+import { getCompanyInfo } from "./company-info";
+import type { CompanyInfo } from "./company-info";
 
 /**
  * A class to manage interactions with the MM API
@@ -52,7 +54,7 @@ export type {
 /**
  * Types related of labor tickets received from the MM API
  */
-export { MMReceiveLaborTicket } from "./types/receive-types.js";
+export { MMReceiveLaborTicket } from "./types/receive-types";
 export type {
   MMReceiveLaborTicketReason,
   MMReceiveLaborTicketWorkOrderOperation,
@@ -81,3 +83,9 @@ export {
  * Batch interfaces for sending multiple related entities
  */
 export type { MMSendWorkOrderBatch };
+
+/**
+ * Company information utilities
+ */
+export { getCompanyInfo };
+export type { CompanyInfo };

package/src/services/mm-api-service/mm-api-service.ts

@@ -1,22 +1,22 @@
-import logger from "../reporting-service/logger.js";
-import { ERPObjType } from "../../types/erp-types.js";
-import { MMReceiveLaborTicket } from "./types/receive-types.js";
-import { MMTokenManager } from "./token-mgr.js";
-import * as MM_SEND_TYPES from "./types/send-types.js";
+import logger from "../reporting-service/logger";
+import { ERPObjType } from "../../types/erp-types";
+import { MMReceiveLaborTicket } from "./types/receive-types";
+import { MMTokenManager } from "./token-mgr";
+import * as MM_SEND_TYPES from "./types/send-types";
 import {
   HTTPClient,
   HTTPMethod,
   HTTPRequestConfig,
   HTTPClientFactory,
-} from "../../utils/http-client.js";
-import { Checkpoint } from "./types/checkpoint.js";
-import { CoreConfiguration } from "../data-sync-service/configuration-manager.js";
-import { ErrorHandler } from "../erp-api-services/errors.js";
+} from "../../utils/http-client";
+import { Checkpoint } from "./types/checkpoint";
+import { CoreConfiguration } from "../data-sync-service/configuration-manager";
+import { ErrorHandler } from "../erp-api-services/errors";
 import {
   MMApiBaseResponse,
   MMGraphQLResourceResponse,
   MMMachineGroupsResponse,
-} from "./types/mm-response-interfaces.js";
+} from "./types/mm-response-interfaces";
 
 const MAPPING = "MAPPING";
 const CHECKPOINTS = "CHECKPOINTS";
@@ -80,9 +80,12 @@ export class MMApiClient {
         return typeof err === "object" && err !== null && "status" in err;
       };
 
-      // Check if this looks like an auth error - only retry on explicit auth status codes
+      // Check if this looks like an auth error - retry on auth status codes or JWT expiration errors
       const isAuthError =
-        hasStatus(error) && (error.status === 401 || error.status === 403);
+        hasStatus(error) && (error.status === 401 || error.status === 403) ||
+        (hasStatus(error) && error.status === 500 && 
+         typeof (error as any).data?.error === 'string' && 
+         (error as any).data.error.includes('JWT'));
 
       if (isAuthError && !options.token) {
         // Only retry if we used cached token
@@ -506,6 +509,20 @@ export class MMApiClient {
     return updates.data.map((ticket) => new MMReceiveLaborTicket(ticket));
   }
 
+  /**
+   * Fetch a single labor ticket by reference from the MM API
+   * @param laborTicketRef The labor ticket reference to fetch
+   * @returns Promise with the labor ticket data
+   */
+  async fetchLaborTicketByRef(
+    laborTicketRef: string
+  ): Promise<MMReceiveLaborTicket> {
+    const response = (await this.getData(
+      `${this.resourceURLs[ERPObjType.LABOR_TICKETS]}/${laborTicketRef}`
+    )) as { data: MMReceiveLaborTicket };
+    return new MMReceiveLaborTicket(response.data);
+  }
+
   /**
    * Fetch a checkpoint for a specific system, table, and checkpoint type
    * @param checkpoint The checkpoint to fetch

package/src/services/mm-api-service/token-mgr.ts

@@ -1,10 +1,10 @@
 import {
   getCachedMMToken,
   setCachedMMToken,
-} from "../../utils/local-data-store/jobs-shared-data.js";
-import { HTTPClient, HTTPClientFactory } from "../../utils/http-client.js";
-import { CoreConfiguration } from "../data-sync-service/configuration-manager.js";
-import { logger } from "../reporting-service/index.js";
+} from "../../utils/local-data-store/jobs-shared-data";
+import { HTTPClient, HTTPClientFactory } from "../../utils/http-client";
+import { CoreConfiguration } from "../data-sync-service/configuration-manager";
+import { logger } from "../reporting-service";
 
 /**
  * Manages the MM API token with caching and expiration checking

package/src/services/mm-api-service/types/entity-transformer.ts

@@ -1,5 +1,5 @@
-import { ERPObjType } from "../../../types/erp-types.js";
-import { IToRESTApiObject } from "../index.js";
+import { ERPObjType } from "../../../types/erp-types";
+import { IToRESTApiObject } from "..";
 import {
   MMSendPerson,
   MMSendResource,
@@ -9,7 +9,7 @@ import {
   MMSendWorkOrderOperation,
   MMSendLaborTicket,
   MMSendReason,
-} from "../index.js";
+} from "..";
 
 /**
  * Utility class for transforming entities to/from non-typed and typed objects

package/src/services/mm-api-service/types/receive-types.ts

@@ -42,6 +42,7 @@ export class MMReceiveLaborTicket {
   personId!: string; // The person who did the work
   reasons?: MMReceiveLaborTicketReason[];
   resourceId!: string; // The physical resource that did the work
+  resource?: { name: string }; // The resource name (available from export/updates endpoint)
   sequenceNumber!: number; // 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!: string; // Batch number if order split for staggered delivery. If not available in the ERP, default to an empty string
   state!: string; // The current state of the labor ticket (e.g., "CLOSED/OPEN")

package/src/services/nats-service/nats-service.ts

@@ -0,0 +1,351 @@
+/**
+ * NATS Service - Central connection and subscription management
+ * Allows connectors to register handlers for different NATS subjects
+ */
+
+import { connect, NatsConnection, StringCodec, Subscription } from "nats";
+import { logger } from "../reporting-service";
+
+const sc = StringCodec();
+
+export interface NatsMessageHandler {
+  /**
+   * Handler function for NATS messages
+   * - Return a value to reply (if msg has reply subject)
+   * - Return void/undefined for pub-sub (no reply)
+   */
+  handle: (data: any, subject: string) => Promise<any | void>;
+}
+
+export interface NatsHandlerRegistration {
+  /**
+   * Subject pattern to subscribe to (supports wildcards: *, >)
+   * Examples:
+   *   - "mm.14.epic01.labor-ticket.*" (single level wildcard)
+   *   - "mm.14.epic01.erp.>" (multi-level wildcard)
+   */
+  subject: string;
+
+  /**
+   * Handler for this subject
+   */
+  handler: NatsMessageHandler;
+
+  /**
+   * Optional description for logging/debugging
+   */
+  description?: string;
+}
+
+export interface NatsServiceConfig {
+  /**
+   * NATS server URLs
+   */
+  servers: string | string[];
+
+  /**
+   * Connection name (for monitoring)
+   */
+  name: string;
+
+  /**
+   * Location reference (for subject namespacing)
+   */
+  locationRef: string;
+
+  /**
+   * ERP type (epicor, infor, etc.)
+   */
+  erpType: string;
+
+  /**
+   * Enable/disable NATS
+   */
+  enabled: boolean;
+
+  /**
+   * Auto-reconnect settings
+   */
+  reconnect?: boolean;
+  maxReconnectAttempts?: number;
+  reconnectTimeWait?: number;
+}
+
+export class NatsService {
+  private connection: NatsConnection | null = null;
+  private subscriptions: Map<string, Subscription> = new Map();
+  private config: NatsServiceConfig;
+  private handlers: NatsHandlerRegistration[] = [];
+  private statusPublishTimer: NodeJS.Timeout | null = null;
+
+  constructor(config: NatsServiceConfig) {
+    this.config = config;
+  }
+
+  /**
+   * Register a handler for a specific subject pattern
+   */
+  registerHandler(registration: NatsHandlerRegistration): void {
+    logger.info("Registering NATS handler", {
+      subject: registration.subject,
+      description: registration.description,
+    });
+    this.handlers.push(registration);
+  }
+
+  /**
+   * Connect to NATS and start all registered handlers
+   */
+  async connect(): Promise<void> {
+    if (!this.config.enabled) {
+      logger.info("NATS is disabled, skipping connection");
+      return;
+    }
+
+    try {
+      logger.info("Connecting to NATS...", {
+        servers: this.config.servers,
+        name: this.config.name,
+      });
+
+      this.connection = await connect({
+        servers: this.config.servers,
+        name: this.config.name,
+        reconnect: this.config.reconnect ?? true,
+        maxReconnectAttempts: this.config.maxReconnectAttempts ?? -1,
+        reconnectTimeWait: this.config.reconnectTimeWait ?? 2000,
+      });
+
+      logger.info("Connected to NATS", {
+        server: this.connection.getServer(),
+        clientId: this.connection.info?.client_id,
+      });
+
+      // Start all registered handlers
+      for (const registration of this.handlers) {
+        await this.startHandler(registration);
+      }
+
+      // Start automatic status publishing
+      this.startStatusPublishing();
+
+      // Monitor connection status
+      this.monitorConnection();
+
+      // Graceful shutdown
+      this.setupShutdown();
+    } catch (error) {
+      logger.error("Failed to connect to NATS", { error });
+      throw error;
+    }
+  }
+
+  /**
+   * Start a single handler (subscribe to its subject)
+   */
+  private async startHandler(registration: NatsHandlerRegistration): Promise<void> {
+    if (!this.connection) {
+      throw new Error("NATS connection not established");
+    }
+
+    const sub = this.connection.subscribe(registration.subject);
+    this.subscriptions.set(registration.subject, sub);
+
+    logger.info("Started NATS handler", {
+      subject: registration.subject,
+      description: registration.description,
+    });
+
+    // Process messages
+    (async () => {
+      for await (const msg of sub) {
+        try {
+          const data = sc.decode(msg.data);
+          
+          logger.info("Received NATS message", {
+            subject: msg.subject,
+            hasReply: !!msg.reply,
+          });
+
+          // Parse JSON if possible
+          let parsedData: any;
+          try {
+            parsedData = JSON.parse(data);
+          } catch {
+            parsedData = data;
+          }
+
+          // Call handler
+          const response = await registration.handler.handle(parsedData, msg.subject);
+          
+          // If there's a reply subject and handler returned something, reply
+          if (msg.reply && response !== undefined) {
+            const responseStr = JSON.stringify(response);
+            msg.respond(sc.encode(responseStr));
+            logger.info("Sent reply", { replySubject: msg.reply });
+          }
+        } catch (error) {
+          logger.error("Error handling NATS message", {
+            subject: msg.subject,
+            error,
+          });
+
+          // Send error response if reply expected
+          if (msg.reply) {
+            const errorResponse = {
+              status: "error",
+              error: {
+                message: error instanceof Error ? error.message : "Unknown error",
+                code: "HANDLER_ERROR",
+              },
+            };
+            msg.respond(sc.encode(JSON.stringify(errorResponse)));
+          }
+        }
+      }
+    })();
+  }
+
+  /**
+   * Publish a message to a subject (for pub/sub)
+   */
+  async publish(subject: string, data: any): Promise<void> {
+    if (!this.connection) {
+      throw new Error("NATS connection not established");
+    }
+
+    const message = typeof data === "string" ? data : JSON.stringify(data);
+    this.connection.publish(subject, sc.encode(message));
+
+    logger.info("Published NATS message", { subject });
+  }
+
+  /**
+   * Send a request and wait for reply (for request-reply)
+   */
+  async request(subject: string, data: any, timeoutMs: number = 30000): Promise<any> {
+    if (!this.connection) {
+      throw new Error("NATS connection not established");
+    }
+
+    const message = typeof data === "string" ? data : JSON.stringify(data);
+    const response = await this.connection.request(
+      subject,
+      sc.encode(message),
+      { timeout: timeoutMs }
+    );
+
+    const responseData = sc.decode(response.data);
+    
+    try {
+      return JSON.parse(responseData);
+    } catch {
+      return responseData;
+    }
+  }
+
+  /**
+   * Check if connected to NATS
+   */
+  isConnected(): boolean {
+    return this.connection !== null && !this.connection.isClosed();
+  }
+
+  /**
+   * Start automatic status publishing (every 30 seconds)
+   */
+  private startStatusPublishing(): void {
+    logger.info("Starting status publishing (every 30 seconds)");
+
+    // Publish immediately on start
+    this.publishStatus();
+
+    // Then publish every 30 seconds
+    this.statusPublishTimer = setInterval(() => {
+      this.publishStatus();
+    }, 30000);
+  }
+
+  /**
+   * Publish connector status
+   */
+  private async publishStatus(): Promise<void> {
+    try {
+      const status = {
+        timestamp: new Date().toISOString(),
+        locationRef: this.config.locationRef,
+        erpType: this.config.erpType,
+        natsConnected: this.isConnected(),
+      };
+
+      await this.publish(
+        `mm.14.${this.config.locationRef}.erp.status`,
+        status
+      );
+
+      logger.debug("Published connector status");
+    } catch (error) {
+      logger.error("Failed to publish status", { error });
+    }
+  }
+
+  /**
+   * Monitor connection status
+   */
+  private monitorConnection(): void {
+    if (!this.connection) return;
+
+    (async () => {
+      for await (const status of this.connection!.status()) {
+        // Only log important events, skip pingTimer
+        if (status.type !== "pingTimer") {
+          logger.info("NATS connection status", {
+            type: status.type,
+            data: status.data,
+          });
+        }
+      }
+    })();
+  }
+
+  /**
+   * Setup graceful shutdown
+   */
+  private setupShutdown(): void {
+    const shutdown = async () => {
+      logger.info("Shutting down NATS service...");
+      await this.disconnect();
+      process.exit(0);
+    };
+
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+  }
+
+  /**
+   * Disconnect from NATS
+   */
+  async disconnect(): Promise<void> {
+    // Stop status publishing
+    if (this.statusPublishTimer) {
+      clearInterval(this.statusPublishTimer);
+      this.statusPublishTimer = null;
+    }
+
+    // Close connection
+    if (this.connection) {
+      await this.connection.drain();
+      this.connection = null;
+      this.subscriptions.clear();
+      logger.info("Disconnected from NATS");
+    }
+  }
+
+  /**
+   * Get the location reference
+   */
+  getLocationRef(): string {
+    return this.config.locationRef;
+  }
+}
+

package/src/services/nats-service/test-nats-subscriber.ts

@@ -0,0 +1,96 @@
+/**
+ * Simple proof-of-concept NATS subscriber
+ * Subscribes to mm.14.> and replies with "hello world"
+ */
+
+import { connect, StringCodec } from "nats";
+import { logger } from "../../services/reporting-service";
+
+const sc = StringCodec();
+
+async function startTestSubscriber() {
+  try {
+    // Connect to NATS server
+    const nc = await connect({
+      servers: "nats://localhost:4222",
+      name: "mm-erp-sdk-test-subscriber",
+    });
+
+    logger.info("Connected to NATS server", {
+      server: nc.getServer(),
+      clientId: nc.info?.client_id,
+    });
+
+    // Subscribe to all messages on mm.14.>
+    const sub = nc.subscribe("mm.14.>");
+
+    logger.info("Subscribed to mm.14.> - waiting for messages...");
+
+    // Process incoming messages
+    (async () => {
+      for await (const msg of sub) {
+        const data = sc.decode(msg.data);
+        
+        logger.info("📨 Received NATS message", {
+          subject: msg.subject,
+          data: data,
+          reply: msg.reply,
+        });
+
+        console.log("\n=== NATS MESSAGE RECEIVED ===");
+        console.log("Subject:", msg.subject);
+        console.log("Data:", data);
+        console.log("Reply subject:", msg.reply);
+        console.log("============================\n");
+
+        // Reply if there's a reply subject
+        if (msg.reply) {
+          const replyMessage = JSON.stringify({
+            message: "hello world",
+            timestamp: new Date().toISOString(),
+            receivedSubject: msg.subject,
+            receivedData: data,
+          });
+
+          msg.respond(sc.encode(replyMessage));
+          
+          logger.info("✅ Sent reply: hello world", {
+            replySubject: msg.reply,
+          });
+          
+          console.log("✅ Replied with: hello world\n");
+        }
+      }
+    })();
+
+    // Handle connection events
+    (async () => {
+      for await (const status of nc.status()) {
+        logger.info("NATS connection status", {
+          type: status.type,
+          data: status.data,
+        });
+        console.log(`Connection status: ${status.type}`, status.data);
+      }
+    })();
+
+    // Graceful shutdown
+    const shutdown = async () => {
+      logger.info("Shutting down NATS subscriber...");
+      await nc.drain();
+      process.exit(0);
+    };
+
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+
+  } catch (error) {
+    logger.error("Failed to connect to NATS", { error });
+    console.error("Error connecting to NATS:", error);
+    process.exit(1);
+  }
+}
+
+// Start the subscriber
+startTestSubscriber();
+