@matter-server/ws-controller 0.3.6 → 0.3.7

package/src/server/Converters.ts

@@ -167,9 +167,73 @@ export function convertCommandDataToMatter(
     return convertWebSocketGenericToMatter(value, model, clusterModel);
 }
 
+/**
+ * Model conversion kinds, classified once per ValueModel and cached for fast dispatch.
+ */
+const enum ConvKind {
+    Passthrough,
+    EpochS,
+    EpochUS,
+    Bytes,
+    Bitmap,
+    Struct,
+    List,
+}
+
+/** Cached model-to-kind classification. Avoids repeated metabase property traversal. */
+const modelKindCache = new WeakMap<ValueModel, ConvKind>();
+
+/** Precomputed struct member info: avoids camelize() on every conversion. */
+type StructMemberEntry = { readonly name: string; readonly id: number; readonly model: ValueModel };
+const structMemberCache = new WeakMap<ValueModel, StructMemberEntry[]>();
+
+function classifyModel(model: ValueModel): ConvKind {
+    let kind = modelKindCache.get(model);
+    if (kind !== undefined) return kind;
+
+    if (model.type === "list") {
+        kind = ConvKind.List;
+    } else if (model.metabase?.name === "struct") {
+        kind = ConvKind.Struct;
+    } else if (model.metabase?.metatype === "bitmap") {
+        kind = ConvKind.Bitmap;
+    } else if (model.metabase?.metatype === "bytes") {
+        kind = ConvKind.Bytes;
+    } else if (model.metabase?.metatype === "integer") {
+        kind =
+            model.type === "epoch-s"
+                ? ConvKind.EpochS
+                : model.type === "epoch-us"
+                  ? ConvKind.EpochUS
+                  : ConvKind.Passthrough;
+    } else {
+        kind = ConvKind.Passthrough;
+    }
+
+    modelKindCache.set(model, kind);
+    return kind;
+}
+
+function getStructMembers(model: ValueModel): StructMemberEntry[] {
+    let members = structMemberCache.get(model);
+    if (members !== undefined) return members;
+
+    members = [];
+    for (const member of model.members) {
+        if (member.name !== undefined && member.id !== undefined) {
+            members.push({ name: camelize(member.name), id: member.id, model: member });
+        }
+    }
+    structMemberCache.set(model, members);
+    return members;
+}
+
 /**
  * Uses the matter.js Model to convert the response data for read, subscribe and invoke into a tag-based response
  * including conversion of data types.
+ *
+ * Model classification and struct member info are cached in WeakMaps so that repeated calls
+ * for the same model (e.g. across 160 nodes with identical clusters) skip the metabase traversal.
  */
 export function convertMatterToWebSocketTagBased(
     value: unknown,
@@ -180,34 +244,50 @@ export function convertMatterToWebSocketTagBased(
         return null;
     }
     if (model === undefined) {
-        // Do some simple conversions when we have unknown attributes
+        // Unknown attributes: simple type conversions only
         if (Bytes.isBytes(value)) {
-            return `${Bytes.toBase64(value)}`;
+            return Bytes.toBase64(value);
         }
         if (isObject(value) || !["string", "number", "bigint", "boolean", "undefined"].includes(typeof value)) {
-            return null; // We cannot convert this
+            return null;
         }
-
         return value;
     }
-    if (Array.isArray(value) && model.type === "list") {
-        return value.map(v => convertMatterToWebSocketTagBased(v, model.members[0], clusterModel));
-    }
-    if (isObject(value) && model.metabase?.name === "struct") {
-        const valueKeys = Object.keys(value);
-        const result: { [key: string]: any } = {};
-        for (const member of model.members) {
-            const name = camelize(member.name);
-            if (member.name !== undefined && member.id !== undefined && valueKeys.includes(name)) {
-                result[member.id] = convertMatterToWebSocketTagBased(value[name], member, clusterModel);
+
+    switch (classifyModel(model)) {
+        case ConvKind.Passthrough:
+            return value;
+
+        case ConvKind.EpochS:
+            return typeof value === "number" ? value - MATTER_EPOCH_OFFSET_S : value;
+
+        case ConvKind.EpochUS:
+            return typeof value === "number" || typeof value === "bigint"
+                ? BigInt(value) - MATTER_EPOCH_OFFSET_US
+                : value;
+
+        case ConvKind.Bytes:
+            return value instanceof Uint8Array ? Bytes.toBase64(value) : value;
+
+        case ConvKind.List:
+            return Array.isArray(value)
+                ? value.map(v => convertMatterToWebSocketTagBased(v, model.members[0], clusterModel))
+                : value;
+
+        case ConvKind.Struct: {
+            if (!isObject(value)) return value;
+            const result: { [key: string]: any } = {};
+            for (const { name, id, model: memberModel } of getStructMembers(model)) {
+                if (Object.hasOwn(value, name)) {
+                    result[id] = convertMatterToWebSocketTagBased(value[name], memberModel, clusterModel);
+                }
             }
+            return result;
         }
-        return result;
-    }
-    if (isObject(value) && model.metabase?.metatype === "bitmap") {
-        if (clusterModel !== undefined) {
-            let numberValue = 0;
 
+        case ConvKind.Bitmap: {
+            if (!isObject(value) || clusterModel === undefined) return value;
+            let numberValue = 0;
             for (const member of clusterModel.scope.membersOf(model)) {
                 const memberValue =
                     member.name !== undefined && value[camelize(member.name)]
@@ -231,26 +311,9 @@ export function convertMatterToWebSocketTagBased(
                     numberValue |= typeof memberValue === "boolean" ? 1 : memberValue << minBit;
                 }
             }
-
             return numberValue;
         }
     }
-
-    if (value instanceof Uint8Array && model.metabase?.metatype === "bytes") {
-        value = `${Bytes.toBase64(value)}`;
-    }
-
-    if (model.metabase?.metatype === "integer") {
-        // Convert Epoch timestamps to Unix timestamps we use internally
-        if (model.type === "epoch-s" && typeof value === "number") {
-            value -= MATTER_EPOCH_OFFSET_S;
-        } else if (model.type === "epoch-us" && (typeof value === "number" || typeof value === "bigint")) {
-            value = BigInt(value) - MATTER_EPOCH_OFFSET_US;
-        }
-        return value;
-    }
-
-    return value;
 }
 
 /**

package/src/server/WebSocketControllerHandler.ts

@@ -6,7 +6,7 @@
 
 import { camelize, ClusterId, FabricIndex, Logger, LogLevel, Millis, NodeId, ObserverGroup } from "@matter/main";
 import { ControllerCommissioningFlowOptions } from "@matter/main/protocol";
-import { EndpointNumber, getClusterById, QrPairingCodeCodec } from "@matter/main/types";
+import { EndpointNumber, QrPairingCodeCodec } from "@matter/main/types";
 import { NodeStates } from "@project-chip/matter.js/device";
 import { WebSocketServer } from "ws";
 import { ControllerCommandHandler } from "../controller/ControllerCommandHandler.js";
@@ -138,19 +138,19 @@ export class WebSocketControllerHandler implements WebServerHandler {
 
                 switch (eventName) {
                     case "node_added":
-                    case "node_updated":
-                        this.#collectNodeDetails(nodeId).then(
-                            nodeDetails => {
-                                logger.debug(`[${connId}] Sending ${eventName} event for Node ${formatNodeId(nodeId)}`);
-                                ws.send(toBigIntAwareJson({ event: eventName, data: nodeDetails }));
-                            },
-                            err =>
-                                logger.error(
-                                    `[${connId}] Failed to collect node details for Node ${formatNodeId(nodeId)}`,
-                                    err,
-                                ),
-                        );
+                    case "node_updated": {
+                        try {
+                            const nodeDetails = this.#collectNodeDetails(nodeId);
+                            logger.debug(`[${connId}] Sending ${eventName} event for Node ${formatNodeId(nodeId)}`);
+                            ws.send(toBigIntAwareJson({ event: eventName, data: nodeDetails }));
+                        } catch (err) {
+                            logger.error(
+                                `[${connId}] Failed to collect node details for Node ${formatNodeId(nodeId)}`,
+                                err,
+                            );
+                        }
                         break;
+                    }
                     case "node_removed":
                         logger.debug(`[${connId}] Sending node_removed event for Node ${formatNodeId(nodeId)}`);
                         ws.send(toBigIntAwareJson({ event: eventName, data: nodeId }));
@@ -163,8 +163,7 @@ export class WebSocketControllerHandler implements WebServerHandler {
                 if (this.#closed) return;
                 const { endpointId, clusterId, attributeId } = data.path;
                 const pathStr = `${endpointId}/${clusterId}/${attributeId}`;
-                const cluster = getClusterById(clusterId);
-                const clusterData = ClusterMap[cluster.name.toLowerCase()];
+                const clusterData = ClusterMap[clusterId];
                 const value = convertMatterToWebSocketTagBased(
                     data.value,
                     clusterData?.attributes[attributeId],
@@ -321,7 +320,9 @@ export class WebSocketControllerHandler implements WebServerHandler {
             );
         });
 
-        await this.#commandHandler.connect();
+        // Initialize all nodes (populates attribute caches) and start connecting them.
+        // Guarded internally so it runs exactly once even with multiple listen addresses.
+        await this.#commandHandler.initializeNodes();
     }
 
     unregister(): Promise<void> {
@@ -372,7 +373,7 @@ export class WebSocketControllerHandler implements WebServerHandler {
             let enableListeners: boolean | undefined = undefined;
             switch (command) {
                 case "start_listening":
-                    result = await this.#handleStartListening(args);
+                    result = this.#handleStartListening(args);
                     enableListeners = true;
                     break;
                 case "set_default_fabric_label":
@@ -388,7 +389,7 @@ export class WebSocketControllerHandler implements WebServerHandler {
                     result = await this.#handleGetNode(args);
                     break;
                 case "get_nodes":
-                    result = await this.#handleGetNodes(args);
+                    result = this.#handleGetNodes(args);
                     break;
                 case "get_node_ip_addresses":
                     result = await this.#handleGetNodeIpAddresses(args);
@@ -414,7 +415,7 @@ export class WebSocketControllerHandler implements WebServerHandler {
                 case "diagnostics":
                     result = {
                         info: await this.#getServerInfo(),
-                        nodes: await this.#handleGetNodes(args),
+                        nodes: this.#handleGetNodes(args),
                         events: this.getEventHistory(),
                     };
                     break;
@@ -543,8 +544,11 @@ export class WebSocketControllerHandler implements WebServerHandler {
         this.#broadcastEvent("server_info_updated", serverInfo);
     }
 
-    async #handleStartListening(_args: ArgsOf<"start_listening">): Promise<ResponseOf<"start_listening">> {
-        return await this.#handleGetNodes({});
+    #handleStartListening(_args: ArgsOf<"start_listening">): ResponseOf<"start_listening"> {
+        logger.info("WebSocket server start_listening");
+        const data = this.#handleGetNodes({});
+        logger.info("WebSocket server start_listening. Returned", data.length, "nodes");
+        return data;
     }
 
     async #handleSetDefaultFabricLabel(
@@ -592,7 +596,7 @@ export class WebSocketControllerHandler implements WebServerHandler {
             threadCredentials,
         });
 
-        return await this.#collectNodeDetails(nodeId);
+        return this.#collectNodeDetails(nodeId);
     }
 
     async #handleCommissionOnNetwork(
@@ -640,15 +644,15 @@ export class WebSocketControllerHandler implements WebServerHandler {
 
         const { nodeId } = await this.#commandHandler.commissionNode(commissionRequest);
 
-        return await this.#collectNodeDetails(nodeId);
+        return this.#collectNodeDetails(nodeId);
     }
 
-    async #handleGetNodes(args: ArgsOf<"get_nodes">): Promise<ResponseOf<"get_nodes">> {
+    #handleGetNodes(args: ArgsOf<"get_nodes">): ResponseOf<"get_nodes"> {
         const { only_available = false } = args ?? {};
         const nodeDetails = new Array<MatterNode>();
         // Include real nodes
         for (const node of this.#commandHandler.getNodeIds()) {
-            const details = await this.#collectNodeDetails(node);
+            const details = this.#collectNodeDetails(node);
             if (!only_available || details.available) {
                 nodeDetails.push(details);
             }
@@ -673,9 +677,9 @@ export class WebSocketControllerHandler implements WebServerHandler {
 
         // Pass the last interview date for real nodes
         if (handler === this.#commandHandler) {
-            return await this.#commandHandler.getNodeDetails(nodeId, this.#lastInterviewDates.get(nodeId));
+            return this.#commandHandler.getNodeDetails(nodeId, this.#lastInterviewDates.get(nodeId));
         }
-        return await handler.getNodeDetails(nodeId);
+        return handler.getNodeDetails(nodeId);
     }
 
     async #handleGetNodeIpAddresses(
@@ -899,24 +903,25 @@ export class WebSocketControllerHandler implements WebServerHandler {
                 addresses,
                 mrpSessionActiveInterval,
                 mrpSessionIdleInterval,
-            }) => ({
-                instance_name: instanceName,
-                host_name: hostName, // TODO
-                port,
-                long_discriminator: longDiscriminator,
-                vendor_id: vendorId,
-                product_id: productId,
-                commissioning_mode: commissioningMode,
-                device_type: deviceType,
-                device_name: deviceName,
-                pairing_instruction: pairingInstruction,
-                pairing_hint: pairingHint,
-                mrp_retry_interval_idle: mrpSessionIdleInterval,
-                mrp_retry_interval_active: mrpSessionActiveInterval,
-                supports_tcp: supportsTcpServer,
-                addresses,
-                rotating_id: rotatingId,
-            }),
+            }) =>
+                ({
+                    instance_name: instanceName,
+                    host_name: hostName, // TODO
+                    port,
+                    long_discriminator: longDiscriminator,
+                    vendor_id: vendorId,
+                    product_id: productId,
+                    commissioning_mode: commissioningMode,
+                    device_type: deviceType,
+                    device_name: deviceName,
+                    pairing_instruction: pairingInstruction,
+                    pairing_hint: pairingHint,
+                    mrp_retry_interval_idle: mrpSessionIdleInterval,
+                    mrp_retry_interval_active: mrpSessionActiveInterval,
+                    supports_tcp: supportsTcpServer,
+                    addresses,
+                    rotating_id: rotatingId,
+                }),
         );
     }
 
@@ -968,9 +973,9 @@ export class WebSocketControllerHandler implements WebServerHandler {
         return await this.#commandHandler.updateNode(NodeId(node_id), targetVersion);
     }
 
-    async #collectNodeDetails(nodeId: NodeId): Promise<MatterNode> {
+    #collectNodeDetails(nodeId: NodeId): MatterNode {
         const lastInterviewDate = this.#lastInterviewDates.get(nodeId);
-        return await this.#commandHandler.getNodeDetails(nodeId, lastInterviewDate);
+        return this.#commandHandler.getNodeDetails(nodeId, lastInterviewDate);
     }
 
     #convertCommandDataToWebSocketTagBased(
@@ -980,8 +985,7 @@ export class WebSocketControllerHandler implements WebServerHandler {
         clusterData?: ClusterMapEntry,
     ) {
         if (!clusterData) {
-            const cluster = getClusterById(clusterId);
-            clusterData = clusterData ?? ClusterMap[cluster.name.toLowerCase()];
+            clusterData = ClusterMap[clusterId];
         }
 
         if (clusterData === undefined || clusterData.commands[commandName.toLowerCase()] === undefined) {