@oimdb/core 1.0.6 → 1.1.0

package/README.md

@@ -65,9 +65,7 @@ const queue = new OIMEventQueue({
 
 // Create reactive collection
 const users = new OIMReactiveCollection<User, string>(queue, {
-    collectionOpts: {
-        selectPk: (user) => user.id
-    }
+    selectPk: (user) => user.id
 });
 
 // Subscribe to key-specific updates
@@ -249,10 +247,8 @@ const deepMergeUpdater: TOIMEntityUpdater<User> = (newEntity, oldEntity) => {
 // Use custom updater with reactive collection
 const queue = new OIMEventQueue();
 const users = new OIMReactiveCollection<User, string>(queue, {
-    collectionOpts: {
-        selectPk: (user) => user.id,
-        updateEntity: deepMergeUpdater
-    }
+    selectPk: (user) => user.id,
+    updateEntity: deepMergeUpdater
 });
 
 // Now updates will use deep merge logic
@@ -393,9 +389,7 @@ Reactive collection with automatic change notifications and event coalescing.
 
 **Constructor:**
 ```typescript
-new OIMReactiveCollection(queue: OIMEventQueue, opts?: {
-    collectionOpts?: TOIMCollectionOptions<TEntity, TPk>
-})
+new OIMReactiveCollection(queue: OIMEventQueue, opts?: TOIMCollectionOptions<TEntity, TPk>)
 ```
 
 **Properties:**
@@ -411,19 +405,19 @@ new OIMReactiveCollection(queue: OIMEventQueue, opts?: {
 - `getOneByPk(pk: TPk): TEntity | undefined` - Get entity by primary key
 - `getManyByPks(pks: readonly TPk[]): Map<TPk, TEntity | undefined>` - Get multiple entities
 
-#### `OIMRICollection<TEntity, TPk, TIndexName, TIndexKey, TIndex, TReactiveIndex>`
+#### `OIMRICollection<TEntity, TPk, TIndexName, TIndexKey, TIndex, TReactiveIndex, TReactiveIndexMap>`
 Reactive collection with integrated indexing capabilities.
 
 **Constructor:**
 ```typescript
 new OIMRICollection(queue: OIMEventQueue, opts: {
     collectionOpts?: TOIMCollectionOptions<TEntity, TPk>;
-    indexes: Record<TIndexName, TReactiveIndex>;
+    indexes: TReactiveIndexMap;
 })
 ```
 
 **Properties:**
-- `indexes: Record<TIndexName, TReactiveIndex>` - Named reactive indexes
+- `indexes: TReactiveIndexMap` - Named reactive indexes preserving index-to-name mapping
 - *(inherits all OIMReactiveCollection properties)*
 
 #### `OIMReactiveIndexManual<TKey, TPk>`
@@ -529,9 +523,7 @@ describe('OIMReactiveCollection', () => {
         });
         
         users = new OIMReactiveCollection(queue, {
-            collectionOpts: {
-                selectPk: (user) => user.id
-            }
+            selectPk: (user) => user.id
         });
     });
     

package/dist/index.cjs

@@ -28,6 +28,7 @@ __export(index_exports, {
   OIMCollectionStore: () => OIMCollectionStore,
   OIMCollectionStoreMapDriven: () => OIMCollectionStoreMapDriven,
   OIMComparatorFactory: () => OIMComparatorFactory,
+  OIMDBSettings: () => OIMDBSettings,
   OIMEntityUpdaterFactory: () => OIMEntityUpdaterFactory,
   OIMEventEmitter: () => OIMEventEmitter,
   OIMEventQueue: () => OIMEventQueue,
@@ -182,18 +183,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
@@ -206,39 +255,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
@@ -247,15 +296,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
     };
@@ -265,21 +315,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;
   }
   /**
@@ -414,35 +469,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 */,
@@ -461,23 +614,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();
   }
 };
 
@@ -548,14 +692,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());
@@ -657,16 +811,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 */,
@@ -679,129 +824,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
@@ -829,10 +867,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;
   }
 };
 
@@ -955,9 +991,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;
         }
@@ -1201,6 +1235,7 @@ var OIMEventQueueSchedulerFactory = class {
   OIMCollectionStore,
   OIMCollectionStoreMapDriven,
   OIMComparatorFactory,
+  OIMDBSettings,
   OIMEntityUpdaterFactory,
   OIMEventEmitter,
   OIMEventQueue,