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

package/dist/index14.mjs

@@ -1,207 +1,45 @@
-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);
-        }
-      };
-      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);
-      }
-    };
-  }
+import isFieldExpression from "./index12.mjs";
+import serializeValue from "./index13.mjs";
+//#region src/utils/getMatchingKeys.ts
+/**
+* Extracts the matching and excluded keys for a given field in a selector.
+* Supports serialized values and `$in`/`$nin` field expressions for optimization.
+* Returns `null` for include/exclude if the field cannot be optimized.
+* @template T - The type of the items in the selector.
+* @template I - The type of the unique identifier for the items.
+* @param field - The name of the field to extract matching keys for.
+* @param selector - The selector object containing query criteria.
+* @returns An object containing arrays of serialized included and excluded keys,
+*   or `null` if the field cannot be optimized.
+*/
+function getMatchingKeys(field, selector) {
+	const result = {
+		include: null,
+		exclude: null
+	};
+	const fieldSelector = selector[field];
+	if (fieldSelector instanceof RegExp) return result;
+	if (fieldSelector == null) return result;
+	if (isFieldExpression(fieldSelector)) {
+		if (fieldSelector.$ne != null) {
+			result.exclude = [serializeValue(fieldSelector.$ne)];
+			return result;
+		}
+		if (Array.isArray(fieldSelector.$in) && fieldSelector.$in.length > 0) {
+			result.include = fieldSelector.$in.map(serializeValue);
+			return result;
+		}
+		if (Array.isArray(fieldSelector.$nin) && fieldSelector.$nin.length > 0) {
+			result.exclude = fieldSelector.$nin.map(serializeValue);
+			return result;
+		}
+		return {
+			include: null,
+			exclude: null
+		};
+	}
+	result.include = [serializeValue(fieldSelector)];
+	return result;
 }
-export {
-  WorkerDataAdapter as default
-};
+//#endregion
+export { getMatchingKeys as default };

package/dist/index15.cjs.js

@@ -0,0 +1,86 @@
+const require_createIndexProvider = require("./index10.cjs.js");
+const require_get = require("./index11.cjs.js");
+const require_serializeValue = require("./index13.cjs.js");
+const require_getMatchingKeys = require("./index14.cjs.js");
+//#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 require_createIndexProvider.default({
+		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)
+			} : require_getMatchingKeys.default(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(require_serializeValue.default(require_get.default(item, field))).add(item.id);
+			});
+		},
+		insert(items) {
+			for (const item of items) ensureSet(require_serializeValue.default(require_get.default(item, field))).add(item.id);
+		},
+		remove(items) {
+			for (const item of items) {
+				const value = require_serializeValue.default(require_get.default(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 = require_serializeValue.default(require_get.default(oldItem, field));
+				const newValue = require_serializeValue.default(require_get.default(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);
+			}
+		}
+	});
+}
+//#endregion
+exports.default = createIndex;