@signaldb/core 1.7.0 → 2.0.0-beta.0

package/dist/index12.mjs

@@ -1,6 +1,340 @@
-function randomId() {
-  return Math.floor(Math.random() * 1e17).toString(16);
+import createIndex from "./index20.mjs";
+import getIndexInfo from "./index21.mjs";
+import deepClone from "./index19.mjs";
+import EventEmitter from "./index9.mjs";
+import isEqual from "./index6.mjs";
+import match from "./index22.mjs";
+import modify from "./index7.mjs";
+import project from "./index23.mjs";
+import queryId from "./index24.mjs";
+import serializeValue from "./index11.mjs";
+import sortItems from "./index25.mjs";
+function hasPendingUpdates(pendingUpdates) {
+  return pendingUpdates.added.length > 0 || pendingUpdates.modified.length > 0 || pendingUpdates.removed.length > 0;
+}
+class DefaultDataAdapter {
+  items = /* @__PURE__ */ new Map();
+  options;
+  storageAdapters = /* @__PURE__ */ new Map();
+  indices = /* @__PURE__ */ new Map();
+  activeQueries = /* @__PURE__ */ new Map();
+  queryEmitters = /* @__PURE__ */ new Map();
+  queuedQueryUpdates = /* @__PURE__ */ new Map();
+  cachedQueryResults = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.options = options || {};
+  }
+  ensureStorageAdapter(name) {
+    if (this.storageAdapters.get(name))
+      return;
+    if (!this.options.storage)
+      return;
+    const adapter = this.options.storage(name);
+    if (!adapter)
+      return;
+    this.storageAdapters.set(name, adapter);
+  }
+  rebuildIndices(collection) {
+    const items = this.items.get(collection.name);
+    if (!items)
+      throw new Error(`Items not found for collection ${collection.name}`);
+    const indices = this.indices.get(collection.name);
+    if (!indices)
+      throw new Error(`Indices not found for collection ${collection.name}`);
+    indices.forEach((index) => index.rebuild([...items.values()]));
+  }
+  async setupStorageAdapter(collection) {
+    const storageAdapter = this.storageAdapters.get(collection.name);
+    if (!storageAdapter)
+      return;
+    return storageAdapter.setup().then(async () => {
+      const items = await storageAdapter.readAll();
+      this.items.set(collection.name, items.reduce((map, item) => {
+        map.set(serializeValue(item.id), item);
+        return map;
+      }, /* @__PURE__ */ new Map()));
+      this.rebuildIndices(collection);
+    }).catch((error) => {
+      if (!this.options.onError) {
+        console.error(`Error during data persistence operation in collection ${collection.name}`, error);
+        return;
+      }
+      this.options.onError(collection.name, error instanceof Error ? error : new Error(error));
+    });
+  }
+  getIndexInfo(collection, selector) {
+    if (selector != null && Object.keys(selector).length === 1 && "id" in selector && typeof selector.id !== "object") {
+      return {
+        matched: true,
+        ids: [serializeValue(selector.id)],
+        optimizedSelector: {}
+      };
+    }
+    if (selector == null) {
+      return {
+        matched: false,
+        ids: [],
+        optimizedSelector: {}
+      };
+    }
+    return getIndexInfo((this.indices.get(collection.name) ?? []).map((i) => i.query.bind(i)), selector);
+  }
+  applyIndexDeltas(collection, changes) {
+    const indices = this.indices.get(collection.name) ?? [];
+    for (const index of indices) {
+      if (changes.modified)
+        index.update(changes.modified);
+      if (changes.added && changes.added.length > 0)
+        index.insert(changes.added);
+      if (changes.removed && changes.removed.length > 0)
+        index.remove(changes.removed);
+    }
+  }
+  getItem(collection, selector) {
+    const memory = this.items.get(collection.name) ?? /* @__PURE__ */ new Map();
+    const indexInfo = this.getIndexInfo(collection, selector);
+    const items = indexInfo.matched ? indexInfo.ids.map((id) => memory.get(serializeValue(id))).filter((i) => i != null) : [...memory.values()];
+    const item = items.find((document) => match(document, selector));
+    return item;
+  }
+  queryItems(collection, selector) {
+    const indexInfo = this.getIndexInfo(collection, selector);
+    const matchItems = (item) => {
+      if (indexInfo.optimizedSelector == null)
+        return true;
+      if (Object.keys(indexInfo.optimizedSelector).length <= 0)
+        return true;
+      const matches = match(item, indexInfo.optimizedSelector);
+      return matches;
+    };
+    const items = this.items.get(collection.name);
+    if (!indexInfo.matched) {
+      if (isEqual(selector, {}))
+        return [...items.values()];
+      return [...items.values()].filter(matchItems);
+    }
+    const foundItems = indexInfo.ids.map((ids) => items.get(serializeValue(ids))).filter((i) => i != null);
+    if (isEqual(indexInfo.optimizedSelector, {}))
+      return foundItems;
+    return foundItems.filter(matchItems);
+  }
+  executeQuery(collection, selector, options) {
+    const items = this.queryItems(collection, selector || {});
+    const { sort, skip, limit, fields } = options || {};
+    const sorted = sort ? sortItems(items, sort) : items;
+    const skipped = skip ? sorted.slice(skip) : sorted;
+    const limited = limit ? skipped.slice(0, limit) : skipped;
+    const idExcluded = fields && fields.id === 0;
+    return limited.map((item) => {
+      if (!fields)
+        return item;
+      return {
+        ...idExcluded ? {} : { id: item.id },
+        ...project(item, fields)
+      };
+    });
+  }
+  flushQueuedQueryUpdates(collection) {
+    if (!this.queuedQueryUpdates.get(collection.name))
+      return;
+    const changes = this.queuedQueryUpdates.get(collection.name);
+    if (!changes || !hasPendingUpdates(changes))
+      return;
+    this.queuedQueryUpdates.set(collection.name, { added: [], modified: [], removed: [] });
+    const flatItems = [...changes.added, ...changes.modified, ...changes.removed];
+    const queries = [...this.activeQueries.get(collection.name)?.values() ?? []].filter(({ selector }) => flatItems.some((item) => match(item, selector)));
+    queries.forEach(({ selector, options }) => {
+      const emitter = this.queryEmitters.get(collection.name);
+      if (!emitter)
+        return;
+      emitter.emit("change", selector, options, "complete");
+    });
+  }
+  updateQueries(collection, changes) {
+    this.queuedQueryUpdates.set(collection.name, this.queuedQueryUpdates.get(collection.name) || { added: [], modified: [], removed: [] });
+    this.queuedQueryUpdates.get(collection.name)?.added.push(...changes.added);
+    this.queuedQueryUpdates.get(collection.name)?.modified.push(...changes.modified);
+    this.queuedQueryUpdates.get(collection.name)?.removed.push(...changes.removed);
+    this.flushQueuedQueryUpdates(collection);
+  }
+  createCollectionBackend(collection, indices) {
+    this.ensureStorageAdapter(collection.name);
+    this.items.set(collection.name, this.items.get(collection.name) ?? /* @__PURE__ */ new Map());
+    this.queryEmitters.set(collection.name, this.queryEmitters.get(collection.name) ?? new EventEmitter());
+    this.activeQueries.set(collection.name, this.activeQueries.get(collection.name) || /* @__PURE__ */ new Map());
+    this.indices.set(collection.name, indices.map((field) => createIndex(field)));
+    this.rebuildIndices(collection);
+    const persistenceReadyPromise = this.setupStorageAdapter(collection);
+    const backend = {
+      // CRUD operations
+      insert: async (newItem) => {
+        const items = this.items.get(collection.name);
+        if (!items)
+          throw new Error(`Items not found for collection ${collection.name}`);
+        if (items.has(serializeValue(newItem.id))) {
+          throw new Error(`Item with id '${newItem.id}' already exists`);
+        }
+        this.items.get(collection.name)?.set(serializeValue(newItem.id), newItem);
+        await this.storageAdapters.get(collection.name)?.insert([newItem]);
+        this.applyIndexDeltas(collection, { added: [newItem] });
+        this.updateQueries(collection, {
+          added: [],
+          modified: [newItem],
+          removed: []
+        });
+        return newItem;
+      },
+      updateOne: async (selector, modifier) => {
+        const { $setOnInsert, ...restModifier } = modifier;
+        const item = this.getItem(collection, selector);
+        if (item == null)
+          return [];
+        const modifiedItem = modify(deepClone(item), restModifier);
+        const hasItemWithSameId = item.id !== modifiedItem.id && this.getItem(collection, { id: modifiedItem.id }) != null;
+        if (hasItemWithSameId) {
+          throw new Error(`Item with id '${modifiedItem.id}' already exists`);
+        }
+        this.items.get(collection.name)?.set(serializeValue(modifiedItem.id), modifiedItem);
+        await this.storageAdapters.get(collection.name)?.replace([modifiedItem]);
+        this.applyIndexDeltas(collection, { modified: [{ oldItem: item, newItem: modifiedItem }] });
+        this.updateQueries(collection, {
+          added: [],
+          modified: [modifiedItem],
+          removed: []
+        });
+        return [modifiedItem];
+      },
+      updateMany: async (selector, modifier) => {
+        const { $setOnInsert, ...restModifier } = modifier;
+        const items = backend.getQueryResult(selector);
+        const changedItems = items.map((item) => {
+          const modifiedItem = modify(deepClone(item), restModifier);
+          const hasItemWithSameId = item.id !== modifiedItem.id && this.getItem(collection, { id: modifiedItem.id }) != null;
+          if (hasItemWithSameId) {
+            throw new Error(`Item with id '${modifiedItem.id}' already exists`);
+          }
+          return modifiedItem;
+        });
+        changedItems.forEach((item) => {
+          this.items.get(collection.name)?.set(serializeValue(item.id), item);
+        });
+        await this.storageAdapters.get(collection.name)?.replace(changedItems);
+        const pairs = items.map((oldItem, index) => ({ oldItem, newItem: changedItems[index] }));
+        this.applyIndexDeltas(collection, { modified: pairs });
+        this.updateQueries(collection, {
+          added: [],
+          modified: changedItems,
+          removed: []
+        });
+        return changedItems;
+      },
+      replaceOne: async (selector, replacement) => {
+        const item = this.getItem(collection, selector);
+        if (item == null)
+          return [];
+        const hasItemWithSameId = item.id !== replacement.id && replacement.id != null && this.getItem(collection, { id: replacement.id }) != null;
+        if (hasItemWithSameId) {
+          throw new Error(`Item with id '${replacement.id}' already exists`);
+        }
+        const modifiedItem = { id: item.id, ...replacement };
+        this.items.get(collection.name)?.set(serializeValue(modifiedItem.id), modifiedItem);
+        await this.storageAdapters.get(collection.name)?.replace([modifiedItem]);
+        this.applyIndexDeltas(collection, { modified: [{ oldItem: item, newItem: modifiedItem }] });
+        this.updateQueries(collection, {
+          added: [],
+          modified: [modifiedItem],
+          removed: []
+        });
+        return [modifiedItem];
+      },
+      removeOne: async (selector) => {
+        const item = this.getItem(collection, selector);
+        if (item == null)
+          return [];
+        this.items.get(collection.name)?.delete(serializeValue(item.id));
+        await this.storageAdapters.get(collection.name)?.remove([item]);
+        this.applyIndexDeltas(collection, { removed: [item] });
+        this.updateQueries(collection, {
+          added: [],
+          modified: [],
+          removed: [item]
+        });
+        return [item];
+      },
+      removeMany: async (selector) => {
+        const items = backend.getQueryResult(selector);
+        items.forEach((item) => {
+          this.items.get(collection.name)?.delete(serializeValue(item.id));
+        });
+        await this.storageAdapters.get(collection.name)?.remove(items);
+        this.applyIndexDeltas(collection, { removed: items });
+        this.updateQueries(collection, {
+          added: [],
+          modified: [],
+          removed: items
+        });
+        return items;
+      },
+      // methods for registering and unregistering queries that will be called from the collection during find/findOne
+      registerQuery: (selector, options) => {
+        this.activeQueries.set(collection.name, this.activeQueries.get(collection.name) || /* @__PURE__ */ new Map());
+        this.activeQueries.get(collection.name)?.set(queryId(selector, options), {
+          selector,
+          options
+        });
+        const emitter = this.queryEmitters.get(collection.name);
+        if (!emitter)
+          throw new Error(`Query emitter not found for collection ${collection.name}`);
+        emitter.emit("change", selector, options, "complete");
+      },
+      unregisterQuery: (selector, options) => {
+        if (!this.activeQueries.get(collection.name))
+          return;
+        this.activeQueries.get(collection.name)?.delete(queryId(selector, options));
+      },
+      getQueryState: () => "complete",
+      onQueryStateChange: (selector, options, callback) => {
+        const emitter = this.queryEmitters.get(collection.name);
+        if (!emitter)
+          throw new Error(`Query emitter not found for collection ${collection.name}`);
+        const handler = (querySelector, queryOptions, state) => {
+          if (querySelector !== selector || queryOptions !== options)
+            return;
+          callback(state);
+        };
+        emitter.on("change", handler);
+        return () => {
+          emitter.off("change", handler);
+        };
+      },
+      getQueryError: () => null,
+      getQueryResult: (selector, options) => {
+        const result = this.executeQuery(collection, selector, options);
+        const isQueryActive = this.activeQueries.get(collection.name)?.has(queryId(selector, options));
+        if (isQueryActive) {
+          this.cachedQueryResults.set(collection.name, this.cachedQueryResults.get(collection.name) || /* @__PURE__ */ new Map());
+          this.cachedQueryResults.get(collection.name)?.set(queryId(selector, options), result);
+        }
+        return result;
+      },
+      // lifecycle methods
+      dispose: async () => {
+        const adapter = this.storageAdapters.get(collection.name);
+        if (adapter?.teardown)
+          await adapter.teardown();
+        this.storageAdapters.delete(collection.name);
+        this.items.delete(collection.name);
+        this.indices.delete(collection.name);
+        this.activeQueries.delete(collection.name);
+        this.queryEmitters.delete(collection.name);
+        this.queuedQueryUpdates.delete(collection.name);
+        this.cachedQueryResults.delete(collection.name);
+      },
+      isReady: () => persistenceReadyPromise
+    };
+    return backend;
+  }
 }
 export {
-  randomId as default
+  DefaultDataAdapter as default
 };