@matter/node 0.16.0-alpha.0-20251110-c4c70a41b → 0.16.0-alpha.0-20251111-11cc8c3bd

package/src/node/client/ClientStructureEvents.ts

@@ -9,22 +9,27 @@ import { ClusterBehavior } from "#behavior/cluster/ClusterBehavior.js";
 import { DescriptorClient } from "#behaviors/descriptor";
 import { Endpoint } from "#endpoint/Endpoint.js";
 import { EndpointType } from "#endpoint/type/EndpointType.js";
-import { Environment, Environmental, Observable } from "#general";
+import { Environment, Environmental, Logger, Observable } from "#general";
 import { DeviceTypeId } from "#types";
 
+const logger = Logger.get("ClientStructureEvents");
+
 /**
  * An environmental service that manages events endpoint and behavior types.
  */
 export class ClientStructureEvents {
-    #endpointEvents?: Map<DeviceTypeId, Observable<[Endpoint]>>;
+    #endpointEvents?: Map<DeviceTypeId, Observable<[endpoint: Endpoint]>>;
     #clusterEvents?: Map<
         string,
         Array<{
             requestedType: Behavior.Type;
-            event: Observable<[Endpoint, Behavior.Type]>;
+            event: Observable<[endpoint: Endpoint, type: ClusterBehavior.Type]>;
         }>
     >;
 
+    #clusterReplaced?: Observable<[endpoint: Endpoint, type: ClusterBehavior.Type]>;
+    #clusterDeleted?: Observable<[endpoint: Endpoint, type: ClusterBehavior.Type]>;
+
     static [Environmental.create](env: Environment) {
         const instance = new ClientStructureEvents();
         env.set(ClientStructureEvents, instance);
@@ -38,7 +43,7 @@ export class ClientStructureEvents {
 
         let event = this.#endpointEvents.get(type.deviceType);
         if (event === undefined) {
-            this.#endpointEvents.set(type.deviceType, (event = Observable()));
+            this.#endpointEvents.set(type.deviceType, (event = this.#createEvent("endpointInstalled")));
         }
 
         return event as Observable<[endpoint: Endpoint<T>]>;
@@ -60,12 +65,26 @@ export class ClientStructureEvents {
             }
         }
 
-        const event = Observable();
+        const event = this.#createEvent("clusterInstalled");
         events.push({ requestedType: type, event });
 
         return event;
     }
 
+    get clusterReplaced() {
+        if (this.#clusterReplaced) {
+            return this.#clusterReplaced;
+        }
+        return (this.#clusterReplaced = this.#createEvent("clusterReplaced"));
+    }
+
+    get clusterDeleted() {
+        if (this.#clusterDeleted) {
+            return this.#clusterDeleted;
+        }
+        return (this.#clusterDeleted = this.#createEvent("clusterDeleted"));
+    }
+
     emitEndpoint(endpoint: Endpoint) {
         if (this.#endpointEvents && endpoint.behaviors.supported.descriptor) {
             const deviceTypes = endpoint.stateOf(DescriptorClient).deviceTypeList;
@@ -75,7 +94,11 @@ export class ClientStructureEvents {
         }
 
         for (const type of Object.values(endpoint.behaviors.supported)) {
-            this.emitCluster(endpoint, type);
+            if (!("cluster" in type)) {
+                continue;
+            }
+
+            this.emitCluster(endpoint, type as ClusterBehavior.Type);
         }
 
         for (const part of endpoint.parts) {
@@ -83,15 +106,40 @@ export class ClientStructureEvents {
         }
     }
 
-    emitCluster(endpoint: Endpoint, type: Behavior.Type) {
+    emitCluster(endpoint: Endpoint, type: ClusterBehavior.Type) {
         const events = this.#clusterEvents?.get(type.id);
         if (!events) {
             return;
         }
+
         for (const { requestedType, event } of events) {
             if (type.supports(requestedType)) {
                 event.emit(endpoint, type);
             }
         }
     }
+
+    emitClusterReplaced(endpoint: Endpoint, type: ClusterBehavior.Type) {
+        if (!this.#clusterReplaced) {
+            return;
+        }
+
+        this.#clusterReplaced.emit(endpoint, type);
+    }
+
+    emitClusterDeleted(endpoint: Endpoint, type: ClusterBehavior.Type) {
+        if (!this.#clusterDeleted) {
+            return;
+        }
+
+        this.#clusterDeleted.emit(endpoint, type);
+    }
+
+    #createEvent(kind: string): Observable<any, void> {
+        return Observable(unhandledError);
+
+        function unhandledError(e: unknown) {
+            logger.error(`Unhandled error in client structure ${kind} event handler:`, e);
+        }
+    }
 }

package/src/node/client/Peers.ts

@@ -131,6 +131,10 @@ export class Peers extends EndpointContainer<ClientNode> {
         return this.owner.env.get(ClientStructureEvents).clusterInstalled(type);
     }
 
+    /**
+     * Emits when fixed attributes
+     */
+
     override get(id: number | string | PeerAddress) {
         if (typeof id !== "string" && typeof id !== "number") {
             const address = PeerAddress(id);

package/src/node/server/ServerEndpointInitializer.ts

@@ -32,7 +32,7 @@ export class ServerEndpointInitializer extends EndpointInitializer {
 
         // DescriptorServer is mandatory but we don't include it in generated device types
         if (!(DescriptorServer.id in endpoint.behaviors.supported)) {
-            endpoint.behaviors.inject(DescriptorServer);
+            endpoint.behaviors.inject(DescriptorServer, undefined, false);
         }
     }
 

package/src/storage/EndpointStore.ts

@@ -115,12 +115,19 @@ export class EndpointStore {
     }
 
     /**
-     * Remove all persisted information for the {@link Endpoint}
+     * Remove all persisted information for the {@link Endpoint}.
      */
     erase() {
         return this.storage.clearAll();
     }
 
+    /**
+     * Remove all persisted information for a single behavior on the {@link Endpoint}.
+     */
+    eraseStoreForBehavior(behaviorId: string) {
+        return this.storage.createContext(behaviorId).clearAll();
+    }
+
     protected get storage() {
         return this.#storage;
     }

package/src/storage/client/DatasourceCache.ts

@@ -5,21 +5,33 @@
  */
 
 import { Datasource } from "#behavior/state/managed/Datasource.js";
-import { InternalError, Transaction } from "#general";
+import { InternalError, MaybePromise, Transaction } from "#general";
 import { Val } from "#protocol";
 import type { ClientEndpointStore } from "./ClientEndpointStore.js";
 import type { RemoteWriteParticipant } from "./RemoteWriteParticipant.js";
 
 /**
- * Factory function for the default implementation of {@link Datasource.ExternallyMutableStore}.
+ * The default implementation of {@link Datasource.ExternallyMutableStore}.
  *
- * This implements storage for attribute values for a single cluster loaded from remote nodes.
+ * This implements storage for attribute values for a single cluster loaded from peers.
  */
+export interface DatasourceCache extends Datasource.ExternallyMutableStore {
+    /**
+     * Reset the cache to "uninitialized" state by reclaiming {@link initialValues} from an active datasource.
+     */
+    reclaimValues(): void;
+
+    /**
+     * Erase values just for this datasource.
+     */
+    erase(): MaybePromise<void>;
+}
+
 export function DatasourceCache(
     store: ClientEndpointStore,
     behaviorId: string,
     initialValues: Val.Struct | undefined,
-): Datasource.ExternallyMutableStore {
+): DatasourceCache {
     let version = initialValues?.[DatasourceCache.VERSION_KEY] as number;
     if (typeof version !== "number") {
         version = Datasource.UNKNOWN_VERSION;
@@ -51,6 +63,14 @@ export function DatasourceCache(
         },
 
         externalChangeListener: undefined,
+        releaseValues: undefined,
+
+        reclaimValues() {
+            if (this.releaseValues) {
+                this.initialValues = this.releaseValues();
+                this.releaseValues = undefined;
+            }
+        },
 
         get version() {
             return version;
@@ -59,6 +79,10 @@ export function DatasourceCache(
         set version(_version: number) {
             throw new InternalError("Datasource version must be set via externalSet");
         },
+
+        async erase() {
+            await store.eraseStoreForBehavior(behaviorId);
+        },
     };
 }