v7.1.7

changelog.md

@@ -1,5 +1,25 @@
 # 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
+
+- Wrap insertOne() in error handling to detect MongoDB duplicate key conflicts
+- Log a clearer message with the collection name and identifiable object when unique indexes are involved
+- Guide callers to use getInstance() or save() on a db-retrieved instance when a duplicate already exists
+
+## 2026-04-05 - 7.1.5 - fix(collection)
+ensure unique indexes are marked before upsert operations
+
+- calls unique index marking during collection updates before executing upsert logic
+- helps keep update behavior aligned with index handling already applied on inserts
+
 ## 2026-04-05 - 7.1.4 - fix(collection)
 improve index creation resilience and add collection integrity checks
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartdata",
-  "version": "7.1.4",
+  "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.4',
+  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.collection.ts

@@ -447,8 +447,22 @@ export class SmartdataCollection<T> {
     }
     
     const saveableObject = await dbDocArg.createSavableObject() as any;
-    const result = await this.mongoDbCollection.insertOne(saveableObject, { session: opts?.session });
-    return result;
+    try {
+      const result = await this.mongoDbCollection.insertOne(saveableObject, { session: opts?.session });
+      return result;
+    } catch (err: any) {
+      const isDuplicateKey = err?.code === 11000 || err?.codeName === 'DuplicateKey';
+      if (isDuplicateKey && dbDocArg.uniqueIndexes && dbDocArg.uniqueIndexes.length > 0) {
+        const identifiableObject = await dbDocArg.createIdentifiableObject();
+        logger.log(
+          'error',
+          `Duplicate key conflict in "${this.collectionName}" on insert. ` +
+          `A document with ${JSON.stringify(identifiableObject)} already exists. ` +
+          `Use getInstance() to retrieve the existing document, or update it via save() on a db-retrieved instance.`
+        );
+      }
+      throw err;
+    }
   }
 
   /**
@@ -460,6 +474,7 @@ export class SmartdataCollection<T> {
   ): Promise<any> {
     await this.init();
     await this.checkDoc(dbDocArg);
+    await this.markUniqueIndexes(dbDocArg.uniqueIndexes);
     const identifiableObject = await dbDocArg.createIdentifiableObject();
     const saveableObject = await dbDocArg.createSavableObject() as any;
     const updateableObject: any = {};

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
    */