@project-chip/matter.js 0.15.1 → 0.15.2-alpha.0-20250703-2e16aba2b

package/src/ControllerStore.ts

@@ -0,0 +1,128 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+    Construction,
+    Destructable,
+    Diagnostic,
+    Environment,
+    ImplementationError,
+    Logger,
+    MaybePromise,
+    StorageContext,
+    StorageManager,
+    StorageService,
+    asyncNew,
+} from "#general";
+
+const logger = Logger.get("ControllerStore");
+
+/**
+ * Non-volatile state management for a {@link ControllerNode}.
+ */
+export class ControllerStore implements Destructable, ControllerStoreInterface {
+    #location: string;
+    #nodeId: string;
+    #storageManager?: StorageManager;
+    #sessionStorage?: StorageContext;
+    #caStorage?: StorageContext; // Root certificate and Fabric
+    #nodesStorage?: StorageContext; // Holds list of nodes in root level and then sub levels with data per client node?
+    #construction: Construction<ControllerStore>;
+
+    get construction() {
+        return this.#construction;
+    }
+
+    /**
+     * Create a new store.
+     *
+     * TODO - implement conversion from 0.7 format so people can change API seamlessly
+     */
+    constructor(nodeId: string, environment: Environment) {
+        if (nodeId === undefined) {
+            throw new ImplementationError("ServerStore must be created with a nodeId");
+        }
+
+        const storage = environment.get(StorageService);
+        this.#location = storage.location ?? "(unknown location)";
+        this.#nodeId = nodeId;
+
+        const initializeStorage = async () => {
+            this.#storageManager = await storage.open(nodeId);
+
+            this.#logChange("Opened");
+        };
+
+        this.#construction = Construction(this, initializeStorage);
+    }
+
+    static async create(nodeId: string, environment = Environment.default) {
+        return await asyncNew(this, nodeId, environment);
+    }
+
+    async erase() {
+        await this.#sessionStorage?.clearAll();
+        await this.#caStorage?.clearAll();
+        await this.#nodesStorage?.clearAll();
+    }
+
+    async close() {
+        await this.#construction.close(async () => {
+            await this.#storageManager?.close();
+            this.#logChange("Closed");
+        });
+    }
+
+    get sessionStorage() {
+        if (!this.#sessionStorage) {
+            this.#sessionStorage = this.storage.createContext("sessions");
+        }
+        return this.#sessionStorage;
+    }
+
+    get caStorage() {
+        if (!this.#caStorage) {
+            this.#caStorage = this.storage.createContext("credentials");
+        }
+        return this.#caStorage;
+    }
+
+    get nodesStorage() {
+        if (this.#nodesStorage === undefined) {
+            this.#nodesStorage = this.storage.createContext("nodes");
+        }
+        return this.#nodesStorage;
+    }
+
+    get fabricStorage() {
+        return this.caStorage;
+    }
+
+    get storage() {
+        if (this.#storageManager === undefined) {
+            throw new ImplementationError("Node storage accessed prior to initialization");
+        }
+        return this.#storageManager;
+    }
+
+    async clientNodeStore(nodeId: string) {
+        return this.storage.createContext(`node-${nodeId}`);
+    }
+
+    #logChange(what: "Opened" | "Closed") {
+        logger.info(what, Diagnostic.strong(this.#nodeId ?? "node"), "storage at", `${this.#location}/${this.#nodeId}`);
+    }
+}
+
+export abstract class ControllerStoreInterface {
+    abstract erase(): Promise<void>;
+    abstract close(): Promise<void>;
+    abstract get sessionStorage(): StorageContext;
+    abstract get caStorage(): StorageContext;
+    abstract get nodesStorage(): StorageContext;
+    abstract get fabricStorage(): StorageContext;
+    abstract clientNodeStore(nodeId: string): MaybePromise<StorageContext>;
+}

package/src/LegacyControllerStore.ts

@@ -5,7 +5,7 @@
  */
 
 import { StorageContext } from "#general";
-import { ControllerStoreInterface } from "@matter/node";
+import { ControllerStoreInterface } from "./ControllerStore.js";
 
 /**
  * Non-volatile state management for a {@link ControllerNode}.

package/src/MatterController.ts

@@ -12,6 +12,7 @@
 
 import { GeneralCommissioning } from "#clusters";
 import { NodeCommissioningOptions } from "#CommissioningController.js";
+import { ControllerStoreInterface } from "#ControllerStore.js";
 import { CachedClientNodeStore } from "#device/CachedClientNodeStore.js";
 import { DeviceInformationData } from "#device/DeviceInformation.js";
 import {
@@ -74,7 +75,6 @@ import {
     VendorId,
 } from "#types";
 import { ClassExtends } from "@matter/general";
-import { ControllerStoreInterface } from "@matter/node";
 import { ControllerCommissioningFlow, MessageChannel } from "@matter/protocol";
 
 export type CommissionedNodeDetails = {

package/src/device/ClientEndpointStore.ts

@@ -5,7 +5,7 @@
  */
 
 import { Construction, isDeepEqual, StorageContext } from "#general";
-import { EndpointStore } from "#node";
+import { ServerEndpointStore } from "#node";
 import { Val } from "@matter/protocol";
 
 /**
@@ -13,16 +13,17 @@ import { Val } from "@matter/protocol";
  * Most methods from EndpointStore are not meant to be used in this class. Please just use "get" and "set".
  * This class is supposed to be used in legacy code paths for Controller usage.
  */
-export class ClientEndpointStore extends EndpointStore {
-    readonly #construction: Construction<EndpointStore>;
+export class ClientEndpointStore extends ServerEndpointStore {
+    readonly #construction: Construction<ServerEndpointStore>;
     #values: Record<string, Val.Struct> = {};
 
     constructor(storage: StorageContext, load = true) {
-        super(storage, load);
+        super(storage);
 
         this.#construction = Construction(this, async () => {
-            await super.construction;
             if (load) {
+                await this.load();
+
                 // Copy over initial values from the superclass
                 this.#values = this.initialValues;
                 this.initialValues = {};
@@ -30,7 +31,7 @@ export class ClientEndpointStore extends EndpointStore {
         });
     }
 
-    override get construction() {
+    get construction() {
         return this.#construction;
     }
 

package/src/device/Endpoint.ts

@@ -313,23 +313,6 @@ export class Endpoint {
         return Array.from(this.clusterClients.values());
     }
 
-    updatePartsList() {
-        const newPartsList = new Array<EndpointNumber>();
-
-        for (const child of this.childEndpoints) {
-            const childPartsList = child.updatePartsList();
-
-            if (child.number === undefined) {
-                throw new InternalError(`Child endpoint has no id, cannot add to parts list`);
-            }
-
-            newPartsList.push(EndpointNumber(child.number));
-            newPartsList.push(...childPartsList);
-        }
-
-        return newPartsList;
-    }
-
     /**
      * Hierarchical diagnostics of endpoint and children.
      */

package/src/export.ts

@@ -5,4 +5,5 @@
  */
 
 export * from "./CommissioningController.js";
+export * from "./ControllerStore.js";
 export * from "./PaseCommissioner.js";