@lossless.org/client 0.1.0

package/ts/nosqldb/classes.easystore.ts

@@ -0,0 +1,154 @@
+import * as plugins from './plugins.js';
+import { Collection } from './classes.collection.js';
+import { SmartdataDb } from './classes.db.js';
+import { SmartDataDbDoc, svDb, unI } from './classes.doc.js';
+
+const easyStoreClassByDb = new WeakMap<SmartdataDb, any>();
+
+const getEasyStoreClassForDb = <T>(smartdataDbArg: SmartdataDb) => {
+  const existingClass = easyStoreClassByDb.get(smartdataDbArg);
+  if (existingClass) {
+    return existingClass;
+  }
+  @Collection(() => smartdataDbArg)
+  class SmartdataEasyStore extends SmartDataDbDoc<
+    SmartdataEasyStore,
+    SmartdataEasyStore
+  > {
+    @unI()
+    public nameId!: string;
+
+    @svDb()
+    public ephemeral!: {
+      activated: boolean;
+      timeout: number;
+    };
+
+    @svDb()
+    lastEdit!: number;
+
+    @svDb()
+    public data!: Partial<T>;
+  }
+  easyStoreClassByDb.set(smartdataDbArg, SmartdataEasyStore);
+  return SmartdataEasyStore;
+};
+
+/**
+ * EasyStore allows the storage of easy objects. It also allows easy sharing of the object between different instances
+ */
+export class EasyStore<T> {
+  // instance
+  public smartdataDbRef: SmartdataDb;
+  public nameId: string;
+
+  private easyStoreClass: ReturnType<typeof getEasyStoreClassForDb<T>>;
+
+  constructor(nameIdArg: string, smartdataDbRefArg: SmartdataDb) {
+    this.smartdataDbRef = smartdataDbRefArg;
+    this.nameId = nameIdArg;
+    this.easyStoreClass = getEasyStoreClassForDb<T>(smartdataDbRefArg);
+  }
+
+  private easyStorePromise?: Promise<InstanceType<typeof this.easyStoreClass>>;
+  private async getEasyStore(): Promise<InstanceType<typeof this.easyStoreClass>> {
+    if (this.easyStorePromise) {
+      return this.easyStorePromise;
+    }
+
+    // first run from here
+    const deferred = plugins.smartpromise.defer<InstanceType<typeof this.easyStoreClass>>();
+    this.easyStorePromise = deferred.promise;
+
+    try {
+      let easyStore = await this.easyStoreClass.getInstance({
+        nameId: this.nameId,
+      });
+
+      if (!easyStore) {
+        easyStore = new this.easyStoreClass();
+        easyStore.nameId = this.nameId;
+        easyStore.data = {};
+        await easyStore.save();
+      }
+      deferred.resolve(easyStore);
+    } catch (error) {
+      // settle the deferred and clear the cache so concurrent callers get the
+      // error instead of awaiting forever, and later callers can retry
+      this.easyStorePromise = undefined;
+      deferred.reject(error);
+    }
+    return deferred.promise;
+  }
+
+  /**
+   * reads all keyValue pairs at once and returns them
+   */
+  public async readAll() {
+    const easyStore = await this.getEasyStore();
+    return easyStore.data;
+  }
+
+  /**
+   * reads a keyValueFile from disk
+   */
+  public async readKey<TKey extends keyof T>(keyArg: TKey): Promise<Partial<T>[TKey]> {
+    const easyStore = await this.getEasyStore();
+    return easyStore.data[keyArg];
+  }
+
+  /**
+   * writes a specific key to the keyValueStore
+   */
+  public async writeKey<TKey extends keyof T>(keyArg: TKey, valueArg: T[TKey]) {
+    const easyStore = await this.getEasyStore();
+    easyStore.data[keyArg] = valueArg;
+    await easyStore.save();
+  }
+
+  public async deleteKey(keyArg: keyof T) {
+    const easyStore = await this.getEasyStore();
+    delete easyStore.data[keyArg];
+    await easyStore.save();
+  }
+
+  /**
+   * merges all keyValue pairs from the object argument into the store.
+   * Existing keys that are not present in `keyValueObject` are preserved.
+   * To overwrite the entire store and drop missing keys, use `replace()`.
+   */
+  public async writeAll(keyValueObject: Partial<T>) {
+    const easyStore = await this.getEasyStore();
+    easyStore.data = { ...easyStore.data, ...keyValueObject };
+    await easyStore.save();
+  }
+
+  /**
+   * atomically replaces the entire store with the given object.
+   * Unlike `writeAll` (which merges), `replace` clears any keys not
+   * present in `keyValueObject`. Useful when you need to drop a key.
+   */
+  public async replace(keyValueObject: Partial<T>) {
+    const easyStore = await this.getEasyStore();
+    easyStore.data = { ...keyValueObject };
+    await easyStore.save();
+  }
+
+  /**
+   * wipes a key value store from disk
+   */
+  public async wipe() {
+    const easyStore = await this.getEasyStore();
+    easyStore.data = {};
+    await easyStore.save();
+  }
+
+  public async cleanUpEphemeral() {
+    // Clean up ephemeral data periodically while connected
+    while (this.smartdataDbRef.status === 'connected') {
+      await plugins.smartdelay.delayFor(60000); // Check every minute
+      // TODO: Implement actual cleanup logic for ephemeral data
+      // For now, this prevents the infinite CPU loop
+    }
+  }
+}