@proteinjs/db 1.14.0 → 1.14.1

package/src/reference/Reference.ts

@@ -3,6 +3,7 @@ import { getDb } from '../Db';
 import { Record } from '../Record';
 import { tableByName } from '../Table';
 import { ReferenceSerializerId } from '../serializers/ReferenceSerializer';
+import { ReferenceCache } from './ReferenceCache';
 
 /**
  * The object returned by Db functions for each field of type ReferenceColumn in a record.
@@ -30,6 +31,15 @@ export class Reference<T extends Record> implements CustomSerializableObject {
 
   async get(): Promise<T | undefined> {
     if (!this._object && this._id) {
+      const cachedObject = ReferenceCache.get().get<T>(this._table, this._id);
+      if (cachedObject) {
+        /**
+         * We don't want to cache this reference in `this._object` in case the reference
+         * is replaced in `ReferenceCache`.
+         */
+        return cachedObject;
+      }
+
       const table = tableByName(this._table);
       const db = getDb();
       this._object = await db.get(table, { id: this._id });
@@ -39,6 +49,13 @@ export class Reference<T extends Record> implements CustomSerializableObject {
   }
 
   getIfExists(): T | undefined {
+    if (!this._object && this._id) {
+      const cachedObject = ReferenceCache.get().get<T>(this._table, this._id);
+      if (cachedObject) {
+        return cachedObject;
+      }
+    }
+
     return this._object;
   }
 

package/src/reference/ReferenceCache.ts

@@ -0,0 +1,117 @@
+/**
+ * A way to cache referenced objects. Cached objects are consumed within `Reference`.
+ *
+ * A common way to use this would be to cache shared reference data on the client. Without
+ * this, reference data would be unique per `Reference` object, since `Reference.get` fetches
+ * a new instance of an object over the wire.
+ */
+export class ReferenceCache {
+  private cache: { [table: string]: { [id: string]: any } } = {};
+
+  /**
+   * Returns the singleton instance of ReferenceCache
+   *
+   * @returns The global ReferenceCache instance
+   */
+  static get(): ReferenceCache {
+    if (!ReferenceCache.getGlobal().__proteinjs_db_ReferenceCache) {
+      ReferenceCache.getGlobal().__proteinjs_db_ReferenceCache = new ReferenceCache();
+    }
+
+    return ReferenceCache.getGlobal().__proteinjs_db_ReferenceCache;
+  }
+
+  /**
+   * Returns the global object based on environment
+   *
+   * @returns The global object (window in browser, globalThis elsewhere)
+   */
+  private static getGlobal(): any {
+    if (typeof window !== 'undefined') {
+      return window;
+    }
+
+    return globalThis;
+  }
+
+  /**
+   * Gets a record from the cache for a specific table by ID
+   *
+   * @param table Name of the table containing the record
+   * @param id ID of the record to retrieve
+   * @returns The cached record or undefined if not found
+   */
+  get<T>(table: string, id: string): T | undefined {
+    return this.cache[table]?.[id];
+  }
+
+  /**
+   * Sets a single record in the cache
+   *
+   * @param table Name of the table to add the record to
+   * @param id ID of the record
+   * @param record The record data to store
+   */
+  set(table: string, id: string, record: any): void {
+    this.ensureTableExists(table);
+    this.cache[table][id] = record;
+  }
+
+  /**
+   * Ensures a table exists in the cache
+   *
+   * @param table Name of the table to initialize if needed
+   */
+  private ensureTableExists(table: string): void {
+    if (!this.cache[table]) {
+      this.cache[table] = {};
+    }
+  }
+
+  /**
+   * Clears all cached records for a specific table
+   *
+   * @param table Name of the table to clear from cache
+   */
+  clearTable(table: string): void {
+    if (this.cache[table]) {
+      delete this.cache[table];
+    }
+  }
+
+  /**
+   * Sets multiple records for a specific table at once
+   *
+   * @param table Name of the table to add records to
+   * @param records Either an array of records or an object mapping record IDs to their values
+   */
+  setMultiple<T extends { [key: string]: any } & { id: string }>(
+    table: string,
+    records: T[] | { [id: string]: any }
+  ): void {
+    this.ensureTableExists(table);
+
+    if (Array.isArray(records)) {
+      // Handle array input
+      for (const record of records) {
+        this.cache[table][record.id] = record;
+      }
+    } else {
+      // Handle map/object input
+      for (const [id, record] of Object.entries(records)) {
+        this.cache[table][id] = record;
+      }
+    }
+  }
+
+  /**
+   * Reloads a table by clearing it and then setting the provided records
+   *
+   * @param table Name of the table to reload
+   * @param records Either an array of records or an object mapping record IDs to their values
+   */
+  reloadTable<T extends { [key: string]: any }>(table: string, records: T[] | { [id: string]: any }): void {
+    this.clearTable(table);
+    this.setMultiple(table, records);
+  }
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2023 Brent Bahry
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.