@signaldb/core 1.7.0 → 2.0.0-beta.0

package/dist/index13.mjs

@@ -1,139 +1,408 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-class EventEmitter {
-  constructor() {
-    __publicField(this, "_maxListeners", 100);
-    /**
-     * We store a set of the listeners for each event.
-     */
-    __publicField(this, "_listenerStore", /* @__PURE__ */ new Map());
-  }
-  setMaxListeners(max) {
-    this._maxListeners = max;
-    return this;
+import deepClone from "./index19.mjs";
+import match from "./index22.mjs";
+import modify from "./index7.mjs";
+import queryId from "./index24.mjs";
+import isEqual from "./index6.mjs";
+import getIndexInfo from "./index21.mjs";
+import getMatchingKeys from "./index26.mjs";
+import sortItems from "./index25.mjs";
+import project from "./index23.mjs";
+class AsyncDataAdapter {
+  options;
+  id;
+  onError;
+  // Per-collection resources
+  storageAdapters = /* @__PURE__ */ new Map();
+  storageAdapterReady = /* @__PURE__ */ new Map();
+  collectionIndices = /* @__PURE__ */ new Map();
+  // Per-collection query registries
+  queries = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.options = options;
+    this.id = options.id || "async-data-adapter";
+    this.onError = options.onError ?? ((error) => {
+      console.error(error);
+    });
+  }
+  createCollectionBackend(collection, indices) {
+    this.collectionIndices.set(collection.name, indices);
+    this.queries.set(collection.name, /* @__PURE__ */ new Map());
+    this.ensureStorageAdapter(collection.name);
+    const ready = (async () => {
+      try {
+        await this.setupStorage(collection.name, indices);
+      } catch (error) {
+        this.onError(error);
+        throw error;
+      }
+    })();
+    this.storageAdapterReady.set(collection.name, ready);
+    const registerQuery = (selector, options) => {
+      const qid = queryId(selector, options);
+      const registry = this.queries.get(collection.name);
+      if (!registry)
+        throw new Error(`Collection ${collection.name} not initialized!`);
+      registry.set(qid, {
+        selector,
+        options,
+        items: [],
+        listeners: /* @__PURE__ */ new Set(),
+        ...registry.get(qid),
+        state: "active",
+        error: null
+      });
+      void this.fulfillQuery(collection.name, selector, options).catch(this.onError);
+    };
+    const unregisterQuery = (selector, options) => {
+      const qid = queryId(selector, options);
+      this.queries.get(collection.name)?.delete(qid);
+    };
+    const getQueryState = (selector, options) => {
+      const q = this.queries.get(collection.name)?.get(queryId(selector, options));
+      return q?.state ?? "active";
+    };
+    const getQueryError = (selector, options) => {
+      const q = this.queries.get(collection.name)?.get(queryId(selector, options));
+      return q?.error ?? null;
+    };
+    const getQueryResult = (selector, options) => {
+      const q = this.queries.get(collection.name)?.get(queryId(selector, options));
+      return q?.items ?? [];
+    };
+    const onQueryStateChange = (selector, options, callback) => {
+      const qid = queryId(selector, options);
+      const registry = this.queries.get(collection.name);
+      if (!registry)
+        throw new Error(`Collection ${collection.name} not initialized!`);
+      if (!registry.has(qid)) {
+        registry.set(qid, {
+          selector,
+          options,
+          state: "active",
+          error: null,
+          items: [],
+          listeners: /* @__PURE__ */ new Set()
+        });
+      }
+      registry.get(qid)?.listeners.add(callback);
+      return () => registry.get(qid)?.listeners.delete(callback);
+    };
+    return {
+      insert: async (item) => {
+        await ready;
+        const inserted = await this.insert(collection.name, item);
+        return inserted;
+      },
+      updateOne: async (selector, modifier) => {
+        await ready;
+        return this.updateOne(collection.name, selector, modifier);
+      },
+      updateMany: async (selector, modifier) => {
+        await ready;
+        return this.updateMany(collection.name, selector, modifier);
+      },
+      replaceOne: async (selector, replacement) => {
+        await ready;
+        return this.replaceOne(collection.name, selector, replacement);
+      },
+      removeOne: async (selector) => {
+        await ready;
+        return this.removeOne(collection.name, selector);
+      },
+      removeMany: async (selector) => {
+        await ready;
+        return this.removeMany(collection.name, selector);
+      },
+      registerQuery,
+      unregisterQuery,
+      getQueryState,
+      getQueryError,
+      getQueryResult,
+      onQueryStateChange,
+      dispose: async () => {
+        this.storageAdapters.delete(collection.name);
+        this.queries.delete(collection.name);
+        this.collectionIndices.delete(collection.name);
+        this.storageAdapterReady.delete(collection.name);
+      },
+      isReady: async () => {
+        await ready;
+      }
+    };
+  }
+  async setupStorage(collectionName, indices) {
+    const storage = this.storageAdapters.get(collectionName);
+    if (!storage)
+      throw new Error(`No persistence adapter for collection ${collectionName}`);
+    await Promise.all([
+      storage.createIndex("id"),
+      ...indices.map((index) => storage.createIndex(index))
+    ]);
+    await storage.setup();
+  }
+  ensureStorageAdapter(name) {
+    if (this.storageAdapters.has(name))
+      return;
+    const adapter = this.options.storage(name);
+    if (!adapter)
+      return;
+    this.storageAdapters.set(name, adapter);
   }
   /**
-   * Subscribe to an event with a listener function.
-   * @param eventName The event name (key of E).
-   * @param listener  A function that receives the emitted arguments.
-   * @returns         The emitter instance (for chaining).
+   * Compute and publish the result for a specific query
+   * @param collectionName - name of the collection
+   * @param selector - query selector
+   * @param options - query options
    */
-  on(eventName, listener) {
-    let listenersSet = this._listenerStore.get(eventName);
-    if (!listenersSet) {
-      listenersSet = /* @__PURE__ */ new Set();
-      this._listenerStore.set(eventName, listenersSet);
+  async fulfillQuery(collectionName, selector, options) {
+    const qid = queryId(selector, options);
+    const registry = this.queries.get(collectionName);
+    if (!registry)
+      throw new Error(`Collection ${collectionName} not initialized!`);
+    const rec = registry.get(qid);
+    if (!rec)
+      return;
+    this.publishState(collectionName, qid, "active", null);
+    try {
+      const items = await this.executeQuery(collectionName, selector, options);
+      this.publishResult(collectionName, qid, items);
+      this.publishState(collectionName, qid, "complete", null);
+    } catch (error) {
+      this.publishState(collectionName, qid, "error", error);
     }
-    listenersSet.add(listener);
-    if (listenersSet.size > this._maxListeners) {
-      console.warn(`Possible EventEmitter memory leak detected. ${listenersSet.size} ${String(eventName)} listeners added. Use emitter.setMaxListeners() to increase limit.`);
-    }
-    return this;
   }
   /**
-   * Subscribe to an event with a listener function.
-   * @param eventName The event name (key of E).
-   * @param listener  A function that receives the emitted arguments.
-   * @returns         The emitter instance (for chaining).
+   * Notify listeners about state changes and keep the cache updated
+   * @param collectionName - name of the collection
+   * @param qid - query id
+   * @param state - new state
+   * @param error - error if state is 'error', null otherwise
    */
-  addListener(eventName, listener) {
-    return this.on(eventName, listener);
+  publishState(collectionName, qid, state, error) {
+    const rec = this.queries.get(collectionName)?.get(qid);
+    if (!rec)
+      return;
+    rec.state = state;
+    rec.error = error;
+    for (const callback of rec.listeners) {
+      try {
+        callback(state);
+      } catch (error_) {
+        this.onError(error_);
+      }
+    }
   }
-  /**
-   * Subscribe to an event, handling it only once. Automatically removes
-   * the listener after it fires the first time.
-   * @param eventName The event name (key of E).
-   * @param listener  A function that receives the emitted arguments.
-   * @returns         The emitter instance (for chaining).
-   */
-  once(eventName, listener) {
-    const onceWrapper = (...args) => {
-      listener(...args);
-      this.off(eventName, onceWrapper);
-    };
-    return this.on(eventName, onceWrapper);
+  publishResult(collectionName, qid, items) {
+    const rec = this.queries.get(collectionName)?.get(qid);
+    if (!rec)
+      return;
+    rec.items = items;
   }
-  /**
-   * Unsubscribe a previously subscribed listener.
-   * @param eventName The event name (key of E).
-   * @param listener  The original function passed to `on` or `once`.
-   * @returns         The emitter instance (for chaining).
-   */
-  off(eventName, listener) {
-    const listenersSet = this._listenerStore.get(eventName);
-    if (!listenersSet)
-      return this;
-    listenersSet.delete(listener);
-    if (listenersSet.size === 0) {
-      this._listenerStore.delete(eventName);
+  async getIndexInfo(collectionName, selector) {
+    const storage = this.storageAdapters.get(collectionName);
+    if (!storage)
+      throw new Error(`No persistence adapter for collection ${collectionName}`);
+    if (selector != null && Object.keys(selector).length === 1 && "id" in selector && typeof selector.id !== "object") {
+      return { matched: true, ids: [selector.id], optimizedSelector: {} };
+    }
+    if (selector == null) {
+      return { matched: false, ids: [], optimizedSelector: {} };
     }
-    return this;
+    const indices = this.collectionIndices.get(collectionName) ?? [];
+    return getIndexInfo(indices.map((field) => async (flatSelector) => {
+      if (!Object.hasOwnProperty.call(flatSelector, field))
+        return { matched: false };
+      const index = await storage.readIndex(field);
+      const fieldSelector = flatSelector[field];
+      const filtersForNull = fieldSelector == null || fieldSelector.$exists === false;
+      const keys = filtersForNull ? { include: null, exclude: [...index.keys()].filter((key) => key != null) } : getMatchingKeys(field, flatSelector);
+      if (keys.include == null && keys.exclude == null)
+        return { matched: false };
+      let includedIds = [];
+      if (keys.include == null) {
+        for (const set of index.values())
+          for (const pos of set)
+            includedIds.push(pos);
+      } else {
+        for (const key of keys.include) {
+          const idSet = index.get(key);
+          if (idSet)
+            for (const id of idSet)
+              includedIds.push(id);
+        }
+      }
+      if (keys.exclude != null) {
+        const excludeIds = /* @__PURE__ */ new Set();
+        for (const key of keys.exclude) {
+          const idSet = index.get(key);
+          if (idSet)
+            for (const id of idSet)
+              excludeIds.add(id);
+        }
+        includedIds = includedIds.filter((pos) => !excludeIds.has(pos));
+      }
+      return { matched: true, ids: includedIds, fields: [field], keepSelector: filtersForNull };
+    }), selector);
   }
-  /**
-   * Unsubscribe a previously subscribed listener.
-   * @param eventName The event name (key of E).
-   * @param listener  The original function passed to `on` or `once`.
-   * @returns         The emitter instance (for chaining).
-   */
-  removeListener(eventName, listener) {
-    return this.off(eventName, listener);
+  async queryItems(collectionName, selector) {
+    const storage = this.storageAdapters.get(collectionName);
+    if (!storage)
+      throw new Error(`No persistence adapter for collection ${collectionName}`);
+    const index = await this.getIndexInfo(collectionName, selector);
+    const matchItems = (item) => {
+      if (index.optimizedSelector == null)
+        return true;
+      if (Object.keys(index.optimizedSelector).length <= 0)
+        return true;
+      return match(item, index.optimizedSelector);
+    };
+    if (index.matched) {
+      const items = await storage.readIds(index.ids);
+      if (isEqual(index.optimizedSelector, {}))
+        return items;
+      return items.filter(matchItems);
+    } else {
+      const allItems = await storage.readAll();
+      if (isEqual(selector, {}))
+        return allItems;
+      return allItems.filter(matchItems);
+    }
   }
-  /**
-   * Emit (dispatch) an event with a variable number of arguments.
-   * @param eventName The event name (key of E).
-   * @param args      The arguments to pass to subscribed listeners.
-   */
-  emit(eventName, ...args) {
-    this.listeners(eventName).forEach((listener) => {
-      listener(...args);
+  async executeQuery(collectionName, selector, options) {
+    const items = await this.queryItems(collectionName, 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) };
     });
   }
   /**
-   * Returns the array of listener functions currently registered for a given event.
-   * @param eventName The event name (key of E).
-   * @returns         An array of listener functions.
+   * After mutations, recompute and push updates for affected active queries
+   * @param collectionName - name of the collection
+   * @param changedItems - items that were inserted/updated/replaced/removed
    */
-  listeners(eventName) {
-    const listenersSet = this._listenerStore.get(eventName);
-    if (!listenersSet)
-      return [];
-    return [...listenersSet.values()];
+  async checkQueryUpdates(collectionName, changedItems) {
+    const registry = this.queries.get(collectionName);
+    if (!registry)
+      throw new Error(`Collection ${collectionName} not initialized!`);
+    if (registry.size === 0)
+      return;
+    const affected = [...registry.values()].filter(({ selector }) => changedItems.some((item) => match(item, selector)));
+    if (affected.length === 0)
+      return;
+    for (const { selector, options } of affected) {
+      const qid = queryId(selector, options);
+      this.publishState(collectionName, qid, "active", null);
+    }
+    await Promise.all(affected.map(async ({ selector, options }) => {
+      const qid = queryId(selector, options);
+      try {
+        const items = await this.executeQuery(collectionName, selector, options);
+        this.publishResult(collectionName, qid, items);
+        this.publishState(collectionName, qid, "complete", null);
+      } catch (error) {
+        this.publishState(collectionName, qid, "error", error);
+      }
+    }));
   }
-  /**
-   * Returns the number of listeners for a given event.
-   * @param eventName The event name (key of E).
-   * @returns         The number of listeners.
-   */
-  listenerCount(eventName) {
-    const listenersSet = this._listenerStore.get(eventName);
-    return listenersSet ? listenersSet.size : 0;
+  async insert(collectionName, newItem) {
+    const storage = this.storageAdapters.get(collectionName);
+    if (!storage)
+      throw new Error(`No persistence adapter for collection ${collectionName}`);
+    const existing = await this.executeQuery(collectionName, { id: newItem.id }, { limit: 1 });
+    if (existing.length > 0)
+      throw new Error(`Item with id ${String(newItem.id)} already exists`);
+    await storage.insert([newItem]);
+    await this.checkQueryUpdates(collectionName, [newItem]);
+    return newItem;
   }
-  /**
-   * Removes all listeners for a given event, or all events if none is specified.
-   * @param eventName Optional. If omitted, clears all events’ listeners.
-   * @returns         The emitter instance (for chaining).
-   */
-  removeAllListeners(eventName) {
-    if (eventName === void 0) {
-      for (const [eventName_, listenersSet] of this._listenerStore.entries()) {
-        for (const listener of listenersSet.values()) {
-          this.off(eventName_, listener);
-        }
-      }
-      this._listenerStore.clear();
-    } else {
-      const listenersSet = this._listenerStore.get(eventName);
-      if (listenersSet) {
-        for (const listener of listenersSet.values()) {
-          this.off(eventName, listener);
-        }
-        this._listenerStore.delete(eventName);
+  async updateOne(collectionName, selector, modifier) {
+    const storage = this.storageAdapters.get(collectionName);
+    if (!storage)
+      throw new Error(`No persistence adapter for collection ${collectionName}`);
+    const items = await this.executeQuery(collectionName, selector, { limit: 1 });
+    const [item] = items;
+    const { $setOnInsert, ...rest } = modifier;
+    if (item == null)
+      return [];
+    const modified = modify(deepClone(item), rest);
+    if (item.id !== modified.id) {
+      const existing = await this.executeQuery(collectionName, { id: modified.id }, { limit: 1 });
+      if (existing.length > 0)
+        throw new Error(`Item with id ${String(modified.id)} already exists`);
+    }
+    await storage.replace([modified]);
+    await this.checkQueryUpdates(collectionName, [modified]);
+    return [modified];
+  }
+  async updateMany(collectionName, selector, modifier) {
+    const storage = this.storageAdapters.get(collectionName);
+    if (!storage)
+      throw new Error(`No persistence adapter for collection ${collectionName}`);
+    const items = await this.executeQuery(collectionName, selector);
+    if (items.length === 0)
+      return [];
+    const { $setOnInsert, ...rest } = modifier;
+    const changed = await Promise.all(items.map(async (item) => {
+      const modified = modify(deepClone(item), rest);
+      if (item.id !== modified.id) {
+        const existing = await this.executeQuery(collectionName, { id: modified.id }, { limit: 1 });
+        if (existing.length > 0)
+          throw new Error(`Item with id ${String(modified.id)} already exists`);
       }
+      return modified;
+    }));
+    await storage.replace(changed);
+    await this.checkQueryUpdates(collectionName, changed);
+    return changed;
+  }
+  async replaceOne(collectionName, selector, replacement) {
+    const storage = this.storageAdapters.get(collectionName);
+    if (!storage)
+      throw new Error(`No persistence adapter for collection ${collectionName}`);
+    const items = await this.executeQuery(collectionName, selector, { limit: 1 });
+    const [item] = items;
+    if (item == null)
+      return [];
+    const modified = { ...replacement, id: replacement.id ?? item.id };
+    if (item.id !== modified.id) {
+      const existing = await this.executeQuery(collectionName, { id: modified.id }, { limit: 1 });
+      if (existing.length > 0)
+        throw new Error(`Item with id ${String(modified.id)} already exists`);
     }
-    return this;
+    await storage.replace([modified]);
+    await this.checkQueryUpdates(collectionName, [modified]);
+    return [modified];
+  }
+  async removeOne(collectionName, selector) {
+    const storage = this.storageAdapters.get(collectionName);
+    if (!storage)
+      throw new Error(`No persistence adapter for collection ${collectionName}`);
+    const items = await this.executeQuery(collectionName, selector, { limit: 1 });
+    const [item] = items;
+    if (item == null)
+      return [];
+    await storage.remove([item]);
+    await this.checkQueryUpdates(collectionName, [item]);
+    return [item];
+  }
+  async removeMany(collectionName, selector) {
+    const storage = this.storageAdapters.get(collectionName);
+    if (!storage)
+      throw new Error(`No persistence adapter for collection ${collectionName}`);
+    const items = await this.executeQuery(collectionName, selector);
+    if (items.length === 0)
+      return [];
+    await storage.remove(items);
+    await this.checkQueryUpdates(collectionName, items);
+    return items;
   }
 }
 export {
-  EventEmitter as default
+  AsyncDataAdapter as default
 };