@signaldb/core 2.0.0-beta.0 → 2.0.0-beta.10

package/dist/index14.mjs

@@ -1,191 +1,86 @@
-import queryId from "./index24.mjs";
-import randomId from "./index8.mjs";
-class WorkerDataAdapter {
-  worker;
-  options;
-  id;
-  isDisposed = false;
-  workerReady;
-  collectionReady = /* @__PURE__ */ new Map();
-  queries = {};
-  constructor(worker, options) {
-    this.worker = worker;
-    this.options = options;
-    this.id = this.options.id || "default-worker-data-adapter";
-    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;
-        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]
-      });
-    });
-  }
-  queryListeners(collectionName, query, listeners) {
-    if (listeners != null) {
-      return this.updateQuery(collectionName, query, { listeners });
-    }
-    const id = queryId(query.selector, query.options);
-    const collectionQueries = this.queries[collectionName];
-    if (!collectionQueries)
-      return 0;
-    const existing = collectionQueries.get(id);
-    return existing?.listeners || 0;
-  }
-  updateQuery(collectionName, query, update) {
-    const id = queryId(query.selector, query.options);
-    const collectionQueries = this.queries[collectionName];
-    if (!collectionQueries)
-      return;
-    const existing = collectionQueries.get(id);
-    collectionQueries.set(id, {
-      listeners: 0,
-      state: "active",
-      error: null,
-      items: [],
-      ...existing,
-      ...update
-    });
-    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));
-    return {
-      insert: async (item) => {
-        return this.exec("insert", collection.name, item);
-      },
-      updateOne: async (selector, modifier) => {
-        return this.exec("updateOne", collection.name, selector, modifier);
-      },
-      updateMany: async (selector, modifier) => {
-        return this.exec("updateMany", collection.name, selector, modifier);
-      },
-      replaceOne: async (selector, replacement) => {
-        return this.exec("replaceOne", collection.name, selector, replacement);
-      },
-      removeOne: async (selector) => {
-        return this.exec("removeOne", collection.name, selector);
-      },
-      removeMany: async (selector) => {
-        return this.exec("removeMany", collection.name, selector);
-      },
-      // methods for registering and unregistering queries that will be called from the collection during find/findOne
-      registerQuery: (selector, options) => {
-        const listeners = this.queryListeners(collection.name, { selector, options });
-        if (listeners === 0) {
-          this.updateQuery(collection.name, { selector, options }, { state: "active", error: null, items: [] });
-          void this.exec("registerQuery", collection.name, selector, options);
-        }
-        this.queryListeners(collection.name, { selector, options }, listeners + 1);
-      },
-      unregisterQuery: (selector, options) => {
-        setTimeout(() => {
-          const listeners = this.queryListeners(collection.name, { selector, options });
-          const newListeners = Math.max(0, listeners - 1);
-          if (newListeners === 0) {
-            this.queries[collection.name]?.delete(queryId(selector, options));
-            void this.exec("unregisterQuery", collection.name, selector, options);
-          }
-        }, 0);
-      },
-      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 (JSON.stringify(responseSelector) !== JSON.stringify(selector))
-            return;
-          if (JSON.stringify(responseOptions) !== JSON.stringify(options))
-            return;
-          this.updateQuery(collection.name, {
-            selector: responseSelector,
-            options: responseOptions
-          }, { state, error, items });
-          callback(state);
-        };
-        this.worker.addEventListener("message", handler);
-        return () => {
-          this.worker.removeEventListener("message", handler);
-        };
-      },
-      // lifecycle methods
-      dispose: async () => {
-        await this.exec("unregisterCollection", collection.name);
-        this.isDisposed = true;
-        this.worker.terminate();
-      },
-      isReady: async () => {
-        await this.exec("isReady", collection.name);
-      }
-    };
-  }
+import createIndexProvider from "./index9.mjs";
+import get from "./index10.mjs";
+import serializeValue from "./index12.mjs";
+import getMatchingKeys from "./index13.mjs";
+//#region src/createIndex.ts
+/**
+* creates an index for a specific field
+* @param field name of the field
+* @returns an index provider to pass to the `indices` option of the collection constructor
+*/
+function createIndex(field) {
+	const index = /* @__PURE__ */ new Map();
+	const ensureSet = (key) => {
+		let set = index.get(key);
+		if (!set) {
+			set = /* @__PURE__ */ new Set();
+			index.set(key, set);
+		}
+		return set;
+	};
+	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 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 posSet = index.get(key);
+				if (posSet) for (const pos of posSet) includedIds.push(pos);
+			}
+			if (keys.exclude != null) {
+				const excludeIds = /* @__PURE__ */ new Set();
+				for (const key of keys.exclude) {
+					const posSet = index.get(key);
+					if (posSet) for (const pos of posSet) excludeIds.add(pos);
+				}
+				includedIds = includedIds.filter((pos) => !excludeIds.has(pos));
+			}
+			return {
+				matched: true,
+				ids: includedIds,
+				fields: [field],
+				keepSelector: filteresForNull
+			};
+		},
+		rebuild(items) {
+			index.clear();
+			items.forEach((item) => {
+				ensureSet(serializeValue(get(item, field))).add(item.id);
+			});
+		},
+		insert(items) {
+			for (const item of items) ensureSet(serializeValue(get(item, field))).add(item.id);
+		},
+		remove(items) {
+			for (const item of items) {
+				const value = serializeValue(get(item, field));
+				const set = index.get(value);
+				if (!set) continue;
+				set.delete(item.id);
+				if (set.size === 0) index.delete(value);
+			}
+		},
+		update(pairs) {
+			for (const { oldItem, newItem } of pairs) {
+				const oldValue = serializeValue(get(oldItem, field));
+				const newValue = serializeValue(get(newItem, field));
+				if (oldValue === newValue) continue;
+				const oldSet = index.get(oldValue);
+				if (oldSet) {
+					oldSet.delete(oldItem.id);
+					if (oldSet.size === 0) index.delete(oldValue);
+				}
+				ensureSet(newValue).add(newItem.id);
+			}
+		}
+	});
 }
-export {
-  WorkerDataAdapter as default
-};
+//#endregion
+export { createIndex as default };

package/dist/index15.cjs.js

@@ -0,0 +1,15 @@
+//#region src/utils/intersection.ts
+/**
+* Computes the intersection of multiple arrays, returning an array of unique elements
+* that are present in all the input arrays.
+* @template T - The type of elements in the arrays.
+* @param arrays - A variable number of arrays to compute the intersection of.
+* @returns An array containing the unique elements found in all the input arrays.
+*   - If no arrays are provided, returns an empty array.
+*/
+function intersection(...arrays) {
+	if (arrays.length === 0) return [];
+	return [...new Set(arrays.reduce((a, b) => a.filter((c) => b.includes(c))))];
+}
+//#endregion
+exports.default = intersection;

package/dist/index15.mjs

@@ -1,342 +1,15 @@
-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 WorkerDataAdapterHost {
-  workerContext;
-  options;
-  id;
-  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 (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;
-    }
-    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: [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([
-        storageAdapter.createIndex("id"),
-        ...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, newItem) => {
-    const storageAdapter = this.storageAdapters.get(collectionName);
-    if (!storageAdapter)
-      throw new Error(`No persistence adapter for collection ${collectionName}`);
-    const existingItems = await this.executeQuery(collectionName, { id: newItem.id }, { limit: 1 });
-    if (existingItems.length > 0) {
-      throw new Error(`Item with id ${newItem.id} already exists`);
-    }
-    await storageAdapter.insert([newItem]);
-    await this.checkQueryUpdates(collectionName, [newItem]);
-    return newItem;
-  };
-  updateOne = async (collectionName, selector, modifier) => {
-    const storageAdapter = this.storageAdapters.get(collectionName);
-    if (!storageAdapter)
-      throw new Error(`No persistence adapter for collection ${collectionName}`);
-    const item = await this.executeQuery(collectionName, selector, { limit: 1 }).then((items) => items[0] ?? null);
-    const { $setOnInsert, ...restModifier } = modifier;
-    if (item == null)
-      return [];
-    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`);
-      }
-    }
-    await storageAdapter.replace([modifiedItem]);
-    await this.checkQueryUpdates(collectionName, [modifiedItem]);
-    return [modifiedItem];
-  };
-  updateMany = async (collectionName, selector, modifier) => {
-    const storageAdapter = this.storageAdapters.get(collectionName);
-    if (!storageAdapter)
-      throw new Error(`No persistence adapter for collection ${collectionName}`);
-    const items = await this.executeQuery(collectionName, selector);
-    if (items.length === 0)
-      return [];
-    const { $setOnInsert, ...restModifier } = modifier;
-    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`);
-        }
-      }
-      return modifiedItem;
-    }));
-    await storageAdapter.replace(changedItems);
-    await this.checkQueryUpdates(collectionName, changedItems);
-    return changedItems;
-  };
-  replaceOne = async (collectionName, selector, replacement) => {
-    const storageAdapter = this.storageAdapters.get(collectionName);
-    if (!storageAdapter)
-      throw new Error(`No persistence adapter for collection ${collectionName}`);
-    const item = await this.executeQuery(collectionName, selector, { limit: 1 }).then((items) => items[0] ?? null);
-    if (item == null)
-      return [];
-    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) {
-        throw new Error(`Item with id ${modifiedItem.id} already exists`);
-      }
-    }
-    await storageAdapter.replace([modifiedItem]);
-    await this.checkQueryUpdates(collectionName, [modifiedItem]);
-    return [modifiedItem];
-  };
-  removeOne = async (collectionName, selector) => {
-    const storageAdapter = this.storageAdapters.get(collectionName);
-    if (!storageAdapter)
-      throw new Error(`No persistence adapter for collection ${collectionName}`);
-    const item = await this.executeQuery(collectionName, selector, { limit: 1 }).then((items) => items[0] ?? null);
-    if (item == null)
-      return [];
-    await storageAdapter.remove([item]);
-    await this.checkQueryUpdates(collectionName, [item]);
-    return [item];
-  };
-  removeMany = async (collectionName, selector) => {
-    const storageAdapter = this.storageAdapters.get(collectionName);
-    if (!storageAdapter)
-      throw new Error(`No persistence adapter for collection ${collectionName}`);
-    const items = await this.executeQuery(collectionName, selector);
-    if (items.length === 0)
-      return [];
-    await storageAdapter.remove(items);
-    await this.checkQueryUpdates(collectionName, items);
-    return items;
-  };
-  isReady = async (collectionName) => {
-    return this.storageAdapterReady.get(collectionName);
-  };
+//#region src/utils/intersection.ts
+/**
+* Computes the intersection of multiple arrays, returning an array of unique elements
+* that are present in all the input arrays.
+* @template T - The type of elements in the arrays.
+* @param arrays - A variable number of arrays to compute the intersection of.
+* @returns An array containing the unique elements found in all the input arrays.
+*   - If no arrays are provided, returns an empty array.
+*/
+function intersection(...arrays) {
+	if (arrays.length === 0) return [];
+	return [...new Set(arrays.reduce((a, b) => a.filter((c) => b.includes(c))))];
 }
-export {
-  WorkerDataAdapterHost as default
-};
+//#endregion
+export { intersection as default };