@oimdb/core 1.2.1 → 1.3.0

package/dist/index.js

@@ -2,6 +2,14 @@
 var OIMCollectionStore = class {
 };
 
+// src/abstract/OIMIndexStoreSetBased.ts
+var OIMIndexStoreSetBased = class {
+};
+
+// src/abstract/OIMIndexStoreArrayBased.ts
+var OIMIndexStoreArrayBased = class {
+};
+
 // src/core/OIMEventEmitter.ts
 var OIMEventEmitter = class {
   constructor() {
@@ -127,12 +135,8 @@ var EOIMIndexEventType = /* @__PURE__ */ ((EOIMIndexEventType2) => {
   return EOIMIndexEventType2;
 })(EOIMIndexEventType || {});
 
-// src/abstract/OIMIndexStore.ts
-var OIMIndexStore = class {
-};
-
-// src/core/OIMIndexStoreMapDriven.ts
-var OIMIndexStoreMapDriven = class extends OIMIndexStore {
+// src/core/OIMIndexStoreMapDrivenSetBased.ts
+var OIMIndexStoreMapDrivenSetBased = class extends OIMIndexStoreSetBased {
   constructor() {
     super(...arguments);
     this.pks = /* @__PURE__ */ new Map();
@@ -175,12 +179,12 @@ var OIMIndexStoreMapDriven = class extends OIMIndexStore {
   }
 };
 
-// src/abstract/OIMIndex.ts
-var OIMIndex = class {
+// src/abstract/OIMIndexSetBased.ts
+var OIMIndexSetBased = class {
   constructor(options = {}) {
     this.emitter = new OIMEventEmitter();
     this.comparePks = options.comparePks;
-    this.store = options.store ?? new OIMIndexStoreMapDriven();
+    this.store = options.store ?? new OIMIndexStoreMapDrivenSetBased();
   }
   /**
    * Get primary keys for multiple index keys
@@ -289,6 +293,155 @@ var OIMIndex = class {
   }
 };
 
+// src/core/OIMIndexStoreMapDrivenArrayBased.ts
+var OIMIndexStoreMapDrivenArrayBased = class extends OIMIndexStoreArrayBased {
+  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/OIMIndexArrayBased.ts
+var OIMIndexArrayBased = class {
+  constructor(options = {}) {
+    this.emitter = new OIMEventEmitter();
+    this.comparePks = options.comparePks;
+    this.store = options.store ?? new OIMIndexStoreMapDrivenArrayBased();
+  }
+  /**
+   * Get primary keys for multiple index keys
+   */
+  getPksByKeys(keys) {
+    return this.store.getManyByKeys(keys);
+  }
+  /**
+   * Get primary keys for a specific index key
+   */
+  getPksByKey(key) {
+    const pksArray = this.store.getOneByKey(key);
+    return pksArray ? pksArray : [];
+  }
+  /**
+   * Check if an index key exists
+   */
+  hasKey(key) {
+    return this.store.getOneByKey(key) !== void 0;
+  }
+  /**
+   * Get all index keys
+   */
+  getKeys() {
+    return this.store.getAllKeys();
+  }
+  /**
+   * Get the number of primary keys for a specific index key
+   */
+  getKeySize(key) {
+    const pksArray = this.store.getOneByKey(key);
+    return pksArray ? pksArray.length : 0;
+  }
+  /**
+   * Get total number of index keys
+   */
+  get size() {
+    return this.store.countAll();
+  }
+  /**
+   * Check if the index is empty
+   */
+  get isEmpty() {
+    return this.store.countAll() === 0;
+  }
+  /**
+   * Get performance metrics for monitoring and debugging
+   */
+  getMetrics() {
+    let totalPks = 0;
+    let maxBucketSize = 0;
+    let minBucketSize = Infinity;
+    const allPks = this.store.getAll();
+    for (const pksArray of allPks.values()) {
+      totalPks += pksArray.length;
+      maxBucketSize = Math.max(maxBucketSize, pksArray.length);
+      minBucketSize = Math.min(minBucketSize, pksArray.length);
+    }
+    return {
+      totalKeys: allPks.size,
+      totalPks,
+      averagePksPerKey: allPks.size > 0 ? totalPks / allPks.size : 0,
+      maxBucketSize: maxBucketSize === -Infinity ? 0 : maxBucketSize,
+      minBucketSize: minBucketSize === Infinity ? 0 : minBucketSize
+    };
+  }
+  /**
+   * Clean up event listeners when index is no longer needed
+   */
+  destroy() {
+    this.emitter.offAll();
+    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) {
+    if (this.comparePks) {
+      const existingPksArray = this.store.getOneByKey(key);
+      if (existingPksArray && existingPksArray.length === newPks.length) {
+        if (this.comparePks(existingPksArray, newPks)) {
+          return false;
+        }
+      } else if (!existingPksArray && newPks.length === 0) {
+        return false;
+      }
+    }
+    this.store.setOneByKey(key, newPks);
+    return true;
+  }
+  /**
+   * Emit update event with changed keys
+   */
+  emitUpdate(keys) {
+    this.emitter.emit(0 /* UPDATE */, { keys });
+  }
+};
+
 // src/enum/EOIMUpdateEventCoalescerEventType.ts
 var EOIMUpdateEventCoalescerEventType = /* @__PURE__ */ ((EOIMUpdateEventCoalescerEventType2) => {
   EOIMUpdateEventCoalescerEventType2[EOIMUpdateEventCoalescerEventType2["HAS_CHANGES"] = 0] = "HAS_CHANGES";
@@ -415,8 +568,8 @@ var OIMUpdateEventEmitter = class {
   }
 };
 
-// src/core/OIMIndexManual.ts
-var OIMIndexManual = class extends OIMIndex {
+// src/core/OIMIndexManualSetBased.ts
+var OIMIndexManualSetBased = class extends OIMIndexSetBased {
   constructor(options = {}) {
     super(options);
   }
@@ -508,8 +661,8 @@ var OIMUpdateEventCoalescer = class {
   constructor(index) {
     this.emitter = new OIMEventEmitter();
     this.hasEmittedChanges = false;
-    this.updatedKeysIndex = index ?? new OIMIndexManual({
-      store: new OIMIndexStoreMapDriven()
+    this.updatedKeysIndex = index ?? new OIMIndexManualSetBased({
+      store: new OIMIndexStoreMapDrivenSetBased()
     });
     if (!this.updatedKeysIndex.hasKey(OIMDBSettings.UPDATED_KEYS_INDEX_KEY)) {
       this.updatedKeysIndex.setPks(
@@ -579,8 +732,49 @@ var OIMUpdateEventCoalescerIndex = class extends OIMUpdateEventCoalescer {
   }
 };
 
-// src/abstract/OIMReactiveIndex.ts
-var OIMReactiveIndex = class {
+// src/abstract/OIMReactiveIndexSetBased.ts
+var OIMReactiveIndexSetBased = class {
+  constructor(queue, opts) {
+    this.index = opts?.index ?? this.createDefaultIndex();
+    this.coalescer = new OIMUpdateEventCoalescerIndex(
+      this.index.emitter
+    );
+    this.updateEventEmitter = new OIMUpdateEventEmitter({
+      coalescer: this.coalescer,
+      queue
+    });
+  }
+  getPksByKey(key) {
+    return this.index.getPksByKey(key);
+  }
+  getPksByKeys(keys) {
+    return this.index.getPksByKeys(keys);
+  }
+  hasKey(key) {
+    return this.index.hasKey(key);
+  }
+  getKeys() {
+    return this.index.getKeys();
+  }
+  getKeySize(key) {
+    return this.index.getKeySize(key);
+  }
+  get size() {
+    return this.index.size;
+  }
+  get isEmpty() {
+    return this.index.isEmpty;
+  }
+  getMetrics() {
+    return this.index.getMetrics();
+  }
+  destroy() {
+    this.index.destroy();
+  }
+};
+
+// src/abstract/OIMReactiveIndexArrayBased.ts
+var OIMReactiveIndexArrayBased = class {
   constructor(queue, opts) {
     this.index = opts?.index ?? this.createDefaultIndex();
     this.coalescer = new OIMUpdateEventCoalescerIndex(
@@ -708,6 +902,10 @@ var OIMCollection = class {
   getManyByPks(pks) {
     return this.store.getManyByPks(pks);
   }
+  upsertOneByPk(pk, entity) {
+    this.upsertOneWithoutNotificationsByPk(pk, entity);
+    this.emitter.emit(0 /* UPDATE */, { pks: [pk] });
+  }
   upsertOne(entity) {
     const pk = this.upsertOneWithoutNotifications(entity);
     this.emitter.emit(0 /* UPDATE */, { pks: [pk] });
@@ -751,6 +949,15 @@ var OIMCollection = class {
   }
   upsertOneWithoutNotifications(entity) {
     const pk = this.selectPk(entity);
+    this.upsertOneWithoutNotificationsByPk(pk, entity);
+    return pk;
+  }
+  upsertOneWithoutNotificationsByPk(pk, entity) {
+    if (!pk) {
+      throw new Error(
+        `[OIMCollection]: PK is required to upsert an entity ${JSON.stringify(entity)}`
+      );
+    }
     const existingEntity = this.store.getOneByPk(pk);
     if (existingEntity) {
       this.store.setOneByPk(
@@ -760,7 +967,6 @@ var OIMCollection = class {
     } else {
       this.store.setOneByPk(pk, entity);
     }
-    return pk;
   }
 };
 
@@ -804,13 +1010,111 @@ var OIMReactiveCollection = class extends OIMCollection {
   }
 };
 
-// src/core/OIMReactiveIndexManual.ts
-var OIMReactiveIndexManual = class extends OIMReactiveIndex {
+// src/core/OIMReactiveIndexManualSetBased.ts
+var OIMReactiveIndexManualSetBased = class extends OIMReactiveIndexSetBased {
+  constructor(queue, opts) {
+    super(queue, opts);
+  }
+  createDefaultIndex() {
+    return new OIMIndexManualSetBased();
+  }
+  setPks(key, pks) {
+    this.index.setPks(key, pks);
+  }
+  addPks(key, pks) {
+    this.index.addPks(key, pks);
+  }
+  removePks(key, pks) {
+    this.index.removePks(key, pks);
+  }
+  clear(key) {
+    this.index.clear(key);
+  }
+};
+
+// src/core/OIMIndexManualArrayBased.ts
+var OIMIndexManualArrayBased = class extends OIMIndexArrayBased {
+  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, pks);
+    if (hasChanges) {
+      this.emitUpdate([key]);
+    }
+  }
+  /**
+   * Add primary keys to a specific index key
+   */
+  addPks(key, pks) {
+    if (pks.length === 0) return;
+    let pksArray = this.store.getOneByKey(key);
+    if (!pksArray) {
+      pksArray = [];
+      this.store.setOneByKey(key, pksArray);
+    }
+    const pksSet = new Set(pksArray);
+    let hasChanges = false;
+    for (const pk of pks) {
+      if (!pksSet.has(pk)) {
+        pksSet.add(pk);
+        hasChanges = true;
+      }
+    }
+    if (hasChanges) {
+      this.store.setOneByKey(key, Array.from(pksSet));
+      this.emitUpdate([key]);
+    }
+  }
+  /**
+   * Remove primary keys from a specific index key
+   */
+  removePks(key, pks) {
+    if (pks.length === 0) return;
+    const pksArray = this.store.getOneByKey(key);
+    if (!pksArray) return;
+    const pksSet = new Set(pks);
+    const filtered = pksArray.filter((pk) => !pksSet.has(pk));
+    const hasChanges = filtered.length !== pksArray.length;
+    if (hasChanges) {
+      if (filtered.length === 0) {
+        this.store.removeOneByKey(key);
+      } else {
+        this.store.setOneByKey(key, filtered);
+      }
+      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/core/OIMReactiveIndexManualArrayBased.ts
+var OIMReactiveIndexManualArrayBased = class extends OIMReactiveIndexArrayBased {
   constructor(queue, opts) {
     super(queue, opts);
   }
   createDefaultIndex() {
-    return new OIMIndexManual();
+    return new OIMIndexManualArrayBased();
   }
   setPks(key, pks) {
     this.index.setPks(key, pks);
@@ -1217,15 +1521,23 @@ export {
   OIMEventQueueSchedulerImmediate,
   OIMEventQueueSchedulerMicrotask,
   OIMEventQueueSchedulerTimeout,
-  OIMIndex,
+  OIMIndexArrayBased,
   OIMIndexComparatorFactory,
-  OIMIndexManual,
+  OIMIndexManualArrayBased,
+  OIMIndexManualSetBased,
+  OIMIndexSetBased,
+  OIMIndexStoreArrayBased,
+  OIMIndexStoreMapDrivenArrayBased,
+  OIMIndexStoreMapDrivenSetBased,
+  OIMIndexStoreSetBased,
   OIMMap2Keys,
   OIMPkSelectorFactory,
   OIMRICollection,
   OIMReactiveCollection,
-  OIMReactiveIndex,
-  OIMReactiveIndexManual,
+  OIMReactiveIndexArrayBased,
+  OIMReactiveIndexManualArrayBased,
+  OIMReactiveIndexManualSetBased,
+  OIMReactiveIndexSetBased,
   OIMUpdateEventCoalescer,
   OIMUpdateEventCoalescerCollection,
   OIMUpdateEventCoalescerIndex,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oimdb/core",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "description": "Core in-memory data library with type-safe indices, reactive subscriptions, and event processing",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -32,6 +32,18 @@
   "files": [
     "dist"
   ],
+  "keywords": [
+    "oimdb",
+    "in-memory",
+    "database",
+    "reactive",
+    "typescript",
+    "type-safe",
+    "indices",
+    "subscriptions",
+    "event-processing",
+    "state-management"
+  ],
   "author": "Andrei Baikov",
   "license": "MIT",
   "devDependencies": {