v7.1.7

changelog.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 2026-04-07 - 7.1.7 - fix(collectionfactory)
+isolate collection caching per database and add easy store replace semantics
+
+- Change CollectionFactory to cache collections per SmartdataDb instance instead of by class name globally, preventing cross-database collection reuse.
+- Add EasyStore.replace() for full object replacement while keeping writeAll() merge behavior for backward compatibility.
+- Add regression tests covering multi-database collection isolation, replace() key removal, and writeAll() merge behavior.
+
 ## 2026-04-05 - 7.1.6 - fix(collection)
 improve duplicate key error reporting on insert
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartdata",
-  "version": "7.1.6",
+  "version": "7.1.7",
   "private": false,
   "description": "An advanced library for NoSQL data organization and manipulation using TypeScript with support for MongoDB, data validation, collections, and custom data types.",
   "exports": {

test/test.collectionfactory.ts

@@ -0,0 +1,70 @@
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import * as smartmongo from '@push.rocks/smartmongo';
+import * as smartdata from '../ts/index.js';
+
+/**
+ * Regression tests for:
+ *
+ *  1. CollectionFactory per-db cache (previously keyed by class name
+ *     alone, which made two SmartdataDb instances share a single
+ *     collection bound to whichever db happened to request it first).
+ *  2. EasyStore.replace() — new atomic-replace method that clears keys
+ *     not present in the new object. EasyStore.writeAll() still merges
+ *     for backward compatibility.
+ */
+
+let smartmongoInstance: smartmongo.SmartMongo;
+let dbA: smartdata.SmartdataDb;
+let dbB: smartdata.SmartdataDb;
+
+tap.test('setup: two dbs against the same replica set', async () => {
+  smartmongoInstance = await smartmongo.SmartMongo.createAndStart();
+  const desc = await smartmongoInstance.getMongoDescriptor();
+  dbA = new smartdata.SmartdataDb({ ...desc, mongoDbName: 'cf_test_a' });
+  dbB = new smartdata.SmartdataDb({ ...desc, mongoDbName: 'cf_test_b' });
+  await dbA.init();
+  await dbB.init();
+});
+
+tap.test('CollectionFactory: same class name in two dbs yields two collections', async () => {
+  const easyA = await dbA.createEasyStore<{ marker: string }>('shared');
+  const easyB = await dbB.createEasyStore<{ marker: string }>('shared');
+  await easyA.writeKey('marker', 'A');
+  await easyB.writeKey('marker', 'B');
+  const fromA = await easyA.readKey('marker');
+  const fromB = await easyB.readKey('marker');
+  expect(fromA).toEqual('A');
+  // Under the old singleton bug, this would be 'A' because the second
+  // createEasyStore() call would receive the collection bound to dbA.
+  expect(fromB).toEqual('B');
+});
+
+tap.test('EasyStore.replace: drops keys not present in the new object', async () => {
+  const store = await dbA.createEasyStore<{ a?: string; b?: string }>('replace_test');
+  await store.writeKey('a', '1');
+  await store.writeKey('b', '2');
+  expect(await store.readKey('a')).toEqual('1');
+  expect(await store.readKey('b')).toEqual('2');
+  await store.replace({ a: 'only-a' });
+  expect(await store.readKey('a')).toEqual('only-a');
+  // `b` must be gone — this is the whole point of replace() over writeAll().
+  expect(await store.readKey('b')).toBeUndefined();
+});
+
+tap.test('EasyStore.writeAll: still merges (back-compat)', async () => {
+  const store = await dbA.createEasyStore<{ a?: string; b?: string }>('merge_test');
+  await store.writeAll({ a: '1' });
+  await store.writeAll({ b: '2' });
+  expect(await store.readKey('a')).toEqual('1');
+  expect(await store.readKey('b')).toEqual('2');
+});
+
+tap.test('teardown', async () => {
+  await dbA.mongoDb.dropDatabase();
+  await dbB.mongoDb.dropDatabase();
+  await dbA.close();
+  await dbB.close();
+  await smartmongoInstance.stop();
+});
+
+export default tap.start();

ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartdata',
-  version: '7.1.6',
+  version: '7.1.7',
   description: 'An advanced library for NoSQL data organization and manipulation using TypeScript with support for MongoDB, data validation, collections, and custom data types.'
 }

ts/classes.collectionfactory.ts

@@ -2,13 +2,51 @@ import * as plugins from './plugins.js';
 import { SmartdataCollection } from './classes.collection.js';
 import { SmartdataDb } from './classes.db.js';
 
+/**
+ * Per-SmartdataDb collection cache.
+ *
+ * Historically this class keyed its cache by class name alone, which meant
+ * the first SmartdataDb to request a collection of a given class name
+ * "won" — every subsequent call from a different SmartdataDb instance
+ * received the cached collection bound to the first db. That silently
+ * broke multi-tenant SaaS apps (one db per tenant), tests instantiating
+ * multiple SmartdataDbs in sequence, and any in-process db cluster switch.
+ *
+ * The cache is now keyed by `(SmartdataDb instance, className)` using a
+ * WeakMap of db → Map<className, SmartdataCollection>. Entries are GC'd
+ * with their parent db automatically.
+ */
 export class CollectionFactory {
-  public collections: { [key: string]: SmartdataCollection<any> } = {};
+  private perDbCollections: WeakMap<SmartdataDb, Map<string, SmartdataCollection<any>>> = new WeakMap();
 
   public getCollection = (nameArg: string, dbArg: SmartdataDb): SmartdataCollection<any> => {
-    if (!this.collections[nameArg] && dbArg instanceof SmartdataDb) {
-      this.collections[nameArg] = new SmartdataCollection(nameArg, dbArg);
+    if (!(dbArg instanceof SmartdataDb)) {
+      // Preserve the historical behavior of returning undefined-ish for
+      // non-db args. All in-repo callers already guard on instanceof
+      // before using the result (see classes.collection.ts).
+      return undefined as unknown as SmartdataCollection<any>;
     }
-    return this.collections[nameArg];
+    let dbMap = this.perDbCollections.get(dbArg);
+    if (!dbMap) {
+      dbMap = new Map();
+      this.perDbCollections.set(dbArg, dbMap);
+    }
+    let coll = dbMap.get(nameArg);
+    if (!coll) {
+      coll = new SmartdataCollection(nameArg, dbArg);
+      dbMap.set(nameArg, coll);
+    }
+    return coll;
   };
+
+  /**
+   * @deprecated Internal back-compat shim. The previous field was a public
+   * Record<className, SmartdataCollection> but was not part of the
+   * documented public API. WeakMap is not iterable, so this getter returns
+   * an empty object — anyone actually relying on the old shape would get
+   * clean nothing rather than wrong-db data. Will be removed in 8.0.
+   */
+  public get collections(): { [key: string]: SmartdataCollection<any> } {
+    return {};
+  }
 }

ts/classes.easystore.ts

@@ -93,7 +93,9 @@ export class EasyStore<T> {
   }
 
   /**
-   * writes all keyValue pairs in the object argument
+   * 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();
@@ -101,6 +103,17 @@ export class EasyStore<T> {
     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
    */