@matter/node 0.15.2-alpha.0-20250717-3607eeac6 → 0.15.2-alpha.0-20250718-7e661c331

package/src/storage/client/RemoteWriter.ts

@@ -0,0 +1,81 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { InternalError } from "#general";
+import { ClientStructure } from "#node/client/ClientStructure.js";
+import type { ClientNode } from "#node/ClientNode.js";
+import { Write, WriteResult, type Val } from "#protocol";
+import type { ClusterId, ClusterType, EndpointNumber } from "#types";
+import type { ClientNodeStore } from "./ClientNodeStore.js";
+
+/**
+ * Persistence handler for {@link ClientNodeStore}.
+ *
+ * A remote writer conveys updates to the remote node.  This performs actual persistence for client nodes where the
+ * local store is just a cache and the source of truth is on the remote device.
+ */
+export interface RemoteWriter {
+    (request: RemoteWriter.Request): Promise<void>;
+}
+
+const attrCache = new WeakMap<ClusterType, Record<string, ClusterType.Attribute>>();
+
+export function RemoteWriter(node: ClientNode, structure: ClientStructure): RemoteWriter {
+    return async function writeRemote(request: RemoteWriter.Request) {
+        const attrWrites = Array<Write.Attribute>();
+        for (const { number, behaviorId, values } of request) {
+            const cluster = structure.clusterFor(number, Number.parseInt(behaviorId) as ClusterId);
+            if (cluster === undefined) {
+                throw new InternalError(`Cannot remote write to non-cluster behavior ${behaviorId}`);
+            }
+            const attrs = attrsFor(cluster);
+
+            for (const id in values) {
+                const attr = attrs[id];
+                if (attr === undefined) {
+                    if (id.startsWith("__")) {
+                        continue;
+                    }
+
+                    throw new InternalError(`Cannot write unknown attribute ${id} for ${behaviorId}`);
+                }
+
+                attrWrites.push(
+                    Write.Attribute({
+                        endpoint: number,
+                        cluster,
+                        attributes: [attrs[id]],
+                        value: values[id],
+                    }),
+                );
+            }
+        }
+
+        const write = Write(...attrWrites);
+        const response = await node.interaction.write(write);
+        WriteResult.assertSuccess(response);
+    };
+}
+
+export namespace RemoteWriter {
+    export interface EndpointUpdateRequest {
+        number: EndpointNumber;
+        behaviorId: string;
+        values: Val.Struct;
+    }
+
+    export interface Request extends Array<EndpointUpdateRequest> {}
+}
+
+function attrsFor(cluster: ClusterType) {
+    let attrs = attrCache.get(cluster);
+    if (attrs) {
+        return attrs;
+    }
+    attrs = Object.fromEntries(Object.values(cluster.attributes).map(attr => [attr.id, attr]));
+    attrCache.set(cluster, attrs);
+    return attrs;
+}

package/src/storage/server/DatasourceStore.ts

@@ -67,8 +67,7 @@ function participantFor(transaction: Transaction, endpointStore: EndpointStore)
         },
 
         commit1(): MaybePromise {
-            // Persistence serves phase one commit; values are added directly to
-            // the journal so nothing necessary here
+            // Persistence serves phase one commit; values are added directly to the journal so nothing necessary here
         },
 
         async commit2() {
@@ -86,7 +85,3 @@ function participantFor(transaction: Transaction, endpointStore: EndpointStore)
 
     return participant;
 }
-
-export namespace DatasourceStore {
-    export type Type = typeof DatasourceStore;
-}

package/src/storage/server/ServerEndpointStore.ts

@@ -7,6 +7,7 @@
 import { Endpoint } from "#endpoint/Endpoint.js";
 import { ImplementationError, StorageContext } from "#general";
 import { EndpointStore } from "#storage/EndpointStore.js";
+import { DatasourceStore } from "./DatasourceStore.js";
 
 const NUMBER_KEY = "__number__";
 
@@ -37,6 +38,14 @@ export class ServerEndpointStore extends EndpointStore {
         this.#childStorage = storage.createContext("parts");
     }
 
+    /**
+     * Create a {@link Datasource.Store} for a behavior.
+     */
+    createStoreForBehavior(behaviorId: string) {
+        const initialValues = this.consumeInitialValues(behaviorId);
+        return DatasourceStore(this, behaviorId, initialValues);
+    }
+
     /**
      * Invoke a function on this store and the stores of descendant parts.
      */

package/src/storage/server/ServerNodeStore.ts

@@ -15,6 +15,7 @@ import {
     StorageManager,
     StorageService,
 } from "#general";
+import type { ServerNode } from "#node/ServerNode.js";
 import { NodeStore } from "../NodeStore.js";
 import { ClientNodeStores } from "../client/ClientNodeStores.js";
 import { ServerEndpointStores } from "./ServerEndpointStores.js";
@@ -22,8 +23,9 @@ import { ServerEndpointStores } from "./ServerEndpointStores.js";
 const logger = Logger.get("ServerNodeStore");
 
 /**
- * The "server" node store is a {@link NodeStore} with storage for components shared by the server node and client
- * nodes.
+ * {@link ServerNode} persistence.
+ *
+ * Each {@link ServerNode} has an instance of this store.
  */
 export class ServerNodeStore extends NodeStore implements Destructable {
     #env: Environment;