@oimdb/core 1.0.6 → 1.1.0

package/dist/index.js

@@ -127,18 +127,66 @@ var EOIMIndexEventType = /* @__PURE__ */ ((EOIMIndexEventType2) => {
   return EOIMIndexEventType2;
 })(EOIMIndexEventType || {});
 
+// src/abstract/OIMIndexStore.ts
+var OIMIndexStore = class {
+};
+
+// src/core/OIMIndexStoreMapDriven.ts
+var OIMIndexStoreMapDriven = class extends OIMIndexStore {
+  constructor() {
+    super(...arguments);
+    this.pks = /* @__PURE__ */ new Map();
+  }
+  setOneByKey(key, pks) {
+    this.pks.set(key, pks);
+  }
+  removeOneByKey(key) {
+    this.pks.delete(key);
+  }
+  removeManyByKeys(keys) {
+    for (const key of keys) {
+      this.pks.delete(key);
+    }
+  }
+  getOneByKey(key) {
+    return this.pks.get(key);
+  }
+  getManyByKeys(keys) {
+    const result = /* @__PURE__ */ new Map();
+    for (const key of keys) {
+      const pks = this.getOneByKey(key);
+      if (pks !== void 0) {
+        result.set(key, pks);
+      }
+    }
+    return result;
+  }
+  getAllKeys() {
+    return Array.from(this.pks.keys());
+  }
+  getAll() {
+    return new Map(this.pks);
+  }
+  countAll() {
+    return this.pks.size;
+  }
+  clear() {
+    this.pks.clear();
+  }
+};
+
 // src/abstract/OIMIndex.ts
 var OIMIndex = class {
   constructor(options = {}) {
-    this.pks = /* @__PURE__ */ new Map();
     this.emitter = new OIMEventEmitter();
     this.comparePks = options.comparePks;
+    this.store = options.store ?? new OIMIndexStoreMapDriven();
   }
   /**
    * Get primary keys for multiple index keys
    */
   getPksByKeys(keys) {
-    return new Map(keys.map((key) => [key, this.getPks(key)]));
+    return this.store.getManyByKeys(keys);
   }
   /**
    * @deprecated Use getPksByKey instead
@@ -151,39 +199,39 @@ var OIMIndex = class {
    * Get primary keys for a specific index key
    */
   getPksByKey(key) {
-    const pksSet = this.pks.get(key);
+    const pksSet = this.store.getOneByKey(key);
     return pksSet ? pksSet : /* @__PURE__ */ new Set();
   }
   /**
    * Check if an index key exists
    */
   hasKey(key) {
-    return this.pks.has(key);
+    return this.store.getOneByKey(key) !== void 0;
   }
   /**
    * Get all index keys
    */
   getKeys() {
-    return Array.from(this.pks.keys());
+    return this.store.getAllKeys();
   }
   /**
    * Get the number of primary keys for a specific index key
    */
   getKeySize(key) {
-    const pksSet = this.pks.get(key);
+    const pksSet = this.store.getOneByKey(key);
     return pksSet ? pksSet.size : 0;
   }
   /**
    * Get total number of index keys
    */
   get size() {
-    return this.pks.size;
+    return this.store.countAll();
   }
   /**
    * Check if the index is empty
    */
   get isEmpty() {
-    return this.pks.size === 0;
+    return this.store.countAll() === 0;
   }
   /**
    * Get performance metrics for monitoring and debugging
@@ -192,15 +240,16 @@ var OIMIndex = class {
     let totalPks = 0;
     let maxBucketSize = 0;
     let minBucketSize = Infinity;
-    for (const pksSet of this.pks.values()) {
+    const allPks = this.store.getAll();
+    for (const pksSet of allPks.values()) {
       totalPks += pksSet.size;
       maxBucketSize = Math.max(maxBucketSize, pksSet.size);
       minBucketSize = Math.min(minBucketSize, pksSet.size);
     }
     return {
-      totalKeys: this.pks.size,
+      totalKeys: allPks.size,
       totalPks,
-      averagePksPerKey: this.pks.size > 0 ? totalPks / this.pks.size : 0,
+      averagePksPerKey: allPks.size > 0 ? totalPks / allPks.size : 0,
       maxBucketSize: maxBucketSize === -Infinity ? 0 : maxBucketSize,
       minBucketSize: minBucketSize === Infinity ? 0 : minBucketSize
     };
@@ -210,21 +259,26 @@ var OIMIndex = class {
    */
   destroy() {
     this.emitter.offAll();
-    this.pks.clear();
+    this.store.clear();
   }
   /**
    * Set primary keys for a specific index key with optional comparison.
    * If comparator is provided and returns true (no changes), skip the update.
    */
   setPksWithComparison(key, newPks) {
-    const existingPks = this.getPks(key).values();
-    if (this.comparePks && this.comparePks(
-      Array.from(existingPks),
-      Array.from(newPks.values())
-    )) {
-      return false;
+    if (this.comparePks) {
+      const existingPksSet = this.store.getOneByKey(key);
+      if (existingPksSet && existingPksSet.size === newPks.size) {
+        const existingPksArray = existingPksSet.size > 0 ? [...existingPksSet] : [];
+        const newPksArray = newPks.size > 0 ? [...newPks] : [];
+        if (this.comparePks(existingPksArray, newPksArray)) {
+          return false;
+        }
+      } else if (!existingPksSet && newPks.size === 0) {
+        return false;
+      }
     }
-    this.pks.set(key, newPks);
+    this.store.setOneByKey(key, newPks);
     return true;
   }
   /**
@@ -359,35 +413,133 @@ var OIMUpdateEventEmitter = class {
   }
 };
 
+// src/core/OIMIndexManual.ts
+var OIMIndexManual = class extends OIMIndex {
+  constructor(options = {}) {
+    super(options);
+  }
+  /**
+   * Set primary keys for a specific index key, replacing any existing values.
+   * Uses optional comparator to skip updates if PKs haven't actually changed.
+   */
+  setPks(key, pks) {
+    const hasChanges = this.setPksWithComparison(key, new Set(pks));
+    if (hasChanges) {
+      this.emitUpdate([key]);
+    }
+  }
+  /**
+   * Add primary keys to a specific index key
+   */
+  addPks(key, pks) {
+    if (pks.length === 0) return;
+    let pksSet = this.store.getOneByKey(key);
+    if (!pksSet) {
+      pksSet = /* @__PURE__ */ new Set();
+      this.store.setOneByKey(key, pksSet);
+    }
+    let hasChanges = false;
+    for (const pk of pks) {
+      if (!pksSet.has(pk)) {
+        pksSet.add(pk);
+        hasChanges = true;
+      }
+    }
+    if (hasChanges) {
+      this.store.setOneByKey(key, pksSet);
+      this.emitUpdate([key]);
+    }
+  }
+  /**
+   * Remove primary keys from a specific index key
+   */
+  removePks(key, pks) {
+    if (pks.length === 0) return;
+    const pksSet = this.store.getOneByKey(key);
+    if (!pksSet) return;
+    let hasChanges = false;
+    for (const pk of pks) {
+      if (pksSet.delete(pk)) {
+        hasChanges = true;
+      }
+    }
+    if (pksSet.size === 0) {
+      this.store.removeOneByKey(key);
+      hasChanges = true;
+    } else if (hasChanges) {
+      this.store.setOneByKey(key, pksSet);
+    }
+    if (hasChanges) {
+      this.emitUpdate([key]);
+    }
+  }
+  /**
+   * Clear all primary keys for a specific index key, or all keys if no key specified
+   */
+  clear(key) {
+    if (key === void 0) {
+      const allKeys = this.store.getAllKeys();
+      if (allKeys.length > 0) {
+        this.store.clear();
+        this.emitUpdate(allKeys);
+      }
+    } else {
+      if (this.store.getOneByKey(key) !== void 0) {
+        this.store.removeOneByKey(key);
+        this.emitUpdate([key]);
+      }
+    }
+  }
+};
+
+// src/const/OIMDBSettings.ts
+var OIMDBSettings = class {
+};
+/**
+ * Fixed key used in the manual index to store updated keys set in coalescers.
+ * This constant is exported so users can create their own indexes and pass them to coalescers.
+ */
+OIMDBSettings.UPDATED_KEYS_INDEX_KEY = "__updatedKeys__";
+
 // src/core/OIMUpdateEventCoalescer.ts
 var OIMUpdateEventCoalescer = class {
-  constructor() {
+  constructor(index) {
     this.emitter = new OIMEventEmitter();
-    this.updatedKeys = /* @__PURE__ */ new Set();
     this.hasEmittedChanges = false;
+    this.updatedKeysIndex = index ?? new OIMIndexManual({
+      store: new OIMIndexStoreMapDriven()
+    });
+    if (!this.updatedKeysIndex.hasKey(OIMDBSettings.UPDATED_KEYS_INDEX_KEY)) {
+      this.updatedKeysIndex.setPks(
+        OIMDBSettings.UPDATED_KEYS_INDEX_KEY,
+        []
+      );
+    }
   }
   /**
    * Get the set of keys that have been updated since last clear
    */
   getUpdatedKeys() {
-    return this.updatedKeys;
+    return this.updatedKeysIndex.getPksByKey(
+      OIMDBSettings.UPDATED_KEYS_INDEX_KEY
+    );
   }
   /**
    * Clear all updated keys and reset the changed state
    */
   clearUpdatedKeys() {
-    this.updatedKeys.clear();
+    this.updatedKeysIndex.setPks(OIMDBSettings.UPDATED_KEYS_INDEX_KEY, []);
     this.hasEmittedChanges = false;
   }
   /**
    * Add keys to the updated set and emit HAS_CHANGES event if needed
    */
   addUpdatedKeys(keys) {
-    const hadChanges = this.updatedKeys.size > 0;
-    for (const key of keys) {
-      this.updatedKeys.add(key);
-    }
-    if (!hadChanges && this.updatedKeys.size > 0 && !this.hasEmittedChanges) {
+    this.updatedKeysIndex.addPks(
+      OIMDBSettings.UPDATED_KEYS_INDEX_KEY,
+      keys
+    );
+    if (!this.hasEmittedChanges) {
       this.hasEmittedChanges = true;
       this.emitter.emit(
         0 /* HAS_CHANGES */,
@@ -406,23 +558,14 @@ var OIMUpdateEventCoalescerIndex = class extends OIMUpdateEventCoalescer {
      * When the index is updated, we keep track of the updated keys.
      */
     this.handleUpdate = (payload) => {
-      const hadChanges = this.updatedKeys.size > 0;
-      for (const key of payload.keys) {
-        this.updatedKeys.add(key);
-      }
-      if (!hadChanges && this.updatedKeys.size > 0) {
-        this.emitter.emit(
-          0 /* HAS_CHANGES */,
-          void 0
-        );
-      }
+      this.addUpdatedKeys(payload.keys);
     };
     this.indexEmitter.on(0 /* UPDATE */, this.handleUpdate);
   }
   destroy() {
     this.indexEmitter.off(0 /* UPDATE */, this.handleUpdate);
     this.emitter.offAll();
-    this.updatedKeys.clear();
+    this.clearUpdatedKeys();
   }
 };
 
@@ -493,14 +636,24 @@ var OIMCollectionStoreMapDriven = class extends OIMCollectionStore {
   }
   removeManyByPks(pks) {
     for (const pk of pks) {
-      this.removeOneByPk(pk);
+      this.entities.delete(pk);
     }
   }
   getOneByPk(pk) {
     return this.entities.get(pk);
   }
   getManyByPks(pks) {
-    return pks.map((pk) => this.getOneByPk(pk)).filter(Boolean);
+    const result = [];
+    result.length = pks.length;
+    let writeIndex = 0;
+    for (let i = 0; i < pks.length; i++) {
+      const entity = this.getOneByPk(pks[i]);
+      if (entity !== void 0) {
+        result[writeIndex++] = entity;
+      }
+    }
+    result.length = writeIndex;
+    return result;
   }
   getAll() {
     return Array.from(this.entities.values());
@@ -602,16 +755,7 @@ var OIMUpdateEventCoalescerCollection = class extends OIMUpdateEventCoalescer {
      * When the collection is updated, we keep track of the updated pks.
      */
     this.handleUpdate = (payload) => {
-      const hadChanges = this.updatedKeys.size > 0;
-      for (const pk of payload.pks) {
-        this.updatedKeys.add(pk);
-      }
-      if (!hadChanges && this.updatedKeys.size > 0) {
-        this.emitter.emit(
-          0 /* HAS_CHANGES */,
-          void 0
-        );
-      }
+      this.addUpdatedKeys(payload.pks);
     };
     this.collectionEmitter.on(
       0 /* UPDATE */,
@@ -624,129 +768,22 @@ var OIMUpdateEventCoalescerCollection = class extends OIMUpdateEventCoalescer {
       this.handleUpdate
     );
     this.emitter.offAll();
-    this.updatedKeys.clear();
+    this.clearUpdatedKeys();
   }
 };
 
 // src/core/OIMReactiveCollection.ts
-var OIMReactiveCollection = class {
+var OIMReactiveCollection = class extends OIMCollection {
   constructor(queue, opts) {
-    this.collection = new OIMCollection(opts?.collectionOpts);
+    super(opts);
     this.coalescer = new OIMUpdateEventCoalescerCollection(
-      this.collection.emitter
+      this.emitter
     );
     this.updateEventEmitter = new OIMUpdateEventEmitter({
       coalescer: this.coalescer,
       queue
     });
   }
-  upsertMany(entities) {
-    this.collection.upsertMany(entities);
-  }
-  upsertOne(entity) {
-    this.collection.upsertOne(entity);
-  }
-  removeMany(entities) {
-    this.collection.removeMany(entities);
-  }
-  removeOne(entity) {
-    this.collection.removeOne(entity);
-  }
-  getOneByPk(pk) {
-    return this.collection.getOneByPk(pk);
-  }
-  getManyByPks(pks) {
-    return this.collection.getManyByPks(pks);
-  }
-  clear() {
-    this.collection.clear();
-  }
-  countAll() {
-    return this.collection.countAll();
-  }
-  getAll() {
-    return this.collection.getAll();
-  }
-  getAllPks() {
-    return this.collection.getAllPks();
-  }
-};
-
-// src/core/OIMIndexManual.ts
-var OIMIndexManual = class extends OIMIndex {
-  constructor(options = {}) {
-    super(options);
-  }
-  /**
-   * Set primary keys for a specific index key, replacing any existing values.
-   * Uses optional comparator to skip updates if PKs haven't actually changed.
-   */
-  setPks(key, pks) {
-    const hasChanges = this.setPksWithComparison(key, new Set(pks));
-    if (hasChanges) {
-      this.emitUpdate([key]);
-    }
-  }
-  /**
-   * Add primary keys to a specific index key
-   */
-  addPks(key, pks) {
-    if (pks.length === 0) return;
-    let pksSet = this.pks.get(key);
-    if (!pksSet) {
-      pksSet = /* @__PURE__ */ new Set();
-      this.pks.set(key, pksSet);
-    }
-    let hasChanges = false;
-    for (const pk of pks) {
-      const sizeBefore = pksSet.size;
-      pksSet.add(pk);
-      if (pksSet.size > sizeBefore) {
-        hasChanges = true;
-      }
-    }
-    if (hasChanges) {
-      this.emitUpdate([key]);
-    }
-  }
-  /**
-   * Remove primary keys from a specific index key
-   */
-  removePks(key, pks) {
-    if (pks.length === 0) return;
-    const pksSet = this.pks.get(key);
-    if (!pksSet) return;
-    let hasChanges = false;
-    for (const pk of pks) {
-      if (pksSet.delete(pk)) {
-        hasChanges = true;
-      }
-    }
-    if (pksSet.size === 0) {
-      this.pks.delete(key);
-      hasChanges = true;
-    }
-    if (hasChanges) {
-      this.emitUpdate([key]);
-    }
-  }
-  /**
-   * Clear all primary keys for a specific index key, or all keys if no key specified
-   */
-  clear(key) {
-    if (key === void 0) {
-      if (this.pks.size > 0) {
-        const allKeys = Array.from(this.pks.keys());
-        this.pks.clear();
-        this.emitUpdate(allKeys);
-      }
-    } else {
-      if (this.pks.has(key)) {
-        this.pks.delete(key);
-        this.emitUpdate([key]);
-      }
-    }
-  }
 };
 
 // src/core/OIMReactiveIndexManual.ts
@@ -774,10 +811,8 @@ var OIMReactiveIndexManual = class extends OIMReactiveIndex {
 // src/core/OIMRICollection.ts
 var OIMRICollection = class extends OIMReactiveCollection {
   constructor(queue, opts) {
-    super(queue, {
-      collectionOpts: opts.collectionOpts
-    });
-    this.indexes = opts.indexes || {};
+    super(queue, opts.collectionOpts);
+    this.indexes = opts.indexes;
   }
 };
 
@@ -900,9 +935,7 @@ var OIMIndexComparatorFactory = class {
       if (existingSet.size !== newSet.size || existingSet.size !== existingPks.length) {
         return false;
       }
-      const setValues = Array.from(existingSet);
-      for (let i = 0; i < setValues.length; i++) {
-        const pk = setValues[i];
+      for (const pk of existingSet) {
         if (!newSet.has(pk)) {
           return false;
         }
@@ -1145,6 +1178,7 @@ export {
   OIMCollectionStore,
   OIMCollectionStoreMapDriven,
   OIMComparatorFactory,
+  OIMDBSettings,
   OIMEntityUpdaterFactory,
   OIMEventEmitter,
   OIMEventQueue,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oimdb/core",
-  "version": "1.0.6",
+  "version": "1.1.0",
   "description": "Core in-memory data library with type-safe indices, reactive subscriptions, and event processing",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -24,8 +24,10 @@
   },
   "scripts": {
     "build": "tsup src/index.ts --dts --format esm,cjs",
+    "test": "jest",
+    "type-check": "tsc --noEmit",
     "clean": "rimraf dist",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run type-check && npm test && npm run build"
   },
   "files": [
     "dist"
@@ -33,6 +35,9 @@
   "author": "Andrei Baikov",
   "license": "MIT",
   "devDependencies": {
+    "@types/jest": "^29.5.8",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.1",
     "tsup": "^8.5.0",
     "typescript": "^5.2.2",
     "rimraf": "^5.0.5"