@oimdb/core 1.0.6 → 1.2.0

package/dist/index.cjs

@@ -21,6 +21,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   EOIMCollectionEventType: () => EOIMCollectionEventType,
+  EOIMEventQueueEventType: () => EOIMEventQueueEventType,
   EOIMEventQueueSchedulerEventType: () => EOIMEventQueueSchedulerEventType,
   EOIMIndexEventType: () => EOIMIndexEventType,
   EOIMUpdateEventCoalescerEventType: () => EOIMUpdateEventCoalescerEventType,
@@ -28,6 +29,7 @@ __export(index_exports, {
   OIMCollectionStore: () => OIMCollectionStore,
   OIMCollectionStoreMapDriven: () => OIMCollectionStoreMapDriven,
   OIMComparatorFactory: () => OIMComparatorFactory,
+  OIMDBSettings: () => OIMDBSettings,
   OIMEntityUpdaterFactory: () => OIMEntityUpdaterFactory,
   OIMEventEmitter: () => OIMEventEmitter,
   OIMEventQueue: () => OIMEventQueue,
@@ -182,18 +184,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 +256,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 +297,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 +316,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;
   }
   /**
@@ -293,6 +349,8 @@ var OIMIndex = class {
 // src/enum/EOIMUpdateEventCoalescerEventType.ts
 var EOIMUpdateEventCoalescerEventType = /* @__PURE__ */ ((EOIMUpdateEventCoalescerEventType2) => {
   EOIMUpdateEventCoalescerEventType2[EOIMUpdateEventCoalescerEventType2["HAS_CHANGES"] = 0] = "HAS_CHANGES";
+  EOIMUpdateEventCoalescerEventType2[EOIMUpdateEventCoalescerEventType2["BEFORE_FLUSH"] = 1] = "BEFORE_FLUSH";
+  EOIMUpdateEventCoalescerEventType2[EOIMUpdateEventCoalescerEventType2["AFTER_FLUSH"] = 2] = "AFTER_FLUSH";
   return EOIMUpdateEventCoalescerEventType2;
 })(EOIMUpdateEventCoalescerEventType || {});
 
@@ -414,35 +472,141 @@ 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.emitter.emit(
+      1 /* BEFORE_FLUSH */,
+      void 0
+    );
+    this.updatedKeysIndex.setPks(OIMDBSettings.UPDATED_KEYS_INDEX_KEY, []);
     this.hasEmittedChanges = false;
+    this.emitter.emit(
+      2 /* AFTER_FLUSH */,
+      void 0
+    );
   }
   /**
    * 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 +625,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 +703,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());
@@ -620,6 +785,14 @@ var OIMCollection = class {
     this.store.removeManyByPks(pks);
     this.emitter.emit(0 /* UPDATE */, { pks });
   }
+  removeOneByPk(pk) {
+    this.store.removeOneByPk(pk);
+    this.emitter.emit(0 /* UPDATE */, { pks: [pk] });
+  }
+  removeManyByPks(pks) {
+    this.store.removeManyByPks(pks);
+    this.emitter.emit(0 /* UPDATE */, { pks });
+  }
   clear() {
     this.store.clear();
     this.emitter.emit(0 /* UPDATE */, { pks: [] });
@@ -657,16 +830,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 +843,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 +886,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;
   }
 };
 
@@ -854,9 +909,17 @@ var OIMComparatorFactory = class {
   }
 };
 
+// src/enum/EOIMEventQueueEventType.ts
+var EOIMEventQueueEventType = /* @__PURE__ */ ((EOIMEventQueueEventType2) => {
+  EOIMEventQueueEventType2[EOIMEventQueueEventType2["AFTER_FLUSH"] = 0] = "AFTER_FLUSH";
+  EOIMEventQueueEventType2[EOIMEventQueueEventType2["BEFORE_FLUSH"] = 1] = "BEFORE_FLUSH";
+  return EOIMEventQueueEventType2;
+})(EOIMEventQueueEventType || {});
+
 // src/core/OIMEventQueue.ts
 var OIMEventQueue = class {
   constructor(options = {}) {
+    this.emitter = new OIMEventEmitter();
     this.queue = [];
     this.scheduler = options.scheduler;
     if (this.scheduler) {
@@ -883,11 +946,13 @@ var OIMEventQueue = class {
    */
   flush() {
     if (this.queue.length === 0) return;
+    this.emitter.emit(1 /* BEFORE_FLUSH */, void 0);
     const currentQueue = this.queue.slice();
     this.queue.length = 0;
     for (let i = 0; i < currentQueue.length; i++) {
       currentQueue[i]();
     }
+    this.emitter.emit(0 /* AFTER_FLUSH */, void 0);
   }
   /**
    * Get the current number of queued functions.
@@ -955,9 +1020,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;
         }
@@ -1194,6 +1257,7 @@ var OIMEventQueueSchedulerFactory = class {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   EOIMCollectionEventType,
+  EOIMEventQueueEventType,
   EOIMEventQueueSchedulerEventType,
   EOIMIndexEventType,
   EOIMUpdateEventCoalescerEventType,
@@ -1201,6 +1265,7 @@ var OIMEventQueueSchedulerFactory = class {
   OIMCollectionStore,
   OIMCollectionStoreMapDriven,
   OIMComparatorFactory,
+  OIMDBSettings,
   OIMEntityUpdaterFactory,
   OIMEventEmitter,
   OIMEventQueue,