@matter/nodejs 0.11.0-alpha.0-20241005-e3e4e4a7a

package/src/storage/StorageBackendDisk.ts

@@ -0,0 +1,132 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { fromJson, StorageError, SupportedStorageTypes, SyncStorage, toJson } from "#general";
+import { LocalStorage } from "node-localstorage";
+
+export class StorageBackendDisk extends SyncStorage {
+    private readonly localStorage;
+    protected isInitialized = false;
+
+    constructor(path: string, clear = false) {
+        super();
+        this.localStorage = new LocalStorage(path);
+        if (clear) this.clear();
+    }
+
+    get initialized() {
+        return this.isInitialized;
+    }
+
+    initialize() {
+        this.isInitialized = true;
+    }
+
+    close() {
+        this.isInitialized = false;
+    }
+
+    clear() {
+        this.localStorage.clear();
+    }
+
+    getContextBaseKey(contexts: string[], allowEmptyContext = false) {
+        const contextKey = contexts.join(".");
+        if (
+            (!contextKey.length && !allowEmptyContext) ||
+            contextKey.includes("..") ||
+            contextKey.startsWith(".") ||
+            contextKey.endsWith(".")
+        )
+            throw new StorageError("Context must not be an empty and not contain dots.");
+        return contextKey;
+    }
+
+    buildStorageKey(contexts: string[], key: string) {
+        if (!key.length) {
+            throw new StorageError("Key must not be an empty string.");
+        }
+        const contextKey = this.getContextBaseKey(contexts);
+        return `${contextKey}.${key}`;
+    }
+
+    get<T extends SupportedStorageTypes>(contexts: string[], key: string): T | undefined {
+        const value = this.localStorage.getItem(this.buildStorageKey(contexts, key));
+        if (value === null) return undefined;
+        return fromJson(value) as T;
+    }
+
+    set(contexts: string[], key: string, value: SupportedStorageTypes): void;
+    set(contexts: string[], values: Record<string, SupportedStorageTypes>): void;
+    set(
+        contexts: string[],
+        keyOrValues: string | Record<string, SupportedStorageTypes>,
+        value?: SupportedStorageTypes,
+    ) {
+        if (typeof keyOrValues === "string") {
+            this.localStorage.setItem(this.buildStorageKey(contexts, keyOrValues), toJson(value));
+        } else {
+            for (const [key, value] of Object.entries(keyOrValues)) {
+                this.localStorage.setItem(this.buildStorageKey(contexts, key), toJson(value));
+            }
+        }
+    }
+
+    delete(contexts: string[], key: string) {
+        this.localStorage.removeItem(this.buildStorageKey(contexts, key));
+    }
+
+    /** Returns all keys of a storage context without keys of sub-contexts */
+    keys(contexts: string[]) {
+        const contextKey = this.getContextBaseKey(contexts);
+        const keys = [];
+        const contextKeyStart = `${contextKey}.`;
+        const len = contextKeyStart.length;
+        for (const key of Object.keys(this.localStorage)) {
+            if (key.startsWith(contextKeyStart) && !key.includes(".", len)) {
+                keys.push(key.substring(len));
+            }
+        }
+        return keys;
+    }
+
+    values(contexts: string[]) {
+        // Initialize and context checks are done by keys method
+        const values = {} as Record<string, SupportedStorageTypes>;
+        for (const key of this.keys(contexts)) {
+            values[key] = this.get(contexts, key);
+        }
+        return values;
+    }
+
+    contexts(contexts: string[]) {
+        const contextKey = this.getContextBaseKey(contexts, true);
+        const startContextKey = contextKey.length ? `${contextKey}.` : "";
+        const len = startContextKey.length;
+        const foundContexts = new Array<string>();
+        for (const key of Object.keys(this.localStorage)) {
+            if (key.startsWith(startContextKey)) {
+                const subKeys = key.substring(len).split(".");
+                if (subKeys.length === 1) continue; // found leaf key
+                const context = subKeys[0];
+                if (!foundContexts.includes(context)) {
+                    foundContexts.push(context);
+                }
+            }
+        }
+        return foundContexts;
+    }
+
+    clearAll(contexts: string[]) {
+        const contextKey = this.getContextBaseKey(contexts, true);
+        const startContextKey = contextKey.length ? `${contextKey}.` : "";
+        for (const key of Object.keys(this.localStorage)) {
+            if (key.startsWith(startContextKey)) {
+                this.localStorage.removeItem(key);
+            }
+        }
+    }
+}

package/src/storage/StorageBackendJsonFile.ts

@@ -0,0 +1,102 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { fromJson, StorageBackendMemory, StorageError, SupportedStorageTypes, Time, toJson } from "#general";
+import { readFile, writeFile } from "fs/promises";
+
+export class StorageBackendJsonFile extends StorageBackendMemory {
+    /** We store changes after a value was set to the storage, but not more often than this setting (in ms). */
+    static commitDelay = 1000;
+    committed = Promise.resolve();
+
+    private readonly commitTimer = Time.getTimer("Storage commit", StorageBackendJsonFile.commitDelay, () =>
+        this.commit(),
+    );
+    private closed = false;
+    private resolveCommitted?: () => void;
+
+    constructor(private readonly path: string) {
+        super();
+    }
+
+    static override async create(path: string) {
+        const storage = new this(path);
+        await storage.initialize();
+        return storage;
+    }
+
+    override async initialize() {
+        if (this.initialized) throw new StorageError("Storage already initialized!");
+        super.initialize();
+        try {
+            this.store = this.fromJson(await readFile(this.path, "utf-8"));
+        } catch (error: any) {
+            // We accept that the file does not exist yet to initialize with an empty store.
+            if (error.code !== "ENOENT") {
+                throw error;
+            }
+        }
+        this.isInitialized = true;
+    }
+
+    private triggerCommit() {
+        if (!this.commitTimer.isRunning) {
+            this.committed = new Promise(resolve => {
+                this.resolveCommitted = resolve;
+            });
+            this.commitTimer.start();
+        }
+    }
+
+    override set(
+        contexts: string[],
+        keyOrValues: string | Record<string, SupportedStorageTypes>,
+        value?: SupportedStorageTypes,
+    ): void {
+        super.set(contexts, keyOrValues, value);
+        this.triggerCommit();
+    }
+
+    override delete(contexts: string[], key: string): void {
+        super.delete(contexts, key);
+        this.triggerCommit();
+    }
+
+    override clear(): void {
+        super.clear();
+        this.triggerCommit();
+    }
+
+    private async commit() {
+        if (!this.initialized || this.closed) return;
+        if (this.commitTimer.isRunning) {
+            this.commitTimer.stop();
+        }
+        try {
+            await writeFile(this.path, this.toJson(this.store), "utf-8");
+        } finally {
+            if (this.resolveCommitted !== undefined) {
+                this.resolveCommitted?.();
+            }
+        }
+    }
+
+    override async close() {
+        this.commitTimer.stop();
+        await this.commit();
+        super.close();
+        this.closed = true;
+        this.isInitialized = false;
+    }
+
+    private toJson(object: any): string {
+        return toJson(object, 1);
+    }
+
+    private fromJson(json: string): any {
+        return fromJson(json);
+    }
+}

package/src/storage/index.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export * from "./StorageBackendDisk.js";
+export * from "./StorageBackendJsonFile.js";

package/src/tsconfig.json

@@ -0,0 +1,28 @@
+{
+    "extends": "../../tools/tsc/tsconfig.lib.json",
+    "compilerOptions": {
+        "types": [
+            "node"
+        ]
+    },
+    "references": [
+        {
+            "path": "../../general/src"
+        },
+        {
+            "path": "../../types/src"
+        },
+        {
+            "path": "../../protocol/src"
+        },
+        {
+            "path": "../../node/src"
+        },
+        {
+            "path": "../../matter.js/src"
+        },
+        {
+            "path": "../../model/src"
+        }
+    ]
+}