Refactored event into a seperate example file

Author: stefanrammo

client.js

@@ -182,7 +182,7 @@ class Client {
    *   codeMask: 0,
    *   limit: 100,
    *   offset: 0,
-   *   flags: 1  // Numeric flags as defined in your protocol
+   *   flags: 1
    * }
    * @returns {Promise<Array>} Resolves with an array of events.
    */

event.js

@@ -1,6 +1,7 @@
 // event.js
 global.WebSocket = require('ws');
 const Client = require('./client');
+// NOTE: Event support is only on API version 4.0.0+
 
 /**
  * Recursively normalizes an object/value.

index.js

@@ -50,50 +50,11 @@ async function printDataPoints() {
   }
 }
 
-// Print events retrieved within a time range corresponding to UTC 9:40.
-// In this example, we use a 5-minute window starting at UTC 9:40.
-async function printEvents() {
-  try {
-    // Specify the target time for events in UTC.
-    // Adjust the date as needed; here we assume a specific date.
-    const targetDate = new Date("2025-03-21T09:38:00Z");
-    const targetTime = targetDate.getTime() / 1000;
-    // Define a window of 5 minutes (300 seconds)
-    const timeWindow = 5 * 60;
-
-    const eventQuery = {
-      timeRangeBegin: targetTime,
-      timeRangeEnd: targetTime + timeWindow,
-      codeMask: 0,
-      limit: 100,
-      offset: 0,
-      flags: 0,
-      // Optionally, add senderConditions or dataConditions if desired.
-    };
-
-    const events = await client.requestEvents(eventQuery);
-    console.log("Events retrieved:");
-    if (!events || events.length === 0) {
-      console.log("No events found with the current query.");
-    } else {
-      events.forEach(evt => {
-        console.log(`Timestamp: ${evt.timestampSec}`);
-        console.log(`  Code:   ${evt.data && evt.data.Code ? evt.data.Code : "N/A"}`);
-        console.log(`  Source: ${evt.data && evt.data.Source ? evt.data.Source : "N/A"}`);
-        console.log(`  Text:   ${evt.data && evt.data.Text ? evt.data.Text : "N/A"}`);
-        console.log('--------------------');
-      });
-    }
-  } catch (err) {
-    console.error("Error retrieving events:", err);
-  }
-}
 
 async function main() {
   try {
     printLoggedNodes();
     await printDataPoints();
-    await printEvents();
   } catch (error) {
     console.error("Error in main:", error);
   } finally {

test/testTimeSync.js

@@ -12,67 +12,88 @@ global.WebSocket = class {
   }
 };
 
+// --- Capture Request IDs for time sync vs. API calls ---
+// We override _getRequestId so that for each API call the first call is used for
+// the time sync update and the second call is used for the actual API request.
+let capturedTimeSyncRequestId = null;
+let capturedApiRequestId = null;
+const originalGetRequestId = Client.prototype._getRequestId;
+Client.prototype._getRequestId = function() {
+  const id = originalGetRequestId.call(this);
+  if (capturedTimeSyncRequestId === null) {
+    capturedTimeSyncRequestId = id;
+  } else if (capturedApiRequestId === null) {
+    capturedApiRequestId = id;
+  }
+  return id;
+};
+
 /**
  * Helper function to run an API method with time sync enabled and then disabled.
- * It forces an update (by setting lastTimeRequest to an old value) before each call.
- * The simulateResponse callback simulates the corresponding response by calling _parseMessage.
+ * It forces a time update (by setting lastTimeRequest to an old value) before each call.
+ * The simulateResponse callback simulates the corresponding responses by calling _parseMessage.
+ * The callback receives two parameters: timeSyncRequestId and apiRequestId.
  */
 async function runThrough(methodName, callFunc, simulateResponse) {
+  // Reset captured IDs for this run.
+  capturedTimeSyncRequestId = null;
+  capturedApiRequestId = null;
+
   console.log(`\n=== Running ${methodName} with time sync ENABLED ===`);
-  // Force a time update by setting lastTimeRequest to an old value.
+  // Force a time update.
   client.lastTimeRequest = Date.now() / 1000 - 20;
   // Call the API method.
   callFunc();
-  // Simulate a response if needed.
-  if (simulateResponse) simulateResponse();
-  // Wait longer for the time sync update to complete.
+  // Allow the _getRequestId calls to occur.
+  await new Promise(resolve => setTimeout(resolve, 50));
+  // Simulate two responses: first for the time sync update, then for the API response.
+  if (simulateResponse) simulateResponse(capturedTimeSyncRequestId, capturedApiRequestId);
+  // Wait for responses to be processed.
   await new Promise(resolve => setTimeout(resolve, 300));
   console.log(`${methodName} -> timeDiff: ${client.timeDiff.toFixed(6)} sec`);
 
   // Now disable time sync.
-  // Clear any pending time requests so they don't update timeDiff later.
   client.storedPromises = {};
   client.setEnableTimeSync(false);
   console.log(`\n=== Running ${methodName} with time sync DISABLED ===`);
   const previousTimeDiff = client.timeDiff;
   client.lastTimeRequest = Date.now() / 1000 - 20;
+  // Reset captured IDs for the disabled run.
+  capturedTimeSyncRequestId = null;
+  capturedApiRequestId = null;
   callFunc();
-  // When time sync is disabled, do NOT simulate a response.
+  // When time sync is disabled, do NOT simulate a time sync response.
   await new Promise(resolve => setTimeout(resolve, 300));
   console.log(`${methodName} -> timeDiff: ${client.timeDiff.toFixed(6)} sec (should remain ${previousTimeDiff.toFixed(6)} sec)`);
   // Re-enable time sync for subsequent tests.
   client.setEnableTimeSync(true);
 }
 
 async function runTest() {
-  // Create a new client instance with only endpoint and autoReconnect.
+  // Create a new client instance.
   client = new Client('127.0.0.1:17000', true);
 
-  // Override _sendTimeRequest to simulate an immediate server time response with variable delay.
+  // Override _sendTimeRequest to simulate a server time response with variable delay.
   client._sendTimeRequest = function (requestId) {
     console.log(`_sendTimeRequest called with requestId: ${requestId}`);
-    // Simulate variable network delay (e.g., 50 to 300ms)
     const delay = Math.floor(Math.random() * 250) + 50;
     setTimeout(() => {
-      // Simulate a server timestamp in nanoseconds.
       const simulatedTimestamp = Date.now() * 1e6;
       console.log(`Simulated timestamp for request ${requestId} after ${delay}ms: ${simulatedTimestamp}`);
-      if (client.storedPromises[requestId]) {
-        client.storedPromises[requestId].resolve(simulatedTimestamp);
-        delete client.storedPromises[requestId];
+      if (this.storedPromises[requestId]) {
+        this.storedPromises[requestId].resolve(simulatedTimestamp);
+        delete this.storedPromises[requestId];
       }
     }, delay);
   };
 
-  // Override _updateTimeDiff to perform one measurement and log its details.
+  // Override _updateTimeDiff to log the measurement.
   client._updateTimeDiff = function () {
     if (!this.enableTimeSync) return;
     const requestId = this._getRequestId();
     const timeSent = Date.now() / 1000;
-    // Call _requestTime (which now calls our overridden _sendTimeRequest).
     this._requestTime(requestId)
       .then(timestamp => {
-        // Simulate a time response arriving.
         this.timeReceived = Date.now() / 1000;
         const roundTripTime = this.timeReceived - timeSent;
         const serverTime = (timestamp / 1e9) + roundTripTime / 2;
@@ -88,46 +109,73 @@ async function runTest() {
       .catch(err => console.error(err));
   };
 
-  // Use the production _requestTime (which already checks enableTimeSync).
-  // No override needed here.
-
-  // Now run through several public API methods.
+  // Run tests for each public API method.
   await runThrough(
     "requestApiVersion",
     () => client.requestApiVersion(),
-    () => {
-      // Simulate a valid API version response.
-      const response = fakeData.createApiVersionResponse();
-      client._parseMessage(response);
+    (timeSyncId, apiId) => {
+      // Simulate time sync response.
+      const timeResponse = {
+        messageType: fakeData.Container.Type.eTimeResponse,
+        timeResponse: { requestId: timeSyncId, timestamp: Date.now() * 1e6 }
+      };
+      client._parseMessage(timeResponse);
+      // Simulate API version response.
+      const apiResponse = fakeData.createApiVersionResponse(apiId);
+      client._parseMessage(apiResponse);
     }
   );
 
   await runThrough(
     "requestLogLimits",
     () => client.requestLogLimits(),
-    () => {
-      const response = fakeData.createLogLimitsResponse();
-      client._parseMessage(response);
+    (timeSyncId, apiId) => {
+      const timeResponse = {
+        messageType: fakeData.Container.Type.eTimeResponse,
+        timeResponse: { requestId: timeSyncId, timestamp: Date.now() * 1e6 }
+      };
+      client._parseMessage(timeResponse);
+      const apiResponse = fakeData.createLogLimitsResponse(apiId);
+      client._parseMessage(apiResponse);
     }
   );
 
   await runThrough(
     "requestLoggedNodes",
     () => client.requestLoggedNodes(),
-    () => {
-      const response = fakeData.createLoggedNodesResponse(1);
-      client._parseMessage(response);
+    (timeSyncId, apiId) => {
+      const timeResponse = {
+        messageType: fakeData.Container.Type.eTimeResponse,
+        timeResponse: { requestId: timeSyncId, timestamp: Date.now() * 1e6 }
+      };
+      client._parseMessage(timeResponse);
+      const apiResponse = fakeData.createLoggedNodesResponse(apiId);
+      client._parseMessage(apiResponse);
     }
   );
 
+  // Ensure that the node mapping includes "CPULoad" before calling requestDataPoints.
+  if (!("CPULoad" in client.nameToId)) {
+    console.log("Mapping missing CPULoad. Simulating logged nodes response to update mapping.");
+    client._parseMessage(fakeData.createLoggedNodesResponse(999));
+  }
+
   await runThrough(
     "requestDataPoints",
     () => client.requestDataPoints(["Output", "CPULoad"], 1531313250.0, 1531461231.0, 500),
-    () => {
-      const response = fakeData.createDataPointResponse();
-      client._parseMessage(response);
+    (timeSyncId, apiId) => {
+      const timeResponse = {
+        messageType: fakeData.Container.Type.eTimeResponse,
+        timeResponse: { requestId: timeSyncId, timestamp: Date.now() * 1e6 }
+      };
+      client._parseMessage(timeResponse);
+      const apiResponse = fakeData.createDataPointResponse(apiId);
+      client._parseMessage(apiResponse);
     }
   );
+
+  // Disconnect the client to close the open WebSocket and allow the process to exit.
+  client.disconnect();
 }
 
 let client;