@machinemetrics/mm-erp-sdk 0.2.0-beta.0 → 0.2.0-beta.2

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();
+

package/src/services/psql-erp-service/index.ts

@@ -1,4 +1,4 @@
-import { PsqlService } from "./psql-service.js";
+import { PsqlService } from "./psql-service";
 
 /**
  * A class to manage interactions with PSQL (Pervasive) databases via ODBC
@@ -8,7 +8,7 @@ export { PsqlService };
 /**
  * Configuration interface for PSQL connections
  */
-export type { PsqlConfiguration } from "./configuration.js";
+export type { PsqlConfiguration } from "./configuration";
 
 /**
  * Helper functions for PSQL data formatting
@@ -19,4 +19,4 @@ export {
   combinePsqlDateTime,
   isPsqlDateEmpty,
   cleanPsqlCharField,
-} from "./psql-helpers.js";
+} from "./psql-helpers";

package/src/services/psql-erp-service/psql-service.ts

@@ -1,7 +1,7 @@
-import { PsqlConfiguration } from "./configuration.js";
-import { ERPResponse } from "../../types/erp-types.js";
-import { OdbcErrorResponse } from "./internal/types/psql-types.js";
-import logger from "../reporting-service/logger.js";
+import { PsqlConfiguration } from "./configuration";
+import { ERPResponse } from "../../types/erp-types";
+import { OdbcErrorResponse } from "./internal/types/psql-types";
+import logger from "../reporting-service/logger";
 
 type PagingParams = {
   limit?: number;

package/src/services/reporting-service/index.ts

@@ -1,4 +1,4 @@
 /**
  * Export the logger instance for use throughout the application
  */
-export { default as logger } from "./logger.js";
+export { default as logger } from "./logger";