Automatically initialize node-persist storage (remove requirement to call the hap.init function)

Author: bauer-andreas

@types/node-persist.d.ts

@@ -1,7 +1,14 @@
 declare module 'node-persist' {
 
   export interface InitOptions {
-    dir?: string;
+    dir?: string; // default 'persist'
+    stringify?: typeof JSON.stringify, // default JSON.stringify
+    parse?: typeof JSON.parse, // default JSON.parse
+    encoding?: string, // default 'utf8'
+    logging?: boolean,
+    continuous?: boolean, // default true (instantly persists to disk)
+    interval?: false | number, // milliseconds
+    ttl?: false | true | number, // can be true for 24h default or a number in MILLISECONDS
   }
 
   export class LocalStorage {
@@ -12,6 +19,7 @@ declare module 'node-persist' {
     getItem(key: string): any;
     setItemSync(key: string, value: any): void;
     removeItemSync(key: string): void
+    persistSync(): void;
 
   }
 

__mocks__/node-persist.ts

@@ -3,6 +3,8 @@ class Storage {
   setItemSync = jest.fn();
   persistSync = jest.fn();
   removeItemSync = jest.fn();
+  initSync = jest.fn();
+  create = jest.fn().mockImplementation(() => new Storage());
 }
 
 export default new Storage();

src/index.ts

@@ -1,11 +1,11 @@
 /// <reference path="../@types/bonjour-hap.d.ts" />
 /// <reference path="../@types/node-persist.d.ts" />
-import storage from 'node-persist';
 
 import './lib/gen';
 import * as accessoryLoader from './lib/AccessoryLoader';
 import * as uuidFunctions from './lib/util/uuid';
 import * as legacyTypes from './accessories/types';
+import { HAPStorage } from "./lib/model/HAPStorage";
 
 export const AccessoryLoader = accessoryLoader;
 export const uuid = uuidFunctions;
@@ -31,10 +31,14 @@ export * from './lib/util/tlv';
 export * from './types';
 export const LegacyTypes = legacyTypes;
 
+/**
+ *
+ * @param {string} storagePath
+ * @deprecated the need to manually initialize the internal storage was removed. If you want to set a custom
+ *  storage path location, please use {@link HAPStorage.setCustomStoragePath} directly.
+ */
 export function init(storagePath?: string) {
-  // initialize our underlying storage system, passing on the directory if needed
-  if (typeof storagePath !== 'undefined')
-    storage.initSync({ dir: storagePath });
-  else
-    storage.initSync(); // use whatever is default
+  if (storagePath) {
+    HAPStorage.setCustomStoragePath(storagePath);
+  }
 }

src/lib/model/AccessoryInfo.ts

@@ -1,11 +1,11 @@
-import storage from 'node-persist';
 import util from 'util';
 import assert from 'assert';
 import tweetnacl from 'tweetnacl';
 
 import { Categories } from '../Accessory';
 import { Session } from "../util/eventedhttp";
 import { MacAddress } from "../../types";
+import { HAPStorage } from "./HAPStorage";
 
 export enum PermissionTypes {
   USER = 0x00,
@@ -220,8 +220,7 @@ export class AccessoryInfo {
 
     var key = AccessoryInfo.persistKey(this.username);
 
-    storage.setItemSync(key, saved);
-    storage.persistSync();
+    HAPStorage.storage().setItemSync(key, saved);
   }
 
 // Gets a key for storing this AccessoryInfo in the filesystem, like "AccessoryInfo.CC223DE3CEF3.json"
@@ -246,7 +245,7 @@ export class AccessoryInfo {
     AccessoryInfo.assertValidUsername(username);
 
     var key = AccessoryInfo.persistKey(username);
-    var saved = storage.getItem(key);
+    var saved = HAPStorage.storage().getItem(key);
 
     if (saved) {
       var info = new AccessoryInfo(username);
@@ -293,7 +292,7 @@ export class AccessoryInfo {
 
   static remove(username: MacAddress) {
     const key = AccessoryInfo.persistKey(username);
-    storage.removeItemSync(key);
+    HAPStorage.storage().removeItemSync(key);
   }
 
   static assertValidUsername = (username: MacAddress) => {

src/lib/model/ControllerStorage.ts

@@ -1,9 +1,9 @@
-import storage from 'node-persist';
 import {MacAddress} from "../../types";
 import util from "util";
 import createDebug from "debug";
 import {ControllerType, SerializableController} from "../controller";
 import {Accessory} from "../Accessory";
+import { HAPStorage } from "./HAPStorage";
 
 const debug = createDebug("ControllerStorage");
 
@@ -159,7 +159,7 @@ export class ControllerStorage {
         this.username = username;
 
         const key = ControllerStorage.persistKey(username);
-        const saved: StorageLayout | undefined = storage.getItem(key);
+        const saved: StorageLayout | undefined = HAPStorage.storage().getItem(key);
 
         let ownData;
         if (saved) {
@@ -230,10 +230,10 @@ export class ControllerStorage {
             };
 
             this.fileCreated = true;
-            storage.setItemSync(key, saved);
+            HAPStorage.storage().setItemSync(key, saved);
         } else if (this.fileCreated) {
             this.fileCreated = false;
-            storage.removeItemSync(key);
+            HAPStorage.storage().removeItemSync(key);
         }
     }
 
@@ -243,7 +243,7 @@ export class ControllerStorage {
 
     static remove(username: MacAddress) {
         const key = ControllerStorage.persistKey(username);
-        storage.removeItemSync(key);
+        HAPStorage.storage().removeItemSync(key);
     }
 
 }

src/lib/model/HAPStorage.spec.ts

@@ -0,0 +1,45 @@
+// @ts-ignore
+import nodePersist from "node-persist";
+import { HAPStorage } from "./HAPStorage";
+
+describe(HAPStorage, () => {
+
+  describe("storage", () => {
+    it('should init storage correctly and only once', function () {
+      const storage = new HAPStorage();
+
+      // @ts-ignore
+      expect(storage.localStore).toBeUndefined();
+      const localStore = storage.storage(); // init first time
+      expect(nodePersist.create).toHaveBeenCalledTimes(1);
+      expect(localStore.initSync).toHaveBeenCalledTimes(1);
+
+      // @ts-ignore
+      expect(storage.localStore).toBeDefined();
+      const localStore2 = storage.storage(); // init first time
+      expect(nodePersist.create).toHaveBeenCalledTimes(1);
+      expect(localStore2).toEqual(localStore);
+      expect(localStore2.initSync).toHaveBeenCalledTimes(1);
+    });
+
+  });
+
+  describe("setCustomStoragePath", () => {
+    it('should init storage correctly with custom storage path', function () {
+      const storage = new HAPStorage();
+
+      storage.setCustomStoragePath("asdfPath");
+      const localStore = storage.storage();
+      expect(localStore.initSync).toHaveBeenCalledTimes(1);
+      expect(localStore.initSync).toHaveBeenLastCalledWith({dir: "asdfPath"});
+    });
+
+    it('should reject setCustomStoragePath after storage has already been initialized', function () {
+      const storage = new HAPStorage();
+
+      storage.storage();
+      expect(() => storage.setCustomStoragePath("customPath")).toThrow(Error);
+    });
+  })
+
+});

src/lib/model/HAPStorage.ts

@@ -0,0 +1,42 @@
+import storage, { LocalStorage } from "node-persist";
+
+export class HAPStorage {
+
+  private static readonly INSTANCE = new HAPStorage();
+
+  private localStore?: LocalStorage;
+  private customStoragePath?: string;
+
+  public static storage(): LocalStorage {
+    return this.INSTANCE.storage();
+  }
+
+  public static setCustomStoragePath(path: string): void {
+    this.INSTANCE.setCustomStoragePath(path);
+  }
+
+  public storage(): LocalStorage {
+    if (!this.localStore) {
+      this.localStore = storage.create();
+
+      if (this.customStoragePath) {
+        this.localStore.initSync({
+          dir: this.customStoragePath,
+        })
+      } else {
+        this.localStore.initSync();
+      }
+    }
+
+    return this.localStore;
+  }
+
+  public setCustomStoragePath(path: string): void {
+    if (this.localStore) {
+      throw new Error("Cannot change storage path after it has already been initialized!");
+    }
+
+    this.customStoragePath = path;
+  }
+
+}

src/lib/model/IdentifierCache.spec.ts

@@ -1,7 +1,11 @@
-// @ts-ignore
-import storage from 'node-persist';
-
 import { IdentifierCache } from './IdentifierCache';
+import { LocalStorage } from "node-persist";
+import { HAPStorage } from "./HAPStorage";
+
+function pullOutLocalStore(): LocalStorage {
+  // @ts-ignore
+  return HAPStorage.INSTANCE.localStore
+}
 
 const createIdentifierCache = (username = 'username') => {
   return new IdentifierCache(username);
@@ -106,8 +110,7 @@ describe('IdentifierCache', () => {
       const identifierCache = createIdentifierCache();
       identifierCache.save();
 
-      expect(storage.setItemSync).toHaveBeenCalledTimes(1);
-      expect(storage.persistSync).toHaveBeenCalledTimes(1);
+      expect(pullOutLocalStore().setItemSync).toHaveBeenCalledTimes(1);
     });
   });
 
@@ -116,7 +119,7 @@ describe('IdentifierCache', () => {
       const identifierCache = createIdentifierCache();
       IdentifierCache.remove(identifierCache.username);
 
-      expect(storage.removeItemSync).toHaveBeenCalledTimes(1);
+      expect(pullOutLocalStore().removeItemSync).toHaveBeenCalledTimes(1);
     });
   });
 

src/lib/model/IdentifierCache.ts

@@ -1,8 +1,7 @@
 import crypto from 'crypto';
 import util from 'util';
-
-import storage from 'node-persist';
 import { MacAddress } from "../../types";
+import { HAPStorage } from "./HAPStorage";
 
 /**
  * IdentifierCache is a model class that manages a system of associating HAP "Accessory IDs" and "Instance IDs"
@@ -86,8 +85,7 @@ export class IdentifierCache {
         cache: this._cache
       };
       var key = IdentifierCache.persistKey(this.username);
-      storage.setItemSync(key, saved);
-      storage.persistSync();
+      HAPStorage.storage().setItemSync(key, saved);
       this._savedCacheHash = newCacheHash; //update hash of saved cache for future use
     }
   }
@@ -102,7 +100,7 @@ export class IdentifierCache {
 
   static load = (username: MacAddress) => {
     var key = IdentifierCache.persistKey(username);
-    var saved = storage.getItem(key);
+    var saved = HAPStorage.storage().getItem(key);
     if (saved) {
       var info = new IdentifierCache(username);
       info._cache = saved.cache;
@@ -115,7 +113,7 @@ export class IdentifierCache {
 
   static remove(username: MacAddress) {
     const key = this.persistKey(username);
-    storage.removeItemSync(key);
+    HAPStorage.storage().removeItemSync(key);
   }
 
 }