@signaldb/core 2.0.0-beta.2 → 2.0.0-beta.21

package/dist/index.cjs13.js

@@ -1,419 +0,0 @@
-"use strict";
-const deepClone = require("./index.cjs19.js");
-const match = require("./index.cjs23.js");
-const modify = require("./index.cjs7.js");
-const queryId = require("./index.cjs20.js");
-const isEqual = require("./index.cjs6.js");
-const getIndexInfo = require("./index.cjs22.js");
-const getMatchingKeys = require("./index.cjs26.js");
-const sortItems = require("./index.cjs25.js");
-const project = require("./index.cjs24.js");
-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,
-      executeQuery: async (selector, options) => {
-        await ready;
-        registerQuery(selector, options);
-        const result = getQueryResult(selector, options);
-        unregisterQuery(selector, options);
-        return result;
-      },
-      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 storage.setup();
-    await Promise.all(indices.map((index) => storage.createIndex(index)));
-  }
-  ensureStorageAdapter(name) {
-    if (this.storageAdapters.has(name))
-      return;
-    const adapter = this.options.storage(name);
-    if (!adapter)
-      return;
-    this.storageAdapters.set(name, adapter);
-  }
-  /**
-   * Compute and publish the result for a specific query
-   * @param collectionName - name of the collection
-   * @param selector - query selector
-   * @param options - query options
-   */
-  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);
-    }
-  }
-  /**
-   * 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
-   */
-  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_);
-      }
-    }
-  }
-  publishResult(collectionName, qid, items) {
-    const rec = this.queries.get(collectionName)?.get(qid);
-    if (!rec)
-      return;
-    rec.items = items;
-  }
-  async getIndexInfo(collectionName, selector) {
-    const storageAdapter = this.storageAdapters.get(collectionName);
-    if (!storageAdapter)
-      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].filter(Boolean),
-        optimizedSelector: {}
-      };
-    }
-    if (selector == null) {
-      return {
-        matched: false,
-        ids: [],
-        optimizedSelector: {}
-      };
-    }
-    const indices = this.collectionIndices.get(collectionName) ?? [];
-    return getIndexInfo.default(indices.map((field) => async (flatSelector) => {
-      if (!Object.hasOwnProperty.call(flatSelector, field))
-        return { matched: false };
-      const index = await storageAdapter.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);
-  }
-  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);
-    }
-  }
-  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) };
-    });
-  }
-  /**
-   * 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
-   */
-  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);
-      }
-    }));
-  }
-  async insert(collectionName, newItem) {
-    const storage = this.storageAdapters.get(collectionName);
-    if (!storage)
-      throw new Error(`No persistence adapter for collection ${collectionName}`);
-    const existingItems = await storage.readIds([newItem.id]);
-    if (existingItems.length > 0)
-      throw new Error(`Item with id ${String(newItem.id)} already exists`);
-    await storage.insert([newItem]);
-    await this.checkQueryUpdates(collectionName, [newItem]);
-    return newItem;
-  }
-  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.default(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.default(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`);
-    }
-    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;
-  }
-}
-module.exports = AsyncDataAdapter;

package/dist/index.cjs14.js

@@ -1,206 +0,0 @@
-"use strict";
-const queryId = require("./index.cjs20.js");
-const randomId = require("./index.cjs8.js");
-const batchOnNextTick = require("./index.cjs27.js");
-class WorkerDataAdapter {
-  worker;
-  options;
-  id;
-  isDisposed = false;
-  workerReady;
-  log = () => {
-  };
-  collectionReady = /* @__PURE__ */ new Map();
-  batchExecutionHelpers = /* @__PURE__ */ new Map();
-  queries = {};
-  constructor(worker, options) {
-    this.worker = worker;
-    this.options = options;
-    this.id = this.options.id || "default-worker-data-adapter";
-    if (this.options.log)
-      this.log = this.options.log;
-    this.workerReady = new Promise((resolve, reject) => {
-      const timeoutId = setTimeout(() => {
-        reject(new Error("WorkerDataAdapter initialization timed out"));
-      }, 5e3);
-      const handleMessage = (event) => {
-        const { type, workerId } = event.data;
-        if (workerId !== this.id)
-          return;
-        if (type === "ready") {
-          resolve();
-          clearTimeout(timeoutId);
-          this.worker.removeEventListener("message", handleMessage);
-        }
-      };
-      this.worker.addEventListener("message", handleMessage);
-    });
-  }
-  async exec(method, collectionName, ...args) {
-    await this.workerReady;
-    if (method !== "isReady") {
-      const collectionReady = this.collectionReady.get(collectionName);
-      if (!collectionReady)
-        throw new Error(`Collection "${collectionName}" is not registered in WorkerDataAdapter`);
-      await collectionReady;
-    }
-    if (this.isDisposed) {
-      throw new Error("WorkerDataAdapter is disposed");
-    }
-    return new Promise((resolve, reject) => {
-      const messageId = randomId();
-      const handleMessage = (event) => {
-        const { id, workerId, type, data, error } = event.data;
-        if (workerId !== this.id)
-          return;
-        if (type !== "response")
-          return;
-        if (id !== messageId)
-          return;
-        this.log(method, "result", data ?? error);
-        if (error) {
-          reject(error);
-        } else {
-          resolve(data);
-        }
-        this.worker.removeEventListener("message", handleMessage);
-      };
-      this.worker.addEventListener("message", handleMessage);
-      this.worker.postMessage({
-        id: messageId,
-        workerId: this.id,
-        method,
-        args: [collectionName, ...args]
-      });
-    });
-  }
-  enqueueBatched(collectionName, method, args) {
-    const helper = this.batchExecutionHelpers.get(collectionName);
-    if (!helper)
-      throw new Error(`Collection "${collectionName}" is not registered in WorkerDataAdapter`);
-    return helper.enqueue(method, args);
-  }
-  // ---------- end batching integration ----------
-  updateQuery(collectionName, query, update) {
-    const id = queryId(query.selector, query.options);
-    const collectionQueries = this.queries[collectionName];
-    if (!collectionQueries)
-      return;
-    const existing = collectionQueries.get(id);
-    const newState = {
-      state: "active",
-      error: null,
-      items: [],
-      stateChangeCallbacks: [],
-      eventHandler: existing?.eventHandler,
-      ...existing,
-      ...update
-    };
-    collectionQueries.set(id, newState);
-    this.queries[collectionName] = collectionQueries;
-  }
-  createCollectionBackend(collection, indices) {
-    this.queries[collection.name] = /* @__PURE__ */ new Map();
-    void this.exec("registerCollection", collection.name, indices);
-    this.collectionReady.set(collection.name, this.exec("isReady", collection.name));
-    this.batchExecutionHelpers.set(collection.name, batchOnNextTick(async (method, args) => this.exec(method, collection.name, args)));
-    return {
-      insert: async (item) => {
-        return this.enqueueBatched(collection.name, "insert", [item]);
-      },
-      updateOne: async (selector, modifier) => {
-        return this.enqueueBatched(collection.name, "updateOne", [selector, modifier]);
-      },
-      updateMany: async (selector, modifier) => {
-        return this.enqueueBatched(collection.name, "updateMany", [selector, modifier]);
-      },
-      replaceOne: async (selector, replacement) => {
-        return this.enqueueBatched(collection.name, "replaceOne", [selector, replacement]);
-      },
-      removeOne: async (selector) => {
-        return this.enqueueBatched(collection.name, "removeOne", [selector]);
-      },
-      removeMany: async (selector) => {
-        return this.enqueueBatched(collection.name, "removeMany", [selector]);
-      },
-      // methods for registering and unregistering queries that will be called from the collection during find/findOne
-      registerQuery: (selector, options) => {
-        this.updateQuery(collection.name, { selector, options }, { state: "active", error: null, items: [] });
-        void this.exec("registerQuery", collection.name, selector, options);
-        const handler = (event) => {
-          const { type, data, workerId, error } = event.data;
-          if (type !== "queryUpdate")
-            return;
-          if (data == null)
-            return;
-          const { collectionName, selector: responseSelector, options: responseOptions, state, items } = data;
-          if (workerId !== this.id)
-            return;
-          if (collectionName !== collection.name)
-            return;
-          if (queryId(responseSelector, responseOptions) !== queryId(selector, options))
-            return;
-          this.log("queryUpdate", responseSelector, responseOptions, state, data ?? error);
-          this.updateQuery(collection.name, {
-            selector: responseSelector,
-            options: responseOptions
-          }, { state, error, items });
-          const query = this.queries[collection.name]?.get(queryId(selector, options));
-          if (!query)
-            return;
-          query.stateChangeCallbacks.forEach((callback) => callback(state));
-        };
-        this.worker.addEventListener("message", handler);
-        this.updateQuery(collection.name, { selector, options }, { eventHandler: handler });
-      },
-      unregisterQuery: (selector, options) => {
-        const qid = queryId(selector, options);
-        const query = this.queries[collection.name]?.get(qid);
-        if (query?.eventHandler) {
-          this.worker.removeEventListener("message", query.eventHandler);
-        }
-        this.queries[collection.name]?.delete(qid);
-        void this.exec("unregisterQuery", collection.name, selector, options);
-      },
-      getQueryState: (selector, options) => {
-        const query = this.queries[collection.name]?.get(queryId(selector, options));
-        return query?.state || "active";
-      },
-      getQueryError: (selector, options) => {
-        const query = this.queries[collection.name]?.get(queryId(selector, options));
-        return query?.error || null;
-      },
-      getQueryResult: (selector, options) => {
-        const query = this.queries[collection.name]?.get(queryId(selector, options));
-        return query?.items || [];
-      },
-      onQueryStateChange: (selector, options, callback) => {
-        this.updateQuery(collection.name, { selector, options }, {
-          stateChangeCallbacks: [
-            ...this.queries[collection.name]?.get(queryId(selector, options))?.stateChangeCallbacks || [],
-            callback
-          ]
-        });
-        return () => {
-          const currentCallbacks = this.queries[collection.name]?.get(queryId(selector, options))?.stateChangeCallbacks;
-          if (!currentCallbacks)
-            throw new Error("State change callbacks are not defined!");
-          this.updateQuery(collection.name, { selector, options }, {
-            stateChangeCallbacks: currentCallbacks.filter((existingCallback) => existingCallback !== callback)
-          });
-        };
-      },
-      executeQuery: (selector, options) => this.exec("executeQuery", collection.name, selector, options),
-      // lifecycle methods
-      dispose: async () => {
-        await this.exec("unregisterCollection", collection.name);
-        this.isDisposed = true;
-        this.worker.terminate();
-      },
-      isReady: async () => {
-        await this.exec("isReady", collection.name);
-      }
-    };
-  }
-}
-module.exports = WorkerDataAdapter;