ocpp-ws-io 2.1.4 → 2.1.6

package/dist/index.mjs

@@ -310,9 +310,9 @@ var RedisAdapter = class {
   // Active streams to poll
   _polling = false;
   _closed = false;
-  // C4: Per-stream sequence counter for message ordering
+  // Per-stream sequence counter for message ordering
   _sequenceCounters = /* @__PURE__ */ new Map();
-  // C3: Rehydration callbacks
+  // Rehydration callbacks
   _unsubError;
   _unsubReconnect;
   // Stored presence entries for rehydration on reconnect
@@ -36919,6 +36919,8 @@ var Validator = class {
   /**
    * Validate a payload against a schema identified by its $id.
    * Throws a typed RPCError if validation fails.
+   *
+   * E2: Schema is compiled on first call to this method (lazy).
    */
   validate(schemaId, params) {
     const resolvedId = this._normalizeSchemaId(schemaId);
@@ -36941,16 +36943,26 @@ var Validator = class {
     return !!this._ajv.getSchema(this._normalizeSchemaId(schemaId));
   }
 };
+var _validatorRegistry = /* @__PURE__ */ new Map();
 function createValidator(subprotocol, schemas) {
-  return new Validator(subprotocol, schemas);
+  const existing = _validatorRegistry.get(subprotocol);
+  if (existing) return existing;
+  const validator = new Validator(subprotocol, schemas);
+  _validatorRegistry.set(subprotocol, validator);
+  return validator;
 }
 
 // src/standard-validators.ts
-var standardValidators = [
-  createValidator("ocpp1.6", ocpp1_6_default),
-  createValidator("ocpp2.0.1", ocpp2_0_1_default),
-  createValidator("ocpp2.1", ocpp2_1_default)
-];
+var _cached = null;
+function getStandardValidators() {
+  if (_cached) return _cached;
+  _cached = [
+    createValidator("ocpp1.6", ocpp1_6_default),
+    createValidator("ocpp2.0.1", ocpp2_0_1_default),
+    createValidator("ocpp2.1", ocpp2_1_default)
+  ];
+  return _cached;
+}
 
 // src/types.ts
 var ConnectionState = {
@@ -37143,6 +37155,7 @@ var OCPPClient = class _OCPPClient extends EventEmitter {
   _prettify = false;
   constructor(options) {
     super();
+    this.setMaxListeners(0);
     if (!options.identity) {
       throw new Error("identity is required");
     }
@@ -37644,11 +37657,13 @@ var OCPPClient = class _OCPPClient extends EventEmitter {
     this._recordActivity();
     let message;
     try {
-      const str = rawData.toString();
-      message = JSON.parse(str);
+      message = JSON.parse(rawData);
       if (!Array.isArray(message)) throw new Error("Message is not an array");
     } catch (err) {
-      this._onBadMessage(rawData.toString(), err);
+      this._onBadMessage(
+        typeof rawData === "string" ? rawData : rawData.toString(),
+        err
+      );
       return;
     }
     const messageType = message[0];
@@ -37975,10 +37990,14 @@ var OCPPClient = class _OCPPClient extends EventEmitter {
     }
     if (ws.bufferedAmount > _OCPPClient._BACKPRESSURE_THRESHOLD) {
       this._logger?.warn?.("Backpressure \u2014 pausing send", {
+        identity: this._identity,
         bufferedAmount: ws.bufferedAmount,
         threshold: _OCPPClient._BACKPRESSURE_THRESHOLD
       });
-      this.emit("backpressure", { bufferedAmount: ws.bufferedAmount });
+      this.emit("backpressure", {
+        identity: this._identity,
+        bufferedAmount: ws.bufferedAmount
+      });
       let waited = 0;
       const drainCheck = setInterval(() => {
         waited += 50;
@@ -38042,7 +38061,7 @@ var OCPPClient = class _OCPPClient extends EventEmitter {
     if (this._options.strictModeValidators) {
       this._validators = this._options.strictModeValidators;
     } else {
-      this._validators = standardValidators;
+      this._validators = getStandardValidators();
     }
     if (Array.isArray(this._options.strictMode)) {
       this._strictProtocols = this._options.strictMode;
@@ -38598,8 +38617,7 @@ var OCPPServerClient = class extends OCPPClient {
         let pData;
         if (limits.methods) {
           try {
-            const str = data.toString();
-            pData = JSON.parse(str);
+            pData = JSON.parse(data);
             if (Array.isArray(pData) && pData[0] === 2) {
               method = pData[2];
             }
@@ -38726,6 +38744,7 @@ var OCPPServer = class extends EventEmitter3 {
   _sessionTimeoutMs;
   constructor(options = {}) {
     super();
+    this.setMaxListeners(0);
     if (options.strictMode) {
       if (!options.strictModeValidators && !options.protocols?.length) {
         throw new Error(
@@ -38748,7 +38767,10 @@ var OCPPServer = class extends EventEmitter3 {
     this._sessionTimeoutMs = this._options.sessionTtlMs;
     const maxSessions = this._options.maxSessions ?? 5e4;
     this._sessions = new LRUMap(maxSessions);
-    this._wss = new WebSocketServer({ noServer: true });
+    this._wss = new WebSocketServer({
+      noServer: true,
+      maxPayload: this._options.maxPayloadBytes ?? 65536
+    });
     this._gcInterval = setInterval(() => {
       const now = Date.now();
       for (const [identity, session] of this._sessions.entries()) {
@@ -39054,6 +39076,51 @@ var OCPPServer = class extends EventEmitter3 {
     }
     return httpServer;
   }
+  /**
+   * Hot-reloads the TLS certificate on all active HTTPS servers without
+   * dropping any existing WebSocket connections.
+   *
+   * **When to use:** Call this whenever your TLS certificate is renewed —
+   * for example, after a Let's Encrypt auto-renewal (every ~90 days).
+   * Without this, you would need to restart the Node.js process to pick up
+   * the new certificate, disconnecting all connected charging stations.
+   *
+   * **How to use:**
+   * ```ts
+   * server.updateTLS({ cert: newCert, key: newKey });
+   * ```
+   *
+   * **Optional:** Only relevant if you are terminating TLS directly in Node.js
+   * (i.e. `SecurityProfile.TLS_BASIC_AUTH` or `TLS_CLIENT_CERT`). If you are
+   * running behind a reverse proxy (Nginx, AWS ALB, etc.) that handles TLS,
+   * you do not need this method — just rotate the cert on the proxy.
+   *
+   * @throws If the server is not using a TLS Security Profile.
+   */
+  updateTLS(tlsOpts) {
+    const profile = this._options.securityProfile ?? 0 /* NONE */;
+    if (profile !== 2 /* TLS_BASIC_AUTH */ && profile !== 3 /* TLS_CLIENT_CERT */) {
+      throw new Error(
+        "updateTLS() requires a TLS Security Profile (TLS_BASIC_AUTH or TLS_CLIENT_CERT)"
+      );
+    }
+    this._options.tls = { ...this._options.tls, ...tlsOpts };
+    const httpsOptions = {};
+    if (tlsOpts.cert) httpsOptions.cert = tlsOpts.cert;
+    if (tlsOpts.key) httpsOptions.key = tlsOpts.key;
+    if (tlsOpts.ca) httpsOptions.ca = tlsOpts.ca;
+    if (tlsOpts.passphrase) httpsOptions.passphrase = tlsOpts.passphrase;
+    let updated = 0;
+    for (const srv of this._httpServers) {
+      if ("setSecureContext" in srv && typeof srv.setSecureContext === "function") {
+        srv.setSecureContext(httpsOptions);
+        updated++;
+      }
+    }
+    this._logger?.info?.(
+      `TLS context hot-reloaded across ${updated} active server(s)`
+    );
+  }
   // ─── Handle Upgrade ──────────────────────────────────────────
   get handleUpgrade() {
     return (req, socket, head) => {
@@ -39107,6 +39174,12 @@ var OCPPServer = class extends EventEmitter3 {
       }
       if (bucket.tokens < 1) {
         this._logger?.warn?.("Connection rate limit exceeded", { ip });
+        this.emit("securityEvent", {
+          type: "CONNECTION_RATE_LIMIT",
+          ip,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          details: { tokensRemaining: bucket.tokens }
+        });
         abortHandshake(socket, 429, "Too Many Requests");
         return;
       }
@@ -39363,6 +39436,13 @@ var OCPPServer = class extends EventEmitter3 {
         if (ac.signal.aborted) {
           const reason = err instanceof Error ? err.message : "Unknown abort";
           this._logger?.warn?.("Handshake aborted", { identity, reason });
+          this.emit("securityEvent", {
+            type: "UPGRADE_ABORTED",
+            identity,
+            ip: req.socket.remoteAddress,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            details: { reason }
+          });
           this.emit("upgradeAborted", {
             identity,
             reason,
@@ -39376,6 +39456,13 @@ var OCPPServer = class extends EventEmitter3 {
         const code = typeof errObj?.code === "number" ? errObj.code : 401;
         const message = typeof errObj?.message === "string" ? errObj.message : "Unauthorized";
         this._logger?.warn?.("Auth rejected", { identity, code });
+        this.emit("securityEvent", {
+          type: "AUTH_FAILED",
+          identity,
+          ip: req.socket.remoteAddress,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          details: { code, message }
+        });
         abortHandshake(socket, code, message);
         return;
       } finally {
@@ -39399,7 +39486,10 @@ var OCPPServer = class extends EventEmitter3 {
       return;
     }
     if (!this._wss) {
-      this._wss = new WebSocketServer({ noServer: true });
+      this._wss = new WebSocketServer({
+        noServer: true,
+        maxPayload: this._options.maxPayloadBytes ?? 65536
+      });
     }
     this._wss.handleUpgrade(req, socket, head, (ws) => {
       const clientOptions = {
@@ -39786,6 +39876,6 @@ export {
   defineRpcMiddleware,
   getErrorPlainObject,
   getPackageIdent,
-  standardValidators
+  getStandardValidators
 };
 //# sourceMappingURL=index.mjs.map