@signaldb/core 2.0.0-beta.4 → 2.0.0-beta.6

package/dist/index.mjs

@@ -8,25 +8,28 @@ import { default as default8 } from "./index8.mjs";
 import { default as default9 } from "./index9.mjs";
 import { default as default10 } from "./index10.mjs";
 import { default as default11 } from "./index11.mjs";
-import { default as default12 } from "./index12.mjs";
+import { default as default12, unwrap } from "./index12.mjs";
 import { default as default13 } from "./index13.mjs";
 import { default as default14 } from "./index14.mjs";
 import { default as default15 } from "./index15.mjs";
 import { default as default16 } from "./index16.mjs";
+import { default as default17 } from "./index17.mjs";
 export {
-  default13 as AsyncDataAdapter,
-  default16 as AutoFetchDataAdapter,
+  default14 as AsyncDataAdapter,
+  default17 as AutoFetchDataAdapter,
   default3 as Collection,
   default2 as Cursor,
-  default12 as DefaultDataAdapter,
+  default13 as DefaultDataAdapter,
   default9 as EventEmitter,
-  default14 as WorkerDataAdapter,
-  default15 as WorkerDataAdapterHost,
+  default15 as WorkerDataAdapter,
+  default16 as WorkerDataAdapterHost,
   default5 as createReactivityAdapter,
   default4 as createStorageAdapter,
   default10 as get,
   default6 as isEqual,
   default7 as modify,
   default8 as randomId,
-  default11 as serializeValue
+  default12 as reactiveOrAsync,
+  default11 as serializeValue,
+  unwrap
 };

package/dist/index12.mjs

@@ -1,354 +1,48 @@
-import createIndex from "./index21.mjs";
-import getIndexInfo from "./index22.mjs";
-import deepClone from "./index19.mjs";
-import EventEmitter from "./index9.mjs";
-import isEqual from "./index6.mjs";
-import match from "./index23.mjs";
-import modify from "./index7.mjs";
-import project from "./index24.mjs";
-import queryId from "./index20.mjs";
-import serializeValue from "./index11.mjs";
-import sortItems from "./index25.mjs";
-function hasPendingUpdates(pendingUpdates) {
-  return pendingUpdates.added.length > 0 || pendingUpdates.modified.length > 0 || pendingUpdates.removed.length > 0;
+function unwrap(value) {
+  return (function* () {
+    return yield value;
+  })();
 }
-class DefaultDataAdapter {
-  items = /* @__PURE__ */ new Map();
-  options;
-  storageAdapters = /* @__PURE__ */ new Map();
-  indices = /* @__PURE__ */ new Map();
-  activeQueries = /* @__PURE__ */ new Map();
-  queryEmitters = /* @__PURE__ */ new Map();
-  queuedQueryUpdates = /* @__PURE__ */ new Map();
-  cachedQueryResults = /* @__PURE__ */ new Map();
-  constructor(options) {
-    this.options = options || {};
-  }
-  ensureStorageAdapter(name) {
-    if (this.storageAdapters.get(name))
-      return;
-    if (!this.options.storage)
-      return;
-    const adapter = this.options.storage(name);
-    if (!adapter)
-      return;
-    this.storageAdapters.set(name, adapter);
-  }
-  rebuildIndices(collection) {
-    const items = this.items.get(collection.name);
-    if (!items)
-      throw new Error(`Items not found for collection ${collection.name}`);
-    const indices = this.indices.get(collection.name);
-    if (!indices)
-      throw new Error(`Indices not found for collection ${collection.name}`);
-    indices.forEach((index) => index.rebuild([...items.values()]));
-  }
-  async setupStorageAdapter(collection) {
-    const storageAdapter = this.storageAdapters.get(collection.name);
-    if (!storageAdapter)
-      return;
-    return storageAdapter.setup().then(async () => {
-      const items = await storageAdapter.readAll();
-      this.items.set(collection.name, items.reduce((map, item) => {
-        map.set(serializeValue(item.id), item);
-        return map;
-      }, /* @__PURE__ */ new Map()));
-      this.rebuildIndices(collection);
-    }).catch((error) => {
-      if (!this.options.onError) {
-        console.error(`Error during data persistence operation in collection ${collection.name}`, error);
-        return;
-      }
-      this.options.onError(collection.name, error instanceof Error ? error : new Error(error));
-    });
-  }
-  getIndexInfo(collection, selector) {
-    if (selector != null && Object.keys(selector).length === 1 && "id" in selector && typeof selector.id !== "object") {
-      return {
-        matched: true,
-        ids: [serializeValue(selector.id)],
-        optimizedSelector: {}
-      };
-    }
-    if (selector == null) {
-      return {
-        matched: false,
-        ids: [],
-        optimizedSelector: {}
-      };
+function isThenable(value) {
+  return typeof value === "object" && value !== null && typeof value.then === "function";
+}
+function runReactiveOrAsync(thisArgument, mode, gen) {
+  const a = !!mode?.async;
+  const it = gen.call(thisArgument, a);
+  if (!a) {
+    let step = it.next();
+    while (!step.done) {
+      const y = step.value;
+      if (isThenable(y))
+        throw new Error("Promise yielded in sync flow");
+      step = it.next(y);
     }
-    return getIndexInfo((this.indices.get(collection.name) ?? []).map((i) => i.query.bind(i)), selector);
-  }
-  applyIndexDeltas(collection, changes) {
-    const indices = this.indices.get(collection.name) ?? [];
-    for (const index of indices) {
-      if (changes.modified)
-        index.update(changes.modified);
-      if (changes.added && changes.added.length > 0)
-        index.insert(changes.added);
-      if (changes.removed && changes.removed.length > 0)
-        index.remove(changes.removed);
+    return step.value;
+  }
+  return (async function() {
+    let step = it.next();
+    while (!step.done) {
+      const y = step.value;
+      const v = isThenable(y) ? await y : y;
+      step = it.next(v);
     }
-  }
-  getItem(collection, selector) {
-    const memory = this.items.get(collection.name) ?? /* @__PURE__ */ new Map();
-    const indexInfo = this.getIndexInfo(collection, selector);
-    const items = indexInfo.matched ? indexInfo.ids.map((id) => memory.get(serializeValue(id))).filter((i) => i != null) : [...memory.values()];
-    const item = items.find((document) => match(document, selector));
-    return item;
-  }
-  queryItems(collection, selector) {
-    const indexInfo = this.getIndexInfo(collection, 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;
-    };
-    const items = this.items.get(collection.name);
-    if (!indexInfo.matched) {
-      if (isEqual(selector, {}))
-        return [...items.values()];
-      return [...items.values()].filter(matchItems);
-    }
-    const foundItems = indexInfo.ids.map((ids) => items.get(serializeValue(ids))).filter((i) => i != null);
-    if (isEqual(indexInfo.optimizedSelector, {}))
-      return foundItems;
-    return foundItems.filter(matchItems);
-  }
-  executeQuery(collection, selector, options) {
-    const items = this.queryItems(collection, 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)
-      };
-    });
-  }
-  flushQueuedQueryUpdates(collection) {
-    if (!this.queuedQueryUpdates.get(collection.name))
-      return;
-    const changes = this.queuedQueryUpdates.get(collection.name);
-    if (!changes || !hasPendingUpdates(changes))
-      return;
-    this.queuedQueryUpdates.set(collection.name, { added: [], modified: [], removed: [] });
-    const flatItems = [...changes.added, ...changes.modified, ...changes.removed];
-    const itemIds = new Set(flatItems.map((i) => i.id));
-    const queries = [
-      ...this.activeQueries.get(collection.name)?.values() ?? []
-    ].filter(({ selector, options }) => {
-      const idsInQuery = this.cachedQueryResults.get(collection.name)?.get(queryId(selector, options))?.map((i) => i.id) ?? [];
-      if (idsInQuery.some((id) => itemIds.has(id)))
-        return true;
-      return flatItems.some((item) => match(item, selector));
-    });
-    queries.forEach(({ selector, options }) => {
-      this.executeAndCacheQuery(collection, selector, options);
+    return step.value;
+  })();
+}
+function reactiveOrAsync(gen) {
+  function method(...allArguments) {
+    const last = allArguments.length > 0 ? allArguments.at(-1) : void 0;
+    const hasMode = typeof last === "object" && last !== null && "async" in last;
+    const mode = hasMode ? last : void 0;
+    const parameters = hasMode ? allArguments.slice(0, -1) : allArguments;
+    return runReactiveOrAsync(this, mode, function* (a) {
+      return yield* gen.call(this, a, ...parameters);
     });
   }
-  executeAndCacheQuery(collection, selector, options) {
-    const result = this.executeQuery(collection, selector, options);
-    this.cachedQueryResults.set(collection.name, this.cachedQueryResults.get(collection.name) || /* @__PURE__ */ new Map());
-    this.cachedQueryResults.get(collection.name)?.set(queryId(selector, options), result);
-    const emitter = this.queryEmitters.get(collection.name);
-    if (!emitter)
-      return;
-    emitter.emit("change", selector, options, "complete");
-  }
-  updateQueries(collection, changes) {
-    this.queuedQueryUpdates.set(collection.name, this.queuedQueryUpdates.get(collection.name) || { added: [], modified: [], removed: [] });
-    this.queuedQueryUpdates.get(collection.name)?.added.push(...changes.added);
-    this.queuedQueryUpdates.get(collection.name)?.modified.push(...changes.modified);
-    this.queuedQueryUpdates.get(collection.name)?.removed.push(...changes.removed);
-    this.flushQueuedQueryUpdates(collection);
-  }
-  createCollectionBackend(collection, indices) {
-    this.ensureStorageAdapter(collection.name);
-    this.items.set(collection.name, this.items.get(collection.name) ?? /* @__PURE__ */ new Map());
-    this.queryEmitters.set(collection.name, this.queryEmitters.get(collection.name) ?? new EventEmitter());
-    this.queryEmitters.get(collection.name)?.setMaxListeners(Infinity);
-    this.activeQueries.set(collection.name, this.activeQueries.get(collection.name) || /* @__PURE__ */ new Map());
-    this.indices.set(collection.name, indices.map((field) => createIndex(field)));
-    this.rebuildIndices(collection);
-    const persistenceReadyPromise = this.setupStorageAdapter(collection);
-    const backend = {
-      // CRUD operations
-      insert: async (newItem) => {
-        const items = this.items.get(collection.name);
-        if (!items)
-          throw new Error(`Items not found for collection ${collection.name}`);
-        if (items.has(serializeValue(newItem.id))) {
-          throw new Error(`Item with id '${newItem.id}' already exists`);
-        }
-        this.items.get(collection.name)?.set(serializeValue(newItem.id), newItem);
-        await this.storageAdapters.get(collection.name)?.insert([newItem]);
-        this.applyIndexDeltas(collection, { added: [newItem] });
-        this.updateQueries(collection, {
-          added: [],
-          modified: [newItem],
-          removed: []
-        });
-        return newItem;
-      },
-      updateOne: async (selector, modifier) => {
-        const { $setOnInsert, ...restModifier } = modifier;
-        const item = this.getItem(collection, selector);
-        if (item == null)
-          return [];
-        const modifiedItem = modify(deepClone(item), restModifier);
-        const hasItemWithSameId = item.id !== modifiedItem.id && this.getItem(collection, { id: modifiedItem.id }) != null;
-        if (hasItemWithSameId) {
-          throw new Error(`Item with id '${modifiedItem.id}' already exists`);
-        }
-        this.items.get(collection.name)?.set(serializeValue(modifiedItem.id), modifiedItem);
-        await this.storageAdapters.get(collection.name)?.replace([modifiedItem]);
-        this.applyIndexDeltas(collection, { modified: [{ oldItem: item, newItem: modifiedItem }] });
-        this.updateQueries(collection, {
-          added: [],
-          modified: [modifiedItem],
-          removed: []
-        });
-        return [modifiedItem];
-      },
-      updateMany: async (selector, modifier) => {
-        const { $setOnInsert, ...restModifier } = modifier;
-        const items = this.executeQuery(collection, selector, {});
-        const changedItems = items.map((item) => {
-          const modifiedItem = modify(deepClone(item), restModifier);
-          const hasItemWithSameId = item.id !== modifiedItem.id && this.getItem(collection, { id: modifiedItem.id }) != null;
-          if (hasItemWithSameId) {
-            throw new Error(`Item with id '${modifiedItem.id}' already exists`);
-          }
-          return modifiedItem;
-        });
-        changedItems.forEach((item) => {
-          this.items.get(collection.name)?.set(serializeValue(item.id), item);
-        });
-        await this.storageAdapters.get(collection.name)?.replace(changedItems);
-        const pairs = items.map((oldItem, index) => ({ oldItem, newItem: changedItems[index] }));
-        this.applyIndexDeltas(collection, { modified: pairs });
-        this.updateQueries(collection, {
-          added: [],
-          modified: changedItems,
-          removed: []
-        });
-        return changedItems;
-      },
-      replaceOne: async (selector, replacement) => {
-        const item = this.getItem(collection, selector);
-        if (item == null)
-          return [];
-        const hasItemWithSameId = item.id !== replacement.id && replacement.id != null && this.getItem(collection, { id: replacement.id }) != null;
-        if (hasItemWithSameId) {
-          throw new Error(`Item with id '${replacement.id}' already exists`);
-        }
-        const modifiedItem = { id: item.id, ...replacement };
-        this.items.get(collection.name)?.set(serializeValue(modifiedItem.id), modifiedItem);
-        await this.storageAdapters.get(collection.name)?.replace([modifiedItem]);
-        this.applyIndexDeltas(collection, { modified: [{ oldItem: item, newItem: modifiedItem }] });
-        this.updateQueries(collection, {
-          added: [],
-          modified: [modifiedItem],
-          removed: []
-        });
-        return [modifiedItem];
-      },
-      removeOne: async (selector) => {
-        const item = this.getItem(collection, selector);
-        if (item == null)
-          return [];
-        this.items.get(collection.name)?.delete(serializeValue(item.id));
-        await this.storageAdapters.get(collection.name)?.remove([item]);
-        this.applyIndexDeltas(collection, { removed: [item] });
-        this.updateQueries(collection, {
-          added: [],
-          modified: [],
-          removed: [item]
-        });
-        return [item];
-      },
-      removeMany: async (selector) => {
-        const items = backend.getQueryResult(selector, {});
-        items.forEach((item) => {
-          this.items.get(collection.name)?.delete(serializeValue(item.id));
-        });
-        await this.storageAdapters.get(collection.name)?.remove(items);
-        this.applyIndexDeltas(collection, { removed: items });
-        this.updateQueries(collection, {
-          added: [],
-          modified: [],
-          removed: items
-        });
-        return items;
-      },
-      // methods for registering and unregistering queries that will be called from the collection during find/findOne
-      registerQuery: (selector, options) => {
-        this.activeQueries.set(collection.name, this.activeQueries.get(collection.name) || /* @__PURE__ */ new Map());
-        this.activeQueries.get(collection.name)?.set(queryId(selector, options), {
-          selector,
-          options
-        });
-        this.executeAndCacheQuery(collection, selector, options);
-      },
-      unregisterQuery: (selector, options) => {
-        if (!this.activeQueries.get(collection.name))
-          return;
-        this.activeQueries.get(collection.name)?.delete(queryId(selector, options));
-      },
-      getQueryState: () => "complete",
-      onQueryStateChange: (selector, options, callback) => {
-        const emitter = this.queryEmitters.get(collection.name);
-        if (!emitter)
-          throw new Error(`Query emitter not found for collection ${collection.name}`);
-        const handler = (querySelector, queryOptions, state) => {
-          if (queryId(querySelector, queryOptions) !== queryId(selector, options))
-            return;
-          callback(state);
-        };
-        emitter.on("change", handler);
-        return () => {
-          emitter.off("change", handler);
-        };
-      },
-      getQueryError: () => null,
-      getQueryResult: (selector, options) => {
-        const isQueryActive = this.activeQueries.get(collection.name)?.has(queryId(selector, options));
-        if (isQueryActive) {
-          const results = this.cachedQueryResults.get(collection.name)?.get(queryId(selector, options));
-          if (!results)
-            throw new Error("Cached query results are not defined!");
-          return results;
-        }
-        return this.executeQuery(collection, selector, options);
-      },
-      executeQuery: (selector, options) => Promise.resolve(this.executeQuery(collection, selector, options)),
-      // lifecycle methods
-      dispose: async () => {
-        const adapter = this.storageAdapters.get(collection.name);
-        if (adapter?.teardown)
-          await adapter.teardown();
-        this.storageAdapters.delete(collection.name);
-        this.items.delete(collection.name);
-        this.indices.delete(collection.name);
-        this.activeQueries.delete(collection.name);
-        this.queryEmitters.delete(collection.name);
-        this.queuedQueryUpdates.delete(collection.name);
-        this.cachedQueryResults.delete(collection.name);
-      },
-      isReady: () => persistenceReadyPromise
-    };
-    return backend;
-  }
+  method.generator = gen;
+  return method;
 }
 export {
-  DefaultDataAdapter as default
+  reactiveOrAsync as default,
+  unwrap
 };