@signaldb/core 1.7.1 → 2.0.0-beta.1

package/dist/index14.mjs

@@ -1,74 +1,185 @@
-import createIndexProvider from "./index6.mjs";
-import get from "./index24.mjs";
-import getMatchingKeys from "./index28.mjs";
-import serializeValue from "./index20.mjs";
-function createExternalIndex(field, index) {
-  return createIndexProvider({
-    query(selector) {
-      if (!Object.hasOwnProperty.call(selector, field)) {
-        return { matched: false };
-      }
-      const fieldSelector = selector[field];
-      const filteresForNull = fieldSelector == null || fieldSelector.$exists === false;
-      const keys = filteresForNull ? { include: null, exclude: [...index.keys()].filter((key) => key != null) } : getMatchingKeys(field, selector);
-      if (keys.include == null && keys.exclude == null)
-        return { matched: false };
-      let includedPositions = [];
-      if (keys.include == null) {
-        for (const set of index.values()) {
-          for (const pos of set) {
-            includedPositions.push(pos);
-          }
-        }
-      } else {
-        for (const key of keys.include) {
-          const posSet = index.get(key);
-          if (posSet) {
-            for (const pos of posSet) {
-              includedPositions.push(pos);
-            }
-          }
-        }
-      }
-      if (keys.exclude != null) {
-        const excludeSet = /* @__PURE__ */ new Set();
-        for (const key of keys.exclude) {
-          const posSet = index.get(key);
-          if (posSet) {
-            for (const pos of posSet) {
-              excludeSet.add(pos);
-            }
-          }
+import queryId from "./index20.mjs";
+import randomId from "./index8.mjs";
+import batchOnNextTick from "./index27.mjs";
+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);
         }
-        includedPositions = includedPositions.filter((pos) => !excludeSet.has(pos));
-      }
-      return {
-        matched: true,
-        positions: includedPositions,
-        fields: [field],
-        keepSelector: filteresForNull
       };
-    },
-    rebuild() {
+      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;
     }
-  });
-}
-function createIndex(field) {
-  const index = /* @__PURE__ */ new Map();
-  return {
-    ...createExternalIndex(field, index),
-    rebuild(items) {
-      index.clear();
-      items.forEach((item, i) => {
-        const value = serializeValue(get(item, field));
-        const current = index.get(value) || /* @__PURE__ */ new Set();
-        current.add(i);
-        index.set(value, current);
-      });
+    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: [],
+      ...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);
+      },
+      unregisterQuery: (selector, options) => {
+        this.queries[collection.name]?.delete(queryId(selector, options));
+        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) => {
+        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 });
+          callback(state);
+        };
+        this.worker.addEventListener("message", handler);
+        return () => {
+          this.worker.removeEventListener("message", handler);
+        };
+      },
+      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);
+      }
+    };
+  }
 }
 export {
-  createExternalIndex,
-  createIndex as default
+  WorkerDataAdapter as default
 };

package/dist/index15.mjs

@@ -1,11 +1,387 @@
-import { sort } from "fast-sort";
-import get from "./index24.mjs";
-function sortItems(items, sortFields) {
-  return sort(items).by(Object.entries(sortFields).map(([key, value]) => {
-    const order = value === 1 ? "asc" : "desc";
-    return { [order]: (i) => get(i, key) };
-  }));
+import deepClone from "./index19.mjs";
+import match from "./index23.mjs";
+import modify from "./index7.mjs";
+import queryId from "./index20.mjs";
+import isEqual from "./index6.mjs";
+import getIndexInfo from "./index22.mjs";
+import getMatchingKeys from "./index26.mjs";
+import sortItems from "./index25.mjs";
+import project from "./index24.mjs";
+import compact from "./index28.mjs";
+class WorkerDataAdapterHost {
+  workerContext;
+  options;
+  id;
+  log = () => {
+  };
+  storageAdapters = /* @__PURE__ */ new Map();
+  storageAdapterReady = /* @__PURE__ */ new Map();
+  collectionIndices = /* @__PURE__ */ new Map();
+  queries = /* @__PURE__ */ new Map();
+  onError = (error) => {
+    console.error(error);
+  };
+  constructor(workerContext, options) {
+    this.workerContext = workerContext;
+    this.options = options;
+    this.id = this.options.id || "default-worker-data-adapter";
+    if (this.options.onError) {
+      this.onError = this.options.onError;
+    }
+    if (this.options.log)
+      this.log = this.options.log;
+    if (typeof addEventListener === "undefined" || typeof postMessage === "undefined") {
+      throw new TypeError("WorkerDataAdapterHost can only be used in a Web Worker context");
+    }
+    this.workerContext.addEventListener("message", async (event) => {
+      try {
+        const { workerId, id, method, args } = event.data;
+        await this.handleMessage(workerId, id, method, args);
+      } catch (error) {
+        this.onError(error);
+      }
+    });
+    this.respond("ready", null, null, "ready");
+  }
+  respond(id, data, error = null, type = "response") {
+    this.workerContext.postMessage({ id, workerId: this.id, type, data, error });
+  }
+  async handleMessage(workerId, id, method, args) {
+    if (workerId !== this.id)
+      return;
+    const fn = this[method];
+    if (typeof fn !== "function") {
+      this.respond(id, null, new Error(`Method ${method} not found`));
+      return;
+    }
+    this.log(method, ...args);
+    await this.isReady(args[0]);
+    try {
+      const result = await fn.apply(this, args);
+      this.respond(id, result);
+    } catch (error) {
+      this.respond(id, null, error);
+    }
+  }
+  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: compact([selector.id]),
+        optimizedSelector: {}
+      };
+    }
+    if (selector == null) {
+      return {
+        matched: false,
+        ids: [],
+        optimizedSelector: {}
+      };
+    }
+    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 storageAdapter.readIndex(field);
+      const fieldSelector = flatSelector[field];
+      const filteresForNull = fieldSelector == null || fieldSelector.$exists === false;
+      const keys = filteresForNull ? { 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: filteresForNull
+      };
+    }), selector);
+  }
+  async queryItems(collectionName, selector) {
+    const storageAdapter = this.storageAdapters.get(collectionName);
+    if (!storageAdapter)
+      throw new Error(`No persistence adapter for collection ${collectionName}`);
+    const indexInfo = await this.getIndexInfo(collectionName, 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;
+    };
+    if (indexInfo.matched) {
+      const items = await storageAdapter.readIds(indexInfo.ids);
+      if (isEqual(indexInfo.optimizedSelector, {}))
+        return items;
+      return items.filter(matchItems);
+    } else {
+      const allItems = await storageAdapter.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)
+      };
+    });
+  }
+  ensureQuery(collectionName, selector, options) {
+    const id = queryId(selector, options);
+    if (!this.queries.get(collectionName)) {
+      throw new Error(`Collection ${collectionName} not initialized!`);
+    }
+    let query = this.queries.get(collectionName)?.get(id);
+    if (!query) {
+      query = { selector, options };
+      this.queries.get(collectionName)?.set(id, query);
+    }
+    return query;
+  }
+  emitQueryUpdate(collectionName, selector, options, state, error, items) {
+    const id = queryId(selector, options);
+    const collectionQueries = this.queries.get(collectionName);
+    if (!collectionQueries)
+      throw new Error(`Collection ${collectionName} not initialized!`);
+    this.respond(id, { collectionName, selector, options, state, error, items }, null, "queryUpdate");
+  }
+  ensureStorageAdapter(name) {
+    if (this.storageAdapters.has(name))
+      return;
+    const adapter = this.options.storage(name);
+    if (!adapter)
+      return;
+    this.storageAdapters.set(name, adapter);
+  }
+  async checkQueryUpdates(collectionName, items) {
+    const queries = this.queries.get(collectionName);
+    if (!queries)
+      throw new Error(`Collection ${collectionName} not initialized!`);
+    const affectedQueries = [...queries.values()].filter(({ selector }) => items.some((item) => match(item, selector))) ?? [];
+    if (affectedQueries.length === 0)
+      return;
+    affectedQueries.forEach(({ selector, options }) => {
+      this.emitQueryUpdate(collectionName, selector, options, "active", null);
+    });
+    await Promise.all(affectedQueries.map(async ({ selector, options }) => {
+      const queryItems = await this.executeQuery(collectionName, selector, options);
+      this.emitQueryUpdate(collectionName, selector, options, "complete", null, queryItems);
+    }));
+  }
+  registerCollection = async (collectionName, indices) => {
+    this.collectionIndices.set(collectionName, indices);
+    this.queries.set(collectionName, /* @__PURE__ */ new Map());
+    this.ensureStorageAdapter(collectionName);
+    const storageAdapter = this.storageAdapters.get(collectionName);
+    if (!storageAdapter)
+      throw new Error(`No persistence adapter for collection ${collectionName}`);
+    const setupPromise = (async () => {
+      await Promise.all(indices.map((index) => storageAdapter.createIndex(index)));
+      await storageAdapter.setup();
+    })();
+    this.storageAdapterReady.set(collectionName, setupPromise);
+    await setupPromise;
+  };
+  unregisterCollection = async (collectionName) => {
+    this.storageAdapters.delete(collectionName);
+    this.queries.delete(collectionName);
+  };
+  registerQuery = async (collectionName, selector, options) => {
+    this.ensureQuery(collectionName, selector, options);
+    const queryItems = await this.executeQuery(collectionName, selector, options);
+    this.emitQueryUpdate(collectionName, selector, options, "complete", null, queryItems);
+  };
+  unregisterQuery = async (collectionName, selector, options) => {
+    const id = queryId(selector, options);
+    if (!this.queries.get(collectionName))
+      throw new Error(`Collection ${collectionName} not initialized!`);
+    this.queries.get(collectionName)?.delete(id);
+  };
+  insert = async (collectionName, input) => {
+    const storageAdapter = this.storageAdapters.get(collectionName);
+    if (!storageAdapter)
+      throw new Error(`No persistence adapter for collection ${collectionName}`);
+    const existingItems = await this.executeQuery(collectionName, { id: { $in: input.map((i) => i[0].id) } });
+    const result = input.map(([item]) => {
+      if (item.id == null)
+        throw new Error("Item must have an id");
+      if (existingItems.some((existing) => existing.id === item.id)) {
+        return new Error(`Item with id ${item.id} already exists`);
+      }
+      return item;
+    });
+    const newItems = result.filter((item) => !(item instanceof Error));
+    await storageAdapter.insert(newItems);
+    await this.checkQueryUpdates(collectionName, newItems);
+    return result;
+  };
+  updateOne = async (collectionName, parameters) => {
+    const storageAdapter = this.storageAdapters.get(collectionName);
+    if (!storageAdapter)
+      throw new Error(`No persistence adapter for collection ${collectionName}`);
+    const previousItems = [];
+    const result = await Promise.all(parameters.map(async ([selector, modifier]) => {
+      const item = await this.executeQuery(collectionName, selector, { limit: 1 }).then((items) => items[0] ?? null);
+      const { $setOnInsert, ...restModifier } = modifier;
+      if (item == null)
+        return [];
+      previousItems.push(item);
+      const modifiedItem = modify(deepClone(item), restModifier);
+      if (item.id !== modifiedItem.id) {
+        const existingItems = await this.executeQuery(collectionName, { id: modifiedItem.id }, { limit: 1 });
+        if (existingItems.length > 0) {
+          return new Error(`Item with id ${modifiedItem.id} already exists`);
+        }
+      }
+      return [modifiedItem];
+    }));
+    const modifiedItems = compact(result.filter((item) => !(item instanceof Error)).flat());
+    if (modifiedItems.length > 0) {
+      await storageAdapter.replace(modifiedItems);
+      await this.checkQueryUpdates(collectionName, [...modifiedItems, ...previousItems]);
+    }
+    return result;
+  };
+  updateMany = async (collectionName, parameters) => {
+    const storageAdapter = this.storageAdapters.get(collectionName);
+    if (!storageAdapter)
+      throw new Error(`No persistence adapter for collection ${collectionName}`);
+    const previousItems = [];
+    const result = await Promise.all(parameters.map(async ([selector, modifier]) => {
+      const items = await this.executeQuery(collectionName, selector);
+      if (items.length === 0)
+        return [];
+      const { $setOnInsert, ...restModifier } = modifier;
+      try {
+        const changedItems = await Promise.all(items.map(async (item) => {
+          const modifiedItem = modify(deepClone(item), restModifier);
+          if (item.id !== modifiedItem.id) {
+            const existingItems = await this.executeQuery(collectionName, { id: modifiedItem.id }, { limit: 1 });
+            if (existingItems.length > 0) {
+              throw new Error(`Item with id ${modifiedItem.id} already exists`);
+            }
+          }
+          previousItems.push(item);
+          return modifiedItem;
+        }));
+        return changedItems;
+      } catch (error) {
+        return error;
+      }
+    }));
+    const modifiedItems = compact(result.filter((item) => !(item instanceof Error)).flat());
+    if (modifiedItems.length > 0) {
+      await storageAdapter.replace(modifiedItems);
+      await this.checkQueryUpdates(collectionName, [...modifiedItems, ...previousItems]);
+    }
+    return result;
+  };
+  replaceOne = async (collectionName, parameters) => {
+    const storageAdapter = this.storageAdapters.get(collectionName);
+    if (!storageAdapter)
+      throw new Error(`No persistence adapter for collection ${collectionName}`);
+    const previousItems = [];
+    const result = await Promise.all(parameters.map(async ([selector, replacement]) => {
+      const item = await this.executeQuery(collectionName, selector, { limit: 1 }).then((items) => items[0] ?? null);
+      if (item == null)
+        return [];
+      previousItems.push(item);
+      const modifiedItem = {
+        ...replacement,
+        id: replacement.id ?? item.id
+      };
+      if (item.id !== modifiedItem.id) {
+        const existingItems = await this.executeQuery(collectionName, { id: modifiedItem.id }, { limit: 1 });
+        if (existingItems.length > 0) {
+          return new Error(`Item with id ${modifiedItem.id} already exists`);
+        }
+      }
+      return [modifiedItem];
+    }));
+    const modifiedItems = compact(result.filter((item) => !(item instanceof Error)).flat());
+    if (modifiedItems.length > 0) {
+      await storageAdapter.replace(modifiedItems);
+      await this.checkQueryUpdates(collectionName, [...modifiedItems, ...previousItems]);
+    }
+    return result;
+  };
+  removeOne = async (collectionName, selectors) => {
+    const storageAdapter = this.storageAdapters.get(collectionName);
+    if (!storageAdapter)
+      throw new Error(`No persistence adapter for collection ${collectionName}`);
+    const result = await Promise.all(selectors.map(async ([selector]) => {
+      const item = await this.executeQuery(collectionName, selector, { limit: 1 }).then((items2) => items2[0] ?? null);
+      if (item == null)
+        return [];
+      return [item];
+    }));
+    const items = result.flat();
+    if (items.length > 0) {
+      await storageAdapter.remove(items);
+      await this.checkQueryUpdates(collectionName, items);
+    }
+    return result;
+  };
+  removeMany = async (collectionName, selectors) => {
+    const storageAdapter = this.storageAdapters.get(collectionName);
+    if (!storageAdapter)
+      throw new Error(`No persistence adapter for collection ${collectionName}`);
+    const result = await Promise.all(selectors.map(async ([selector]) => this.executeQuery(collectionName, selector)));
+    const items = result.flat();
+    if (items.length > 0) {
+      await storageAdapter.remove(items);
+      await this.checkQueryUpdates(collectionName, items);
+    }
+    return result;
+  };
+  isReady = async (collectionName) => {
+    return this.storageAdapterReady.get(collectionName);
+  };
 }
 export {
-  sortItems as default
+  WorkerDataAdapterHost as default
 };