react-smart-query 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,545 @@
+import { QueryKey, QueryFunction, UseQueryOptions } from '@tanstack/react-query';
+import { a as AnyItem, G as GetItemId, S as SortComparator, b as GetItemVersion, c as SmartQueryError, M as MutationType, P as PaginationMode, C as CacheEntry, N as NormalizedList, U as UnifiedNormalizedInfiniteData, Q as QueuedMutation, O as ObserverFn } from './types-XXiTKLnh.js';
+export { A as AsyncStorage, I as InfinitePagedData, d as ObservabilityEvent } from './types-XXiTKLnh.js';
+
+/**
+ * src/utils/smartCompare.ts
+ *
+ * Hybrid 5-tier comparison — short-circuits as early as possible.
+ *
+ * Tier 1  reference equality          O(1)
+ * Tier 2  type / length               O(1)
+ * Tier 3  id-set fingerprint          O(n)   — detects add / remove / reorder
+ * Tier 4  version XOR fingerprint     O(n)   — detects field updates
+ * Tier 5  fast-deep-equal fallback    O(n*f) — schema-less safety net
+ */
+interface SmartCompareOptions {
+    idField?: string;
+    versionField?: string | null;
+}
+interface CompareResult {
+    isEqual: boolean;
+    tier: 1 | 2 | 3 | 4 | 5;
+}
+declare function smartCompare(oldData: unknown, newData: unknown, options?: SmartCompareOptions): CompareResult;
+declare function isDataEqual(oldData: unknown, newData: unknown, options?: SmartCompareOptions): boolean;
+
+/**
+ * src/hooks/useSmartQuery.ts
+ *
+ * Core data-fetching hook — V2.
+ */
+
+interface SmartQueryOptions<TRaw, TData, TItem extends AnyItem = TData extends AnyItem[] ? TData[number] : AnyItem> {
+    queryKey: QueryKey;
+    /**
+     * Fetches raw data from the network.
+     * Automatically wrapped in fetchWithLock — concurrent calls are deduplicated.
+     */
+    queryFn: QueryFunction<TRaw>;
+    /**
+     * Transform the raw API response before caching and exposing to the component.
+     */
+    select?: (raw: TRaw) => TData;
+    /**
+     * Extract a stable string id from a list item.
+     */
+    getItemId?: TData extends AnyItem[] ? GetItemId<TItem> : never;
+    /**
+     * Sort comparator for list data.
+     */
+    sortComparator?: TData extends AnyItem[] ? SortComparator<TItem> : never;
+    /** Cache TTL in ms. Default: 5 minutes. */
+    cacheTtl?: number;
+    /** Maximum items to keep in the normalized list. Default: 1000 */
+    maxItems?: number;
+    /** Optional. Extracts version/timestamp for conflict resolution. */
+    getItemVersion?: TData extends AnyItem[] ? GetItemVersion<TItem> : never;
+    /**
+     * When true, stale cache is never served — waits for a fresh fetch.
+     */
+    strictFreshness?: boolean;
+    /** Data to show when there is no cache and the fetch fails */
+    fallbackData?: TData;
+    /** Smart diff configuration */
+    compareOptions?: SmartCompareOptions;
+    /** Called when a fresh fetch succeeds */
+    onSuccess?: (data: TData) => void;
+    /**
+     * Called when a fetch fails.
+     */
+    onError?: (error: SmartQueryError) => boolean | void;
+    /** Extra TanStack Query options */
+    queryOptions?: Omit<UseQueryOptions<TRaw>, "queryKey" | "queryFn" | "initialData" | "enabled" | "select">;
+}
+interface SmartQueryResult<TData, TItem extends AnyItem = TData extends AnyItem[] ? TData[number] : AnyItem> {
+    data: TData | undefined;
+    isLoading: boolean;
+    isFetching: boolean;
+    isFromCache: boolean;
+    isCacheLoading: boolean;
+    error: SmartQueryError | null;
+    refetch: () => void;
+    addItem: TData extends AnyItem[] ? (item: TItem) => void : never;
+    updateItem: TData extends AnyItem[] ? (item: TItem) => void : never;
+    removeItem: TData extends AnyItem[] ? (id: string) => void : never;
+}
+declare function useSmartQuery<TRaw, TData, TItem extends AnyItem = TData extends AnyItem[] ? TData[number] : AnyItem>(options: SmartQueryOptions<TRaw, TData, TItem>): SmartQueryResult<TData, TItem>;
+declare const invalidateSmartCache: (queryKey: QueryKey) => Promise<void>;
+declare const clearAllSmartCache: () => Promise<void>;
+
+/**
+ * src/hooks/useSmartMutation.ts
+ *
+ * First-class write hook — the companion to useSmartQuery.
+ *
+ * Handles the full mutation lifecycle:
+ *   1. Optimistic update via getSmartQueryActions (instant UI)
+ *   2. API call via mutationFn
+ *   3. On success: optionally update the optimistic item with the server response
+ *   4. On error: automatic rollback of the optimistic update
+ *   5. Offline: enqueue to the persistent mutation queue
+ *
+ * Usage:
+ *   const { mutate, mutateAsync, isLoading, error } = useSmartMutation<Expense>({
+ *     queryKey: ["expenses", tripId],
+ *     mutationType: "ADD_ITEM",
+ *     mutationFn: (expense) => api.post("/expenses", expense),
+ *     getItemId: (e) => e.id,
+ *   });
+ *
+ *   mutate(newExpense); // optimistic + API + queue if offline
+ */
+
+interface SmartMutationOptions<TItem extends AnyItem, TResponse = TItem> {
+    /** The query key this mutation targets — must match the useSmartQuery key */
+    queryKey: readonly unknown[];
+    /** "ADD_ITEM" | "UPDATE_ITEM" | "REMOVE_ITEM" | custom string */
+    mutationType: MutationType | string;
+    /**
+     * The API call. Receives the item and returns the server-confirmed version.
+     * If the app is offline, this is skipped and the mutation is queued.
+     */
+    mutationFn: (item: TItem) => Promise<TResponse>;
+    /**
+     * Extract the stable id from an item.
+     * Used to roll back or replace the optimistic item with the server response.
+     */
+    getItemId: GetItemId<TItem>;
+    /**
+     * Map the server response back to a TItem for the final cache update.
+     * If omitted, the server response is used as-is (assumes TResponse = TItem).
+     */
+    toItem?: (response: TResponse) => TItem;
+    /**
+     * Whether to enqueue the mutation when offline.
+     * Default: true.
+     */
+    enableOfflineQueue?: boolean;
+    /**
+     * Optional entity key for queue coalescing.
+     * Example: (item) => `expense:${item.id}`
+     */
+    getEntityKey?: (item: TItem) => string;
+    /** Called after the API call succeeds */
+    onSuccess?: (response: TResponse, item: TItem) => void;
+    /** Called when the API call fails (after rollback) */
+    onError?: (error: SmartQueryError, item: TItem) => void;
+    /** Check network status — defaults to navigator.onLine on web, true on native */
+    isOnline?: () => boolean;
+}
+interface SmartMutationResult<TItem extends AnyItem> {
+    /** Fire-and-forget mutation */
+    mutate(item: TItem): void;
+    /** Async mutation — resolves after the API call completes */
+    mutateAsync(item: TItem): Promise<void>;
+    isPending: boolean;
+    error: SmartQueryError | null;
+    reset(): void;
+}
+declare function useSmartMutation<TItem extends AnyItem, TResponse = TItem>(options: SmartMutationOptions<TItem, TResponse>): SmartMutationResult<TItem>;
+
+/**
+ * src/hooks/useInfiniteSmartQuery.ts
+ *
+ * Cursor-based infinite scroll hook.
+ */
+
+interface InfiniteSmartQueryOptions<TRaw, TItem extends AnyItem> {
+    queryKey: readonly unknown[];
+    /**
+     * Fetches one page. Receives `pageParam` (the cursor).
+     * First call receives `initialPageParam`.
+     */
+    queryFn: (ctx: {
+        pageParam: unknown;
+    }) => Promise<TRaw>;
+    /**
+     * Extract the cursor for the NEXT page from the raw page response.
+     * Return null when there are no more pages.
+     */
+    getNextCursor: (raw: TRaw) => unknown | null;
+    /**
+     * Transform raw page response → TItem[].
+     * Use to unwrap response envelopes.
+     */
+    select: (raw: TRaw) => TItem[];
+    /** Extract stable string id from an item */
+    getItemId: GetItemId<TItem>;
+    /** Sort order within each page (and across pages) */
+    sortComparator?: SortComparator<TItem>;
+    /** Cursor to use for the first page. Default: undefined */
+    initialPageParam?: unknown;
+    /**
+     * "normalized" (default) -> data: TItem[]
+     * "pages" -> data: { pages: TItem[][] }
+     */
+    paginationMode?: PaginationMode;
+    /** Optional. Inferred from first page if not provided. */
+    pageSize?: number;
+    /** Maximum items to keep in the unified normalized list. Default: 1000 */
+    maxItems?: number;
+    /** Optional. Extracts version/timestamp for conflict resolution. */
+    getItemVersion?: GetItemVersion<TItem>;
+    cacheTtl?: number;
+    strictFreshness?: boolean;
+    onError?: (error: SmartQueryError) => void;
+}
+interface InfiniteSmartQueryResult<TItem extends AnyItem> {
+    /**
+     * If paginationMode: "normalized", data is TItem[]
+     * If paginationMode: "pages", data is { pages: TItem[][] }
+     */
+    data: TItem[] | {
+        pages: TItem[][];
+    };
+    isLoading: boolean;
+    isFetchingNextPage: boolean;
+    isFetching: boolean;
+    isRefreshing: boolean;
+    hasNextPage: boolean;
+    error: SmartQueryError | null;
+    totalCount: number;
+    fetchNextPage(): void;
+    refetch(): void;
+    addItem(item: TItem): void;
+    updateItem(item: TItem): void;
+    removeItem(id: string): void;
+}
+declare function useInfiniteSmartQuery<TRaw, TItem extends AnyItem>(options: InfiniteSmartQueryOptions<TRaw, TItem>): InfiniteSmartQueryResult<TItem>;
+
+/**
+ * src/hooks/useSmartQuerySelector.ts
+ *
+ * Derived data selector — subscribe to a slice of a cached list.
+ *
+ * Problem:
+ *   When an expense list of 500 items has one item updated, every component
+ *   calling useSmartQuery rerenders. For a row component this is O(n) renders.
+ *
+ * Solution:
+ *   useSmartQuerySelector subscribes to the TanStack Query cache for a specific
+ *   queryKey and applies a selector function. The component only rerenders
+ *   when the SELECTOR OUTPUT changes (checked with fast-deep-equal).
+ *
+ * @example
+ *   // Only rerenders when THIS expense changes
+ *   const expense = useSmartQuerySelector(
+ *     ["expenses", tripId],
+ *     (expenses: Expense[]) => expenses.find((e) => e.id === expenseId)
+ *   );
+ *
+ * @example
+ *   // Total amount — only rerenders when the total changes
+ *   const total = useSmartQuerySelector(
+ *     ["expenses", tripId],
+ *     (expenses: Expense[]) => expenses.reduce((s, e) => s + e.amount, 0)
+ *   );
+ */
+/**
+ * Subscribe to a derived slice of a TanStack Query cache entry.
+ *
+ * @param queryKey   Must match a useSmartQuery / useInfiniteSmartQuery key.
+ * @param selector   Pure function — receives the cached data, returns derived value.
+ * @param equalityFn Override the equality check. Defaults to fast-deep-equal.
+ */
+declare function useSmartQuerySelector<TData, TSelected>(queryKey: readonly unknown[], selector: (data: TData | undefined) => TSelected, equalityFn?: (a: TSelected, b: TSelected) => boolean): TSelected;
+
+/**
+ * src/services/cache.service.ts
+ *
+ * Versioned, LRU-aware cache layer.
+ *
+ * Features:
+ *   • Schema versioning — auto-invalidates stale entries on version bump
+ *   • lastAccessedAt tracking — enables LRU eviction
+ *   • Configurable max entries per prefix — prevents unbounded growth
+ *   • Partial hydration — read a subset of a NormalizedList by ids
+ *   • Observability events on hit / miss / write / quota exceeded
+ */
+
+/**
+ * Bump when CacheEntry shape or NormalizedList schema changes in a
+ * breaking way. Any stored entry with a lower version is silently discarded.
+ */
+declare const CURRENT_CACHE_VERSION = 2;
+/** Override the global max entries limit (call before any reads/writes) */
+declare function setMaxCacheEntries(n: number): void;
+declare function cacheKeyFor(queryKey: readonly unknown[]): string;
+declare function readCache<T>(key: string, queryKey?: readonly unknown[]): Promise<CacheEntry<T> | null>;
+declare function writeCache<T>(key: string, data: T, queryKey?: readonly unknown[]): Promise<void>;
+declare function deleteCache(key: string): Promise<void>;
+/**
+ * Read a subset of a NormalizedList cache entry by item ids.
+ *
+ * Use for pagination, lazy loading, or detail views that only need
+ * a handful of items from a large cached list.
+ *
+ * @returns null if the cache entry doesn't exist.
+ *          Empty array if none of the requested ids are cached.
+ *
+ * @example
+ *   const items = await getPartialCache<Expense>(
+ *     cacheKeyFor(["expenses", tripId]),
+ *     ["exp_1", "exp_2"]
+ *   );
+ */
+declare function getPartialCache<T extends AnyItem>(key: string, ids: string[]): Promise<T[] | null>;
+declare function isCacheStale(entry: CacheEntry<unknown>, ttlMs: number): boolean;
+
+/**
+ * src/registry/smartQueryRegistry.ts
+ *
+ * Global mutation registry.
+ * Call addItem / updateItem / removeItem from anywhere — no hook required.
+ */
+
+interface SmartQueryActions<TItem extends AnyItem> {
+    addItem(item: TItem): Promise<void>;
+    updateItem(item: TItem): Promise<void>;
+    removeItem(id: string): Promise<void>;
+    isActive(): boolean;
+}
+declare function getSmartQueryActions<TItem extends AnyItem>(queryKey: readonly unknown[]): SmartQueryActions<TItem>;
+/**
+ * Dev-only debug API. All methods are no-ops in production.
+ */
+declare const smartQueryDebug: {
+    /** Get the current normalized state for a query key. */
+    getNormalizedState: <T extends AnyItem>(queryKey: readonly unknown[]) => Promise<NormalizedList<T> | UnifiedNormalizedInfiniteData<T> | null>;
+    /** Log a detailed summary of the cache entry to the console. */
+    inspectCache: (queryKey: readonly unknown[]) => Promise<void>;
+    /** Clear the cache entry for a query key. */
+    clearCache: (queryKey: readonly unknown[]) => Promise<void>;
+    /** Get the current state of the offline mutation queue. */
+    getQueue: () => Promise<any[]>;
+    /** Get list of all storage keys currently being fetched. */
+    inFlightRequests: () => string[];
+};
+/**
+ * Executes multiple mutations in a single logical batch.
+ * If the hook is unmounted, it performs a single storage write.
+ */
+declare function batchUpdate(queryKey: readonly unknown[], fn: (actions: SmartQueryActions<any>) => void | Promise<void>): Promise<void>;
+
+/**
+ * src/factory/createTypedQuery.ts
+ *
+ * Type-safe query factory — inspired by tRPC's router pattern.
+ *
+ * Problem:
+ *   getSmartQueryActions<Expense>(["expenses", tripId]) — the Expense type
+ *   is not connected to the queryKey. You can pass the wrong type silently.
+ *   Every call site must repeat the type annotation and queryFn.
+ *
+ * Solution:
+ *   Define the query once at module level (queryKey shape + queryFn + config).
+ *   Call sites get pre-typed hooks and actions with full inference.
+ *
+ * @example
+ *   // Define once (e.g. src/queries/expense.query.ts)
+ *   export const expenseQuery = createTypedQuery({
+ *     queryKey: (tripId: string) => ["expenses", tripId] as const,
+ *     queryFn: (tripId: string) =>
+ *       api.get(`/trips/${tripId}/expenses`).then((r) => r.data as Expense[]),
+ *     getItemId: (e: Expense) => e.id,
+ *     sortComparator: (a: Expense, b: Expense) => b.createdAt - a.createdAt,
+ *     cacheTtl: 5 * 60_000,
+ *   });
+ *
+ *   // Use anywhere — fully typed, no annotation needed
+ *   const { data, addItem } = expenseQuery.useQuery(tripId);
+ *   const actions = expenseQuery.getActions(tripId);
+ *   await actions.addItem(newExpense); // TItem = Expense — inferred!
+ */
+
+type AnyArgs = readonly unknown[];
+interface TypedQueryDefinition<TArgs extends AnyArgs, TRaw, TData, TItem extends AnyItem = TData extends AnyItem[] ? TData[number] : AnyItem> {
+    /**
+     * Pre-typed useSmartQuery hook.
+     * Pass the same args you defined in `queryKey(args)`.
+     */
+    useQuery(...args: TArgs): SmartQueryResult<TData, TItem>;
+    /**
+     * Pre-typed useSmartMutation hook.
+     * Requires only the mutation-specific options (queryKey is pre-filled).
+     */
+    useMutation(...args: [...TArgs, Omit<SmartMutationOptions<TItem>, "queryKey" | "getItemId">]): SmartMutationResult<TItem>;
+    /**
+     * Get pre-typed global actions for this query key.
+     * Call from anywhere — no React required.
+     */
+    getActions(...args: TArgs): SmartQueryActions<TItem>;
+    /** Invalidate this query's cache entry */
+    invalidate(...args: TArgs): Promise<void>;
+}
+interface CreateTypedQueryConfig<TArgs extends AnyArgs, TRaw, TData, TItem extends AnyItem = TData extends AnyItem[] ? TData[number] : AnyItem> {
+    /** Build the query key array from args */
+    queryKey(...args: TArgs): readonly unknown[];
+    /** Async function that fetches data — receives the same args */
+    queryFn(...args: TArgs): Promise<TRaw>;
+    /** Transform raw response (optional) */
+    select?: (raw: TRaw) => TData;
+    /** Required for list queries */
+    getItemId?: TData extends AnyItem[] ? GetItemId<TItem> : never;
+    /** Required for list queries */
+    sortComparator?: TData extends AnyItem[] ? SortComparator<TItem> : never;
+    cacheTtl?: number;
+    strictFreshness?: boolean;
+    /** Extra SmartQueryOptions applied to every call */
+    defaultOptions?: Partial<SmartQueryOptions<TRaw, TData, TItem>>;
+}
+/**
+ * Create a type-safe query definition.
+ * Returns a typed query object with useQuery, useMutation, getActions, invalidate.
+ */
+declare function createTypedQuery<TArgs extends AnyArgs, TRaw, TData, TItem extends AnyItem = TData extends AnyItem[] ? TData[number] : AnyItem>(config: CreateTypedQueryConfig<TArgs, TRaw, TData, TItem>): TypedQueryDefinition<TArgs, TRaw, TData, TItem>;
+
+/**
+ * src/services/queue.service.ts
+ *
+ * Offline Mutation Queue — persist-first, retry-on-reconnect, with coalescing.
+ *
+ * Key design decisions:
+ *   • Sequential FIFO processing preserves causal ordering
+ *   • Coalescing: two mutations with the same entityKey are merged before send
+ *     (prevents stale optimistic updates from racing each other)
+ *   • Exponential backoff with full jitter — no thundering herd on reconnect
+ *   • Observability events on enqueue / success / failure / drain
+ *   • clearQueue() on logout prevents cross-user mutation leakage
+ */
+
+type Executor<P = unknown> = (mutation: QueuedMutation<P>) => Promise<void>;
+/**
+ * Register an executor for a mutation type.
+ * Must be called at app startup before mutations are enqueued.
+ *
+ * @example
+ *   registerExecutor("ADD_ITEM", async (m) => {
+ *     await api.post("/expenses", m.payload);
+ *   });
+ */
+declare function registerExecutor<TPayload>(type: string, fn: Executor<TPayload>): void;
+declare function loadQueue(): Promise<QueuedMutation[]>;
+/**
+ * Process all pending mutations in FIFO order.
+ * Coalesces before sending to minimize network calls.
+ * Safe to call concurrently — guarded by isProcessing flag.
+ */
+declare function processQueue(): Promise<void>;
+/**
+ * Add a mutation to the persistent queue.
+ *
+ * @param entityKey  Optional logical key for coalescing (e.g. "expense:exp_123").
+ *                   Mutations with the same entityKey are merged before sending.
+ */
+declare function enqueueMutation<TPayload>(options: {
+    type: MutationType | string;
+    queryKey: readonly unknown[];
+    payload: TPayload;
+    entityKey?: string;
+    maxRetries?: number;
+}): Promise<void>;
+/** Process queue on app startup */
+declare function initQueue(): Promise<void>;
+/** Clear all pending mutations — call on logout */
+declare function clearQueue(): Promise<void>;
+declare const getQueue: typeof loadQueue;
+declare const getQueueLength: () => Promise<number>;
+
+/**
+ * src/services/observer.service.ts
+ *
+ * Pluggable observability — emit structured events to any analytics backend.
+ *
+ * Zero coupling: the library emits; you decide where it goes.
+ * Attach observers at app startup; they receive every internal event.
+ *
+ * @example
+ *   // Sentry breadcrumbs
+ *   addObserver((event) => {
+ *     if (event.type === "fetch_error") {
+ *       Sentry.addBreadcrumb({ message: event.type, data: event });
+ *     }
+ *   });
+ *
+ * @example
+ *   // Datadog / Mixpanel
+ *   addObserver((event) => {
+ *     analytics.track(event.type, event);
+ *   });
+ *
+ * @example
+ *   // Simple console logger in dev
+ *   if (__DEV__) addObserver(console.log);
+ */
+
+/**
+ * Register an observer. Returns an unsubscribe function.
+ *
+ * @example
+ *   const unsub = addObserver(myLogger);
+ *   // Later:
+ *   unsub();
+ */
+declare function addObserver(fn: ObserverFn): () => void;
+/** Remove a specific observer */
+declare function removeObserver(fn: ObserverFn): void;
+/** Remove all observers */
+declare function clearObservers(): void;
+
+/**
+ * src/utils/normalize.ts
+ *
+ * NormalizedList — O(1) lookup, O(log n) sorted mutations.
+ *
+ * The `getItemId` function is passed explicitly — no hardcoded field name.
+ * This lets you use `_id`, `uuid`, numeric ids, or composite keys.
+ */
+
+declare function emptyList<T extends AnyItem>(): NormalizedList<T>;
+declare function fromArray<T extends AnyItem>(items: T[], getItemId: GetItemId<T>, comparator?: SortComparator<T>): NormalizedList<T>;
+declare function toArray<T extends AnyItem>(list: NormalizedList<T>): T[];
+declare function normalizedAdd<T extends AnyItem>(list: NormalizedList<T>, item: T, getItemId: GetItemId<T>, comparator: SortComparator<T>, getItemVersion?: GetItemVersion<T>): NormalizedList<T>;
+declare function normalizedUpdate<T extends AnyItem>(list: NormalizedList<T>, item: T, getItemId: GetItemId<T>, comparator: SortComparator<T>, getItemVersion?: GetItemVersion<T>): NormalizedList<T>;
+declare function normalizedRemove<T extends AnyItem>(list: NormalizedList<T>, id: string): NormalizedList<T>;
+declare function isNormalizedEmpty<T extends AnyItem>(list: NormalizedList<T>): boolean;
+/**
+ * Soft Trim list to maxItems.
+ * Instead of a hard cut every time, we remove 20% of the oldest items
+ * to avoid constant array slicing on every single insert.
+ * Assumes list is already sorted.
+ */
+declare function trimNormalizedList<T extends AnyItem>(list: NormalizedList<T>, maxItems: number): NormalizedList<T>;
+
+/**
+ * src/services/requestLock.service.ts
+ *
+ * In-flight request deduplication.
+ * Concurrent calls with the same key share one Promise — only one fetch fires.
+ */
+declare function fetchWithLock<T>(key: string, fn: () => Promise<T>): Promise<T>;
+declare const inFlightCount: () => number;
+declare const inFlightKeys: () => string[];
+
+export { AnyItem, CURRENT_CACHE_VERSION, CacheEntry, type CompareResult, type CreateTypedQueryConfig, GetItemId, GetItemVersion, type InfiniteSmartQueryOptions, type InfiniteSmartQueryResult, MutationType, NormalizedList, ObserverFn, QueuedMutation, type SmartCompareOptions, type SmartMutationOptions, type SmartMutationResult, type SmartQueryActions, SmartQueryError, type SmartQueryOptions, type SmartQueryResult, SortComparator, type TypedQueryDefinition, addObserver, batchUpdate, cacheKeyFor, clearAllSmartCache, clearObservers, clearQueue, createTypedQuery, deleteCache, emptyList, enqueueMutation, fetchWithLock, fromArray, getPartialCache, getQueue, getQueueLength, getSmartQueryActions, inFlightCount, inFlightKeys, initQueue, invalidateSmartCache, isCacheStale, isDataEqual, isNormalizedEmpty, normalizedAdd, normalizedRemove, normalizedUpdate, processQueue, readCache, registerExecutor, removeObserver, setMaxCacheEntries, smartCompare, smartQueryDebug, toArray, trimNormalizedList, useInfiniteSmartQuery, useSmartMutation, useSmartQuery, useSmartQuerySelector, writeCache };