@signaldb/core 1.7.1 → 2.0.0-beta.0

package/dist/index30.mjs

@@ -0,0 +1,43 @@
+const expressionKeys = /* @__PURE__ */ new Set([
+  "$eq",
+  "$gt",
+  "$gte",
+  "$lt",
+  "$lte",
+  "$in",
+  "$nin",
+  "$ne",
+  "$exists",
+  "$not",
+  "$expr",
+  "$jsonSchema",
+  "$mod",
+  "$regex",
+  "$options",
+  "$text",
+  "$where",
+  "$all",
+  "$elemMatch",
+  "$size",
+  "$bitsAllClear",
+  "$bitsAllSet",
+  "$bitsAnyClear",
+  "$bitsAnySet"
+]);
+function isFieldExpression(expression) {
+  if (typeof expression !== "object" || expression == null) {
+    return false;
+  }
+  const keys = Object.keys(expression);
+  if (keys.length === 0) {
+    return false;
+  }
+  const hasInvalidKeys = keys.some((key) => !expressionKeys.has(key));
+  if (hasInvalidKeys)
+    return false;
+  const hasValidKeys = keys.every((key) => expressionKeys.has(key));
+  return hasValidKeys;
+}
+export {
+  isFieldExpression as default
+};

package/dist/index31.mjs

@@ -0,0 +1,10 @@
+function uniqueBy(array, fn) {
+  const set = /* @__PURE__ */ new Set();
+  return array.filter((element) => {
+    const value = typeof fn === "function" ? fn(element) : element[fn];
+    return !set.has(value) && set.add(value);
+  });
+}
+export {
+  uniqueBy as default
+};

package/dist/index4.mjs

@@ -1,168 +1,6 @@
-import ReplicatedCollection from "./index23.mjs";
-import createSignal from "./index21.mjs";
-class AutoFetchCollection extends ReplicatedCollection {
-  activeObservers = /* @__PURE__ */ new Map();
-  observerTimeouts = /* @__PURE__ */ new Map();
-  purgeDelay;
-  idQueryCache = /* @__PURE__ */ new Map();
-  itemsCache = /* @__PURE__ */ new Map();
-  fetchQueryItems;
-  triggerReload = null;
-  reactivityAdapter = null;
-  loadingSignals = /* @__PURE__ */ new Map();
-  isFetchingSignal;
-  mergeItems;
-  /**
-   * @param options {Object} - Options for the collection.
-   * @param options.fetchQueryItems {Function} - A function that fetches items from the server. It takes the selector as an argument and returns a promise that resolves to an object with an `items` property.
-   * @param options.purgeDelay {Number} - The delay in milliseconds before purging an item from the cache.
-   */
-  constructor(options) {
-    let triggerRemoteChange;
-    super({
-      ...options,
-      pull: () => Promise.resolve({
-        items: [...this.itemsCache.values()].reduce((memo, items) => {
-          const newItems = [...memo];
-          items.forEach((item) => {
-            const index = newItems.findIndex((i) => i.id === item.id);
-            if (index === -1) {
-              newItems.push(item);
-              return;
-            }
-            newItems[index] = this.mergeItems(newItems[index], item);
-          });
-          return newItems;
-        }, [])
-      }),
-      registerRemoteChange: async (onChange) => {
-        triggerRemoteChange = onChange;
-      }
-    });
-    this.mergeItems = options.mergeItems ?? ((itemA, itemB) => ({ ...itemA, ...itemB }));
-    this.purgeDelay = options.purgeDelay ?? 1e4;
-    this.isFetchingSignal = createSignal(options.reactivity, false);
-    if (!triggerRemoteChange)
-      throw new Error("No triggerRemoteChange method found. Looks like your persistence adapter was not registered");
-    this.triggerReload = triggerRemoteChange;
-    this.reactivityAdapter = options.reactivity ?? null;
-    this.fetchQueryItems = options.fetchQueryItems;
-    this.on("observer.created", (selector) => this.handleObserverCreation(selector ?? {}));
-    this.on("observer.disposed", (selector) => setTimeout(() => this.handleObserverDisposal(selector ?? {}), 100));
-    if (options.registerRemoteChange) {
-      void options.registerRemoteChange(() => this.forceRefetch());
-    }
-  }
-  /**
-   * Registers a query manually that items should be fetched for it
-   * @param selector {Object} Selector of the query
-   */
-  registerQuery(selector) {
-    this.handleObserverCreation(selector);
-  }
-  /**
-   * Unregisters a query manually that items are not fetched anymore for it
-   * @param selector {Object} Selector of the query
-   */
-  unregisterQuery(selector) {
-    this.handleObserverDisposal(selector);
-  }
-  getKeyForSelector(selector) {
-    return JSON.stringify(selector);
-  }
-  async forceRefetch() {
-    return Promise.all([...this.activeObservers.values()].map(({ selector }) => this.fetchSelector(selector))).then(() => {
-    });
-  }
-  fetchSelector(selector) {
-    this.isFetchingSignal.set(true);
-    return this.fetchQueryItems(selector).then((response) => {
-      if (!response.items)
-        throw new Error("AutoFetchCollection currently only works with a full item response");
-      this.itemsCache.set(this.getKeyForSelector(selector), response.items);
-      response.items.forEach((item) => {
-        const queries = this.idQueryCache.get(item.id) ?? [];
-        queries.push(selector);
-        this.idQueryCache.set(item.id, queries);
-      });
-      this.setLoading(selector, true);
-      this.once("persistence.received", () => {
-        this.setLoading(selector, false);
-      });
-      if (!this.triggerReload)
-        throw new Error("No triggerReload method found. Looks like your persistence adapter was not registered");
-      void this.triggerReload();
-    }).catch((error) => {
-      this.emit("persistence.error", error);
-    }).finally(() => {
-      this.isFetchingSignal.set(false);
-    });
-  }
-  handleObserverCreation(selector) {
-    const activeObservers = this.activeObservers.get(this.getKeyForSelector(selector))?.count ?? 0;
-    this.activeObservers.set(this.getKeyForSelector(selector), {
-      selector,
-      count: activeObservers + 1
-    });
-    const timeout = this.observerTimeouts.get(this.getKeyForSelector(selector));
-    if (timeout)
-      clearTimeout(timeout);
-    if (activeObservers === 0)
-      void this.fetchSelector(selector);
-  }
-  handleObserverDisposal(selector) {
-    const currentObservers = this.activeObservers.get(this.getKeyForSelector(selector))?.count ?? 0;
-    const activeObservers = currentObservers - 1;
-    if (activeObservers > 0) {
-      this.activeObservers.set(this.getKeyForSelector(selector), {
-        selector,
-        count: activeObservers
-      });
-      return;
-    }
-    const timeout = this.observerTimeouts.get(this.getKeyForSelector(selector));
-    if (timeout)
-      clearTimeout(timeout);
-    const removeObserver = () => {
-      this.activeObservers.delete(this.getKeyForSelector(selector));
-      this.itemsCache.delete(this.getKeyForSelector(selector));
-      if (!this.triggerReload)
-        throw new Error("No triggerReload method found. Looks like your persistence adapter was not registered");
-      void this.triggerReload();
-    };
-    if (this.purgeDelay === 0) {
-      removeObserver();
-      return;
-    }
-    this.observerTimeouts.set(this.getKeyForSelector(selector), setTimeout(removeObserver, this.purgeDelay));
-  }
-  ensureSignal(selector) {
-    if (!this.reactivityAdapter)
-      throw new Error("No reactivity adapter found");
-    if (!this.loadingSignals.has(this.getKeyForSelector(selector))) {
-      this.loadingSignals.set(this.getKeyForSelector(selector), createSignal(this.reactivityAdapter, false));
-    }
-    return this.loadingSignals.get(this.getKeyForSelector(selector));
-  }
-  setLoading(selector, value) {
-    const signal = this.ensureSignal(selector);
-    signal.set(value);
-  }
-  /**
-   * Indicates wether a query is currently been loaded
-   * ⚡️ this function is reactive!
-   * @param selector {Object} Selector of the query
-   * @returns The loading state
-   */
-  isLoading(selector) {
-    const isPushing = this.isPushing();
-    if (!selector) {
-      return this.isFetchingSignal.get() || isPushing;
-    }
-    const signal = this.ensureSignal(selector);
-    return signal.get() || isPushing;
-  }
+function createStorageAdapter(definition) {
+  return definition;
 }
 export {
-  AutoFetchCollection as default
+  createStorageAdapter as default
 };

package/dist/index5.mjs

@@ -1,68 +1,6 @@
-import createPersistenceAdapter from "./index8.mjs";
-function createTemporaryFallbackExecutor(firstResolvingPromiseFunction, secondResolvingPromiseFunction, options) {
-  const cacheTimeout = options?.cacheTimeout;
-  let isResolved = false;
-  let resolvedValue = null;
-  let timeout = null;
-  let secondaryPromise = null;
-  return (...args) => {
-    if (secondaryPromise == null) {
-      if (timeout) {
-        clearTimeout(timeout);
-        timeout = null;
-      }
-      secondaryPromise = secondResolvingPromiseFunction(...args).then((result) => {
-        {
-          timeout = setTimeout(() => {
-            isResolved = false;
-            resolvedValue = null;
-            secondaryPromise = null;
-          }, cacheTimeout);
-        }
-        isResolved = true;
-        resolvedValue = result;
-        if (options?.onResolve)
-          options.onResolve(resolvedValue);
-        return result;
-      });
-    } else if (isResolved) {
-      return secondaryPromise;
-    }
-    return firstResolvingPromiseFunction(...args);
-  };
-}
-function combinePersistenceAdapters(slowAdapter, fastAdapter) {
-  let handleChange = null;
-  const readExecutor = createTemporaryFallbackExecutor(() => fastAdapter.load(), () => slowAdapter.load(), {
-    cacheTimeout: 100,
-    onResolve: (result) => {
-      if (handleChange)
-        void handleChange();
-      void fastAdapter.save(result.items || [], {
-        added: result.changes?.added || [],
-        modified: result.changes?.modified || [],
-        removed: result.changes?.removed || []
-      });
-    }
-  });
-  return createPersistenceAdapter({
-    async register(onChange) {
-      handleChange = onChange;
-      await Promise.all([slowAdapter.register(onChange), fastAdapter.register(onChange)]);
-    },
-    async load() {
-      const promise = readExecutor();
-      return promise;
-    },
-    async save(items, changes) {
-      await Promise.all([
-        fastAdapter.save(items, changes),
-        slowAdapter.save(items, changes)
-      ]);
-    }
-  });
+function createReactivityAdapter(definition) {
+  return definition;
 }
 export {
-  createTemporaryFallbackExecutor,
-  combinePersistenceAdapters as default
+  createReactivityAdapter as default
 };

package/dist/index6.mjs

@@ -1,6 +1,30 @@
-function createIndexProvider(definition) {
-  return definition;
+function isEqual(a, b) {
+  if (Object.is(a, b))
+    return true;
+  if (a instanceof RegExp && b instanceof RegExp)
+    return a.toString() === b.toString();
+  if (a instanceof Date && b instanceof Date)
+    return a.getTime() === b.getTime();
+  if (typeof a !== "object")
+    return false;
+  if (typeof b !== "object")
+    return false;
+  if (a === null)
+    return false;
+  if (b === null)
+    return false;
+  const aKeys = Object.keys(a);
+  const bKeys = Object.keys(b);
+  if (aKeys.length !== bKeys.length)
+    return false;
+  for (const key of aKeys) {
+    if (!bKeys.includes(key))
+      return false;
+    if (!isEqual(a[key], b[key]))
+      return false;
+  }
+  return true;
 }
 export {
-  createIndexProvider as default
+  isEqual as default
 };

package/dist/index7.mjs

@@ -1,6 +1,13 @@
-function createMemoryAdapter(definition) {
-  return definition;
+import { update } from "mingo";
+import deepClone from "./index19.mjs";
+function modify(item, modifier) {
+  const hasOperators = Object.keys(modifier).some((key) => key.startsWith("$"));
+  if (!hasOperators)
+    return modifier;
+  const clonedItem = deepClone(item);
+  update(clonedItem, modifier);
+  return clonedItem;
 }
 export {
-  createMemoryAdapter as default
+  modify as default
 };

package/dist/index8.mjs

@@ -1,6 +1,6 @@
-function createPersistenceAdapter(definition) {
-  return definition;
+function randomId() {
+  return Array.from({ length: 16 }, () => "abcdefghijklmnopqrstuvwxyz0123456789"[Math.floor(Math.random() * 36)]).join("");
 }
 export {
-  createPersistenceAdapter as default
+  randomId as default
 };

package/dist/index9.mjs

@@ -1,6 +1,134 @@
-function createReactivityAdapter(definition) {
-  return definition;
+class EventEmitter {
+  _maxListeners = 100;
+  /**
+   * We store a set of the listeners for each event.
+   */
+  _listenerStore = /* @__PURE__ */ new Map();
+  setMaxListeners(max) {
+    this._maxListeners = max;
+    return this;
+  }
+  /**
+   * Subscribe to an event with a listener function.
+   * @param eventName The event name (key of E).
+   * @param listener  A function that receives the emitted arguments.
+   * @returns         The emitter instance (for chaining).
+   */
+  on(eventName, listener) {
+    let listenersSet = this._listenerStore.get(eventName);
+    if (!listenersSet) {
+      listenersSet = /* @__PURE__ */ new Set();
+      this._listenerStore.set(eventName, listenersSet);
+    }
+    listenersSet.add(listener);
+    if (listenersSet.size > this._maxListeners) {
+      console.warn(`Possible EventEmitter memory leak detected. ${listenersSet.size} ${String(eventName)} listeners added. Use emitter.setMaxListeners() to increase limit.`);
+    }
+    return this;
+  }
+  /**
+   * Subscribe to an event with a listener function.
+   * @param eventName The event name (key of E).
+   * @param listener  A function that receives the emitted arguments.
+   * @returns         The emitter instance (for chaining).
+   */
+  addListener(eventName, listener) {
+    return this.on(eventName, listener);
+  }
+  /**
+   * Subscribe to an event, handling it only once. Automatically removes
+   * the listener after it fires the first time.
+   * @param eventName The event name (key of E).
+   * @param listener  A function that receives the emitted arguments.
+   * @returns         The emitter instance (for chaining).
+   */
+  once(eventName, listener) {
+    const onceWrapper = ((...args) => {
+      listener(...args);
+      this.off(eventName, onceWrapper);
+    });
+    return this.on(eventName, onceWrapper);
+  }
+  /**
+   * Unsubscribe a previously subscribed listener.
+   * @param eventName The event name (key of E).
+   * @param listener  The original function passed to `on` or `once`.
+   * @returns         The emitter instance (for chaining).
+   */
+  off(eventName, listener) {
+    const listenersSet = this._listenerStore.get(eventName);
+    if (!listenersSet)
+      return this;
+    listenersSet.delete(listener);
+    if (listenersSet.size === 0) {
+      this._listenerStore.delete(eventName);
+    }
+    return this;
+  }
+  /**
+   * Unsubscribe a previously subscribed listener.
+   * @param eventName The event name (key of E).
+   * @param listener  The original function passed to `on` or `once`.
+   * @returns         The emitter instance (for chaining).
+   */
+  removeListener(eventName, listener) {
+    return this.off(eventName, listener);
+  }
+  /**
+   * Emit (dispatch) an event with a variable number of arguments.
+   * @param eventName The event name (key of E).
+   * @param args      The arguments to pass to subscribed listeners.
+   */
+  emit(eventName, ...args) {
+    this.listeners(eventName).forEach((listener) => {
+      listener(...args);
+    });
+  }
+  /**
+   * Returns the array of listener functions currently registered for a given event.
+   * @param eventName The event name (key of E).
+   * @returns         An array of listener functions.
+   */
+  listeners(eventName) {
+    const listenersSet = this._listenerStore.get(eventName);
+    if (!listenersSet)
+      return [];
+    return [...listenersSet.values()];
+  }
+  /**
+   * Returns the number of listeners for a given event.
+   * @param eventName The event name (key of E).
+   * @returns         The number of listeners.
+   */
+  listenerCount(eventName) {
+    const listenersSet = this._listenerStore.get(eventName);
+    return listenersSet ? listenersSet.size : 0;
+  }
+  /**
+   * Removes all listeners for a given event, or all events if none is specified.
+   * @param eventName Optional. If omitted, clears all events’ listeners.
+   * @returns         The emitter instance (for chaining).
+   */
+  removeAllListeners(eventName) {
+    if (eventName === void 0) {
+      for (const [eventName_, listenersSet] of this._listenerStore.entries()) {
+        for (const listener of listenersSet.values()) {
+          this.off(eventName_, listener);
+        }
+      }
+      this._listenerStore.clear();
+    } else {
+      const listenersSet = this._listenerStore.get(eventName);
+      if (listenersSet) {
+        for (const listener of listenersSet.values()) {
+          this.off(eventName, listener);
+        }
+        this._listenerStore.delete(eventName);
+      }
+    }
+    return this;
+  }
 }
 export {
-  createReactivityAdapter as default
+  EventEmitter as default
 };

package/dist/types/IndexProvider.d.ts

@@ -1,21 +1,26 @@
 import type { BaseItem } from '../Collection';
 import type { FlatSelector } from './Selector';
-type IndexResult = {
-    positions: number[];
+export type IndexResult<IdType> = {
+    ids: IdType[];
     fields: string[];
     keepSelector?: boolean;
     matched: true;
 } | {
-    positions?: never;
+    ids?: never;
     fields?: never;
     keepSelector?: never;
     matched: false;
 };
+export type SynchronousQueryFunction<T extends BaseItem<I> = BaseItem, I = any> = (selector: FlatSelector<T>) => IndexResult<I>;
+export type AsynchronousQueryFunction<T extends BaseItem<I> = BaseItem, I = any> = (selector: FlatSelector<T>) => Promise<IndexResult<I>>;
 interface IndexProvider<T extends BaseItem<I> = BaseItem, I = any> {
-    query(selector: FlatSelector<T>): IndexResult;
+    query: SynchronousQueryFunction<T, I>;
     rebuild(items: T[]): void;
+    insert(items: T[]): void;
+    remove(items: T[]): void;
+    update(pairs: {
+        oldItem: T;
+        newItem: T;
+    }[]): void;
 }
-export type LowLevelIndexProvider<T extends BaseItem<I> = BaseItem, I = any> = IndexProvider<T, I> & {
-    _index: Map<string, Set<number>>;
-};
 export default IndexProvider;

package/dist/types/StorageAdapter.d.ts

@@ -0,0 +1,20 @@
+export interface Changeset<T> {
+    added: T[];
+    modified: T[];
+    removed: T[];
+}
+export default interface StorageAdapter<T extends {
+    id: I;
+} & Record<string, any>, I> {
+    setup(): Promise<void>;
+    teardown(): Promise<void>;
+    readAll(): Promise<T[]>;
+    readIds(positions: I[]): Promise<T[]>;
+    createIndex(field: string): Promise<void>;
+    dropIndex(field: string): Promise<void>;
+    readIndex(field: string): Promise<Map<any, Set<I>>>;
+    insert(items: T[]): Promise<void>;
+    replace(items: T[]): Promise<void>;
+    remove(items: T[]): Promise<void>;
+    removeAll(): Promise<void>;
+}

package/dist/utils/objectId.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Generates a unique identifier for the given object.
+ * The same object will always receive the same identifier during its lifetime.
+ * Different objects will receive different identifiers.
+ * @param object - The object to generate an identifier for.
+ * @returns A unique identifier for the object.
+ */
+export default function objectId(object: object): number;

package/dist/utils/queryId.d.ts

@@ -0,0 +1,9 @@
+import type { QueryOptions } from '../DataAdapter';
+import type Selector from '../types/Selector';
+/**
+ * Generates a unique identifier for a query based on its selector and options.
+ * @param selector - The selector object.
+ * @param options - The query options object (optional).
+ * @returns A unique identifier string for the query.
+ */
+export default function queryId(selector: Selector<any>, options?: QueryOptions<any>): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signaldb/core",
-  "version": "1.7.1",
+  "version": "2.0.0-beta.0",
   "description": "SignalDB is a client-side database that provides a simple MongoDB-like interface to the data with first-class typescript support to achieve an optimistic UI. Data persistence can be achieved by using storage providers that store the data through a JSON interface to places such as localStorage.",
   "scripts": {
     "build": "rimraf dist && vite build",

package/dist/AutoFetchCollection.d.ts

@@ -1,60 +0,0 @@
-import type { BaseItem } from './Collection';
-import type { ReplicatedCollectionOptions } from './ReplicatedCollection';
-import ReplicatedCollection from './ReplicatedCollection';
-import type Selector from './types/Selector';
-interface AutoFetchOptions<T extends {
-    id: I;
-} & Record<string, any>, I> {
-    fetchQueryItems: (selector: Selector<T>) => ReturnType<ReplicatedCollectionOptions<T, I>['pull']>;
-    purgeDelay?: number;
-    registerRemoteChange?: (onChange: () => Promise<void>) => Promise<void>;
-    mergeItems?: (itemA: T, itemB: T) => T;
-}
-export type AutoFetchCollectionOptions<T extends BaseItem<I>, I, U = T> = Omit<ReplicatedCollectionOptions<T, I, U>, 'pull' | 'registerRemoteChange'> & AutoFetchOptions<T, I>;
-/**
- * A special collection that automatically fetches items when they are needed.
- */
-export default class AutoFetchCollection<T extends BaseItem<I> = BaseItem, I = any, U = T> extends ReplicatedCollection<T, I, U> {
-    private activeObservers;
-    private observerTimeouts;
-    private purgeDelay;
-    private idQueryCache;
-    private itemsCache;
-    private fetchQueryItems;
-    private triggerReload;
-    private reactivityAdapter;
-    private loadingSignals;
-    private isFetchingSignal;
-    private mergeItems;
-    /**
-     * @param options {Object} - Options for the collection.
-     * @param options.fetchQueryItems {Function} - A function that fetches items from the server. It takes the selector as an argument and returns a promise that resolves to an object with an `items` property.
-     * @param options.purgeDelay {Number} - The delay in milliseconds before purging an item from the cache.
-     */
-    constructor(options: AutoFetchCollectionOptions<T, I, U>);
-    /**
-     * Registers a query manually that items should be fetched for it
-     * @param selector {Object} Selector of the query
-     */
-    registerQuery(selector: Selector<T>): void;
-    /**
-     * Unregisters a query manually that items are not fetched anymore for it
-     * @param selector {Object} Selector of the query
-     */
-    unregisterQuery(selector: Selector<T>): void;
-    private getKeyForSelector;
-    private forceRefetch;
-    private fetchSelector;
-    private handleObserverCreation;
-    private handleObserverDisposal;
-    private ensureSignal;
-    private setLoading;
-    /**
-     * Indicates wether a query is currently been loaded
-     * ⚡️ this function is reactive!
-     * @param selector {Object} Selector of the query
-     * @returns The loading state
-     */
-    isLoading(selector?: Selector<T>): boolean;
-}
-export {};

package/dist/Collection/createIndex.d.ts

@@ -1,15 +0,0 @@
-import type IndexProvider from '../types/IndexProvider';
-import type { BaseItem } from './types';
-/**
- * creates an index for a specific field but uses an external map to store the index
- * @param field name of the field
- * @param index the external map to use for the index
- * @returns an index provider to pass to the `indices` option of the collection constructor
- */
-export declare function createExternalIndex<T extends BaseItem<I> = BaseItem, I = any>(field: string, index: Map<string | undefined | null, Set<number>>): IndexProvider<T, I>;
-/**
- * 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
- */
-export default function createIndex<T extends BaseItem<I> = BaseItem, I = any>(field: string): IndexProvider<T, I>;