@signalium/query 1.0.4 → 1.0.6

package/dist/cjs/QueryClient.js

@@ -12,607 +12,18 @@
  * - Self-contained validator (no external dependencies except Signalium)
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueryClientContext = exports.QueryClient = exports.QueryResultImpl = void 0;
+exports.QueryClientContext = exports.QueryClient = exports.queryKeyFor = void 0;
 const signalium_1 = require("signalium");
 const utils_1 = require("signalium/utils");
-const types_js_1 = require("./types.js");
-const proxy_js_1 = require("./proxy.js");
-const parseEntities_js_1 = require("./parseEntities.js");
 const EntityMap_js_1 = require("./EntityMap.js");
-const typeDefs_js_1 = require("./typeDefs.js");
 const NetworkManager_js_1 = require("./NetworkManager.js");
+const QueryResult_js_1 = require("./QueryResult.js");
+const RefetchManager_js_1 = require("./RefetchManager.js");
+const MemoryEvictionManager_js_1 = require("./MemoryEvictionManager.js");
 const queryKeyFor = (queryDef, params) => {
-    return (0, utils_1.hashValue)([queryDef.id, params]);
+    return (0, utils_1.hashValue)([queryDef.id, queryDef.shapeKey, params]);
 };
-const BASE_TICK_INTERVAL = 1000; // 1 second
-// Refetch interval manager - uses a fixed 1-second tick
-class RefetchManager {
-    multiplier;
-    intervalId;
-    clock = 0; // Increments by 1000ms on each tick
-    // Buckets: Map of actual interval -> Set of query instances
-    buckets = new Map();
-    constructor(multiplier = 1) {
-        this.multiplier = multiplier;
-        // Start the timer immediately and keep it running
-        const tickInterval = BASE_TICK_INTERVAL * this.multiplier;
-        this.intervalId = setTimeout(() => this.tick(), tickInterval);
-    }
-    addQuery(instance) {
-        if (instance.def.type === "stream" /* QueryType.Stream */) {
-            return; // Streams don't have refetch intervals
-        }
-        const interval = instance.def.cache?.refetchInterval;
-        if (!interval) {
-            return;
-        }
-        const actualInterval = interval * this.multiplier;
-        // Add to bucket by actual interval
-        let bucket = this.buckets.get(actualInterval);
-        if (!bucket) {
-            bucket = new Set();
-            this.buckets.set(actualInterval, bucket);
-        }
-        bucket.add(instance);
-    }
-    removeQuery(query) {
-        if (query.def.type === "stream" /* QueryType.Stream */) {
-            return; // Streams don't have refetch intervals
-        }
-        const interval = query.def.cache?.refetchInterval;
-        if (!interval) {
-            return;
-        }
-        const actualInterval = interval * this.multiplier;
-        // Remove from bucket
-        const bucket = this.buckets.get(actualInterval);
-        if (bucket) {
-            bucket.delete(query);
-            if (bucket.size === 0) {
-                this.buckets.delete(actualInterval);
-            }
-        }
-    }
-    tick() {
-        this.clock += BASE_TICK_INTERVAL * this.multiplier;
-        // Only process buckets where clock is aligned with the interval
-        for (const [interval, bucket] of this.buckets.entries()) {
-            if (this.clock % interval === 0) {
-                // Process all queries in this bucket
-                for (const query of bucket) {
-                    // Skip if already fetching - let the current fetch complete
-                    if (query && !query.isFetching) {
-                        query.refetch();
-                    }
-                }
-            }
-        }
-        const tickInterval = BASE_TICK_INTERVAL * this.multiplier;
-        this.intervalId = setTimeout(() => this.tick(), tickInterval);
-    }
-    destroy() {
-        clearTimeout(this.intervalId);
-    }
-}
-const EVICTION_INTERVAL = 60 * 1000; // 1 minute
-// Memory eviction manager - uses a single interval with rotating sets to avoid timeout overhead
-class MemoryEvictionManager {
-    queryClient;
-    multiplier;
-    intervalId;
-    currentFlush = new Set(); // Queries to evict on next tick
-    nextFlush = new Set(); // Queries to evict on tick after next
-    constructor(queryClient, multiplier = 1) {
-        this.queryClient = queryClient;
-        this.multiplier = multiplier;
-        this.intervalId = setInterval(this.tick, EVICTION_INTERVAL * this.multiplier);
-    }
-    scheduleEviction(queryKey) {
-        // Add to nextFlush so it waits at least one full interval
-        // This prevents immediate eviction if scheduled right before a tick
-        this.nextFlush.add(queryKey);
-    }
-    cancelEviction(queryKey) {
-        // Remove from both sets to handle reactivation
-        this.currentFlush.delete(queryKey);
-        this.nextFlush.delete(queryKey);
-    }
-    tick = () => {
-        if (!this.queryClient)
-            return;
-        // Evict all queries in currentFlush
-        for (const queryKey of this.currentFlush) {
-            this.queryClient.queryInstances.delete(queryKey);
-        }
-        // Rotate: currentFlush becomes nextFlush, nextFlush becomes empty
-        this.currentFlush = this.nextFlush;
-        this.nextFlush = new Set();
-    };
-    destroy() {
-        clearInterval(this.intervalId);
-    }
-}
-/**
- * QueryResult wraps a DiscriminatedReactivePromise and adds additional functionality
- * like refetch, while forwarding all the base relay properties.
- * This class combines the old QueryInstance and QueryResultImpl into a single entity.
- */
-class QueryResultImpl {
-    def;
-    queryKey;
-    queryClient;
-    initialized = false;
-    isRefetchingSignal = (0, signalium_1.signal)(false);
-    isFetchingMoreSignal = (0, signalium_1.signal)(false);
-    updatedAt = undefined;
-    params = undefined;
-    refIds = undefined;
-    refetchPromise = undefined;
-    fetchMorePromise = undefined;
-    attemptCount = 0;
-    unsubscribe = undefined;
-    relay;
-    _relayState = undefined;
-    wasOffline = false;
-    get relayState() {
-        const relayState = this._relayState;
-        if (!relayState) {
-            throw new Error('Relay state not initialized');
-        }
-        return relayState;
-    }
-    _nextPageParams = undefined;
-    get nextPageParams() {
-        // Streams don't have pagination
-        if (this.def.type === "stream" /* QueryType.Stream */) {
-            return null;
-        }
-        let params = this._nextPageParams;
-        const value = this.relayState.value;
-        if (params === undefined && value !== undefined) {
-            if (!Array.isArray(value)) {
-                throw new Error('Query result is not an array, this is a bug');
-            }
-            const infiniteDef = this.def;
-            const nextParams = infiniteDef.pagination?.getNextPageParams?.(value[value.length - 1]);
-            if (nextParams === undefined) {
-                // store null to indicate that there is no next page, but we've already calculated
-                params = null;
-            }
-            else {
-                // Clone current params
-                let hasDefinedParams = false;
-                const clonedParams = { ...this.params };
-                // iterate over the next page params and copy any defined values to the
-                for (const [key, value] of Object.entries(nextParams)) {
-                    if (value !== undefined && value !== null) {
-                        clonedParams[key] = value;
-                        hasDefinedParams = true;
-                    }
-                }
-                this._nextPageParams = params = hasDefinedParams ? clonedParams : null;
-            }
-        }
-        return params ?? null;
-    }
-    constructor(def, queryClient, queryKey, params) {
-        (0, utils_1.setReactivePromise)(this);
-        this.def = def;
-        this.queryClient = queryClient;
-        this.queryKey = queryKey;
-        this.params = params;
-        // Create the relay and handle activation/deactivation
-        this.relay = (0, signalium_1.relay)(state => {
-            this._relayState = state;
-            // Load from cache first, then fetch fresh data
-            this.queryClient.activateQuery(this);
-            // Track network status for reconnect handling
-            const networkManager = this.queryClient.networkManager;
-            const isOnline = networkManager.getOnlineSignal().value;
-            // Store initial offline state
-            this.wasOffline = !isOnline;
-            if (this.initialized) {
-                if (this.def.type === "stream" /* QueryType.Stream */) {
-                    this.setupSubscription();
-                }
-                else {
-                    // Check if we just came back online
-                    if (!this.wasOffline && isOnline) {
-                        // We're back online - check if we should refresh
-                        const refreshStaleOnReconnect = this.def.cache?.refreshStaleOnReconnect ?? true;
-                        if (refreshStaleOnReconnect && this.isStale) {
-                            this.refetch();
-                        }
-                        // Reset attempt count on reconnect
-                        this.attemptCount = 0;
-                    }
-                    else if (this.isStale && !this.isPaused) {
-                        this.refetch();
-                    }
-                }
-                // Update wasOffline for next check
-                this.wasOffline = !isOnline;
-            }
-            else {
-                this.initialize();
-            }
-            // Return deactivation callback
-            return {
-                update: () => {
-                    // For streams, unsubscribe and resubscribe to re-establish connection
-                    if (this.def.type === "stream" /* QueryType.Stream */) {
-                        this.setupSubscription();
-                        return;
-                    }
-                    // Network status changed - check if we should react
-                    const currentlyOnline = networkManager.getOnlineSignal().value;
-                    // If we just came back online
-                    if (this.wasOffline && currentlyOnline) {
-                        const refreshStaleOnReconnect = this.def.cache?.refreshStaleOnReconnect ?? true;
-                        if (refreshStaleOnReconnect && this.isStale) {
-                            state.setPromise(this.runQuery(this.params, true));
-                        }
-                        // Reset attempt count on reconnect
-                        this.attemptCount = 0;
-                    }
-                    // Update wasOffline for next check
-                    this.wasOffline = !currentlyOnline;
-                },
-                deactivate: () => {
-                    // Last subscriber left, deactivate refetch and schedule memory eviction
-                    if (this.def.type === "stream" /* QueryType.Stream */) {
-                        // Unsubscribe from stream
-                        if (this.unsubscribe) {
-                            this.unsubscribe();
-                            this.unsubscribe = undefined;
-                        }
-                    }
-                    else if (this.def.cache?.refetchInterval) {
-                        this.queryClient.refetchManager.removeQuery(this);
-                    }
-                    // Schedule removal from memory using the global eviction manager
-                    // This allows quick reactivation from memory if needed again soon
-                    // Disk cache (if configured) will still be available after eviction
-                    this.queryClient.memoryEvictionManager.scheduleEviction(this.queryKey);
-                },
-            };
-        });
-    }
-    // ======================================================
-    // ReactivePromise properties
-    // =====================================================
-    get value() {
-        return this.relay.value;
-    }
-    get error() {
-        return this.relay.error;
-    }
-    get isPending() {
-        return this.relay.isPending;
-    }
-    get isRejected() {
-        return this.relay.isRejected;
-    }
-    get isResolved() {
-        return this.relay.isResolved;
-    }
-    get isSettled() {
-        return this.relay.isSettled;
-    }
-    get isReady() {
-        return this.relay.isReady;
-    }
-    // TODO: Intimate APIs needed for `useReactive`, this is a code smell and
-    // we should find a better way to entangle these more generically
-    get _version() {
-        return this.relay._version;
-    }
-    get _signal() {
-        return this.relay._signal;
-    }
-    get _flags() {
-        return this.relay._flags;
-    }
-    // Forward Promise methods
-    then(onfulfilled, onrejected) {
-        return this.relay.then(onfulfilled, onrejected);
-    }
-    catch(onrejected) {
-        return this.relay.catch(onrejected);
-    }
-    finally(onfinally) {
-        return this.relay.finally(onfinally);
-    }
-    get [Symbol.toStringTag]() {
-        return 'QueryResult';
-    }
-    // ======================================================
-    // Internal fetch methods
-    // ======================================================
-    /**
-     * Initialize the query by loading from cache and fetching if stale
-     */
-    async initialize() {
-        const state = this.relayState;
-        try {
-            this.initialized = true;
-            // Load from cache first
-            const cached = await this.queryClient.loadCachedQuery(this.def, this.queryKey);
-            if (cached !== undefined) {
-                const shape = this.def.shape;
-                state.value =
-                    shape instanceof typeDefs_js_1.ValidatorDef
-                        ? (0, parseEntities_js_1.parseEntities)(cached.value, shape, this.queryClient, new Set())
-                        : (0, proxy_js_1.parseValue)(cached.value, shape, this.def.id);
-                // Set the cached timestamp
-                this.updatedAt = cached.updatedAt;
-                // Set the cached reference IDs
-                this.refIds = cached.refIds;
-            }
-            if (this.def.type === "stream" /* QueryType.Stream */) {
-                this.setupSubscription();
-            }
-            else {
-                if (cached !== undefined) {
-                    // Check if data is stale
-                    if (this.isStale) {
-                        // Data is stale, trigger background refetch
-                        this.refetch();
-                    }
-                }
-                else {
-                    // No cached data, fetch fresh
-                    state.setPromise(this.runQuery(this.params, true));
-                }
-            }
-        }
-        catch (error) {
-            // Relay will handle the error state automatically
-            state.setError(error);
-        }
-    }
-    /**
-     * Handle stream updates by merging with existing entity.
-     * Deep merging is handled automatically by parseEntities/setEntity.
-     */
-    setupSubscription() {
-        this.unsubscribe?.();
-        const streamDef = this.def;
-        this.unsubscribe = streamDef.subscribeFn(this.queryClient.getContext(), this.params, update => {
-            const shapeDef = this.def.shape;
-            const entityRefs = this.refIds ?? new Set();
-            const parsedData = (0, parseEntities_js_1.parseEntities)(update, shapeDef, this.queryClient, entityRefs);
-            // Update the relay state
-            this.relayState.value = parsedData;
-            this.updatedAt = Date.now();
-            this.refIds = entityRefs;
-            // Cache the data
-            this.queryClient.saveQueryData(this.def, this.queryKey, parsedData, this.updatedAt, entityRefs);
-        });
-    }
-    /**
-     * Fetches fresh data, updates the cache, and updates updatedAt timestamp
-     */
-    async runQuery(params, reset = false) {
-        // Check if paused before attempting fetch
-        if (this.isPaused) {
-            throw new Error('Query is paused due to network status');
-        }
-        const { retries, retryDelay } = this.getRetryConfig();
-        let lastError;
-        // Attempt fetch with retries
-        for (let attempt = 0; attempt <= retries; attempt++) {
-            try {
-                const queryDef = this.def;
-                const freshData = await queryDef.fetchFn(this.queryClient.getContext(), params);
-                // Success! Reset attempt count
-                this.attemptCount = 0;
-                // Parse and cache the fresh data
-                let entityRefs;
-                const isInfinite = this.def.type === "infiniteQuery" /* QueryType.InfiniteQuery */;
-                if (isInfinite && !reset && this.refIds !== undefined) {
-                    entityRefs = this.refIds;
-                }
-                else {
-                    entityRefs = new Set();
-                }
-                const shape = this.def.shape;
-                const parsedData = shape instanceof typeDefs_js_1.ValidatorDef
-                    ? (0, parseEntities_js_1.parseEntities)(freshData, shape, this.queryClient, entityRefs)
-                    : (0, proxy_js_1.parseValue)(freshData, shape, this.def.id);
-                let queryData;
-                if (isInfinite) {
-                    const prevQueryData = this.relayState.value;
-                    queryData = reset || prevQueryData === undefined ? [parsedData] : [...prevQueryData, parsedData];
-                }
-                else {
-                    queryData = parsedData;
-                }
-                let updatedAt;
-                if (reset) {
-                    updatedAt = this.updatedAt = Date.now();
-                }
-                else {
-                    updatedAt = this.updatedAt ??= Date.now();
-                }
-                this._nextPageParams = undefined;
-                // Cache the data (synchronous, fire-and-forget)
-                this.queryClient.saveQueryData(this.def, this.queryKey, queryData, updatedAt, entityRefs);
-                // Update the timestamp
-                this.updatedAt = Date.now();
-                return queryData;
-            }
-            catch (error) {
-                lastError = error;
-                this.attemptCount = attempt + 1;
-                // If we've exhausted retries, throw the error
-                if (attempt >= retries) {
-                    throw error;
-                }
-                // Wait before retrying (unless paused)
-                const delay = retryDelay(attempt);
-                await new Promise(resolve => setTimeout(resolve, delay));
-                // Check if paused during retry delay
-                if (this.isPaused) {
-                    throw new Error('Query is paused due to network status');
-                }
-            }
-        }
-        // Should never reach here, but TypeScript needs it
-        throw lastError;
-    }
-    // ======================================================
-    // Public methods
-    // ======================================================
-    refetch() {
-        if (this.def.type === "stream" /* QueryType.Stream */) {
-            throw new Error('Cannot refetch a stream query');
-        }
-        if (this.fetchMorePromise) {
-            throw new Error('Query is fetching more, cannot refetch');
-        }
-        if (this.refetchPromise) {
-            return this.refetchPromise;
-        }
-        // Clear memoized nextPageParams so it's recalculated after refetch
-        this._nextPageParams = undefined;
-        // Set the signal before any async operations so it's immediately visible
-        // Use untrack to avoid reactive violations when called from reactive context
-        this.isRefetchingSignal.value = true;
-        this._version.update(v => v + 1);
-        const promise = this.runQuery(this.params, true)
-            .then(result => {
-            this.relayState.value = result;
-            return result;
-        })
-            .catch((error) => {
-            this.relayState.setError(error);
-            return Promise.reject(error);
-        })
-            .finally(() => {
-            this._version.update(v => v + 1);
-            this.isRefetchingSignal.value = false;
-            this.refetchPromise = undefined;
-        });
-        this.refetchPromise = promise;
-        return promise;
-    }
-    fetchNextPage() {
-        if (this.def.type === "stream" /* QueryType.Stream */) {
-            throw new Error('Cannot fetch next page on a stream query');
-        }
-        if (this.refetchPromise) {
-            return Promise.reject(new Error('Query is refetching, cannot fetch next page'));
-        }
-        if (this.fetchMorePromise) {
-            return this.fetchMorePromise;
-        }
-        // Read nextPageParams in untracked context to avoid reactive violations
-        const nextPageParams = this.nextPageParams;
-        if (!nextPageParams) {
-            return Promise.reject(new Error('No next page params'));
-        }
-        // Set the signal before any async operations so it's immediately visible
-        // Use untrack to avoid reactive violations when called from reactive context
-        this.isFetchingMoreSignal.value = true;
-        this._version.update(v => v + 1);
-        const promise = this.runQuery(nextPageParams, false)
-            .then(result => {
-            this.relayState.value = result;
-            return result;
-        })
-            .catch((error) => {
-            this.relayState.setError(error);
-            return Promise.reject(error);
-        })
-            .finally(() => {
-            this._version.update(v => v + 1);
-            this.isFetchingMoreSignal.value = false;
-            this.fetchMorePromise = undefined;
-        });
-        this.fetchMorePromise = promise;
-        return promise;
-    }
-    // ======================================================
-    // Public properties
-    // ======================================================
-    get isRefetching() {
-        return this.isRefetchingSignal.value;
-    }
-    get isFetchingMore() {
-        return this.isFetchingMoreSignal.value;
-    }
-    get isFetching() {
-        return this.relay.isPending || this.isRefetching || this.isFetchingMore;
-    }
-    get hasNextPage() {
-        return this.nextPageParams !== null;
-    }
-    get isStale() {
-        // Streams are never stale - they're always receiving updates
-        if (this.def.type === "stream" /* QueryType.Stream */) {
-            return false;
-        }
-        if (this.updatedAt === undefined) {
-            return true; // No data yet, needs fetch
-        }
-        const staleTime = this.def.cache?.staleTime ?? 0;
-        return Date.now() - this.updatedAt >= staleTime;
-    }
-    get isPaused() {
-        // Streams handle their own connection state
-        if (this.def.type === "stream" /* QueryType.Stream */) {
-            return false;
-        }
-        const networkMode = this.def.cache?.networkMode ?? types_js_1.NetworkMode.Online;
-        const networkManager = this.queryClient.networkManager;
-        // Read the online signal to make this reactive
-        const isOnline = networkManager.getOnlineSignal().value;
-        switch (networkMode) {
-            case types_js_1.NetworkMode.Always:
-                return false;
-            case types_js_1.NetworkMode.Online:
-                return !isOnline;
-            case types_js_1.NetworkMode.OfflineFirst:
-                // Only paused if we have no cached data AND we're offline
-                return !isOnline && this.updatedAt === undefined;
-            default:
-                return false;
-        }
-    }
-    getRetryConfig() {
-        // Streams don't have retry config
-        if (this.def.type === "stream" /* QueryType.Stream */) {
-            return { retries: 0, retryDelay: () => 0 };
-        }
-        const retryOption = this.def.cache?.retry;
-        const isServer = this.queryClient.isServer;
-        // Default retry count: 3 on client, 0 on server
-        let retries;
-        let retryDelay;
-        if (retryOption === false) {
-            retries = 0;
-        }
-        else if (retryOption === undefined) {
-            retries = isServer ? 0 : 3;
-        }
-        else if (typeof retryOption === 'number') {
-            retries = retryOption;
-        }
-        else {
-            retries = retryOption.retries;
-        }
-        // Default exponential backoff: 1000ms * 2^attempt
-        if (typeof retryOption === 'object' && retryOption.retryDelay) {
-            retryDelay = retryOption.retryDelay;
-        }
-        else {
-            retryDelay = (attempt) => 1000 * Math.pow(2, attempt);
-        }
-        return { retries, retryDelay };
-    }
-}
-exports.QueryResultImpl = QueryResultImpl;
+exports.queryKeyFor = queryKeyFor;
 class QueryClient {
     store;
     context;
@@ -622,11 +33,12 @@ class QueryClient {
     refetchManager;
     networkManager;
     isServer;
-    constructor(store, context = { fetch }, networkManager) {
+    constructor(store, context = { fetch }, networkManager, memoryEvictionManager, refetchManager) {
         this.store = store;
         this.context = context;
-        this.memoryEvictionManager = new MemoryEvictionManager(this, this.context.evictionMultiplier);
-        this.refetchManager = new RefetchManager(this.context.refetchMultiplier);
+        this.memoryEvictionManager =
+            memoryEvictionManager ?? new MemoryEvictionManager_js_1.MemoryEvictionManager(this, this.context.evictionMultiplier);
+        this.refetchManager = refetchManager ?? new RefetchManager_js_1.RefetchManager(this.context.refetchMultiplier);
         this.networkManager = networkManager ?? new NetworkManager_js_1.NetworkManager();
         this.isServer = typeof window === 'undefined';
     }
@@ -654,11 +66,11 @@ class QueryClient {
      * that triggers fetches and prepopulates with cached data
      */
     getQuery(queryDef, params) {
-        const queryKey = queryKeyFor(queryDef, params);
+        const queryKey = (0, exports.queryKeyFor)(queryDef, params);
         let queryInstance = this.queryInstances.get(queryKey);
         // Create a new instance if it doesn't exist
         if (queryInstance === undefined) {
-            queryInstance = new QueryResultImpl(queryDef, this, queryKey, params);
+            queryInstance = new QueryResult_js_1.QueryResultImpl(queryDef, this, queryKey, params);
             // Store for future use
             this.queryInstances.set(queryKey, queryInstance);
         }