@ethlete/query 5.21.0 → 5.21.1

package/fesm2022/ethlete-query.mjs

@@ -2871,6 +2871,15 @@ const uncacheableRequestHasCacheKeyParam = (key) => {
 const uncacheableRequestHasSkipCacheParam = () => {
     return new RuntimeError(301 /* RuntimeErrorCode.UNCACHEABLE_REQUEST_HAS_SKIP_CACHE_PARAM */, `This request is uncacheable, but skipCache is set to true. Please remove it.`);
 };
+const pagedQueryPageBiggerThanTotalPages = (page, totalPages) => {
+    return new RuntimeError(400 /* RuntimeErrorCode.PAGED_QUERY_PAGE_BIGGER_THAN_TOTAL_PAGES */, `The page "${page}" is bigger than the total pages "${totalPages}".`);
+};
+const pagedQueryNextPageCalledWithoutPreviousPage = () => {
+    return new RuntimeError(401 /* RuntimeErrorCode.PAGED_QUERY_NEXT_PAGE_CALLED_WITHOUT_PREVIOUS_PAGE */, `fetchNextPage() has been called but the current page is not yet loaded. Please call it after the previous page has been loaded.`);
+};
+const pagedQueryPreviousPageCalledButAlreadyAtFirstPage = () => {
+    return new RuntimeError(402 /* RuntimeErrorCode.PAGED_QUERY_PREVIOUS_PAGE_CALLED_BUT_ALREADY_AT_FIRST_PAGE */, `fetchPreviousPage() has been called but the current page is already the first page.`);
+};
 
 /* eslint-disable @typescript-eslint/no-empty-function */
 const defaultResponseTransformer = (response) => {
@@ -3342,8 +3351,8 @@ const createHttpRequest = (options) => {
         updateErrorState(e);
         return throwError(() => e);
     }));
-    const execute = () => {
-        if (loading() || !isStale()) {
+    const execute = (options) => {
+        if (loading() || (!isStale() && !options?.skipCache)) {
             // Do not execute if there is already a request in progress or the request is not stale
             return false;
         }
@@ -3450,6 +3459,383 @@ const createHttpRequest = (options) => {
     return httpRequest;
 };
 
+/* eslint-disable @typescript-eslint/no-empty-function */
+const createQueryFeature = (config) => {
+    return config;
+};
+const withArgs = (args) => {
+    return createQueryFeature({
+        type: "withArgs" /* QueryFeatureType.WithArgs */,
+        fn: (context) => {
+            const currArgs = computed(() => args());
+            queryEffect(() => {
+                const currArgsNow = currArgs();
+                if (currArgsNow === null)
+                    return;
+                untracked(() => {
+                    if (currArgsNow === QUERY_ARGS_RESET) {
+                        context.state.args.set(null);
+                        return;
+                    }
+                    context.state.args.set(currArgsNow);
+                    if (context.flags.shouldAutoExecute)
+                        context.execute({ args: currArgsNow });
+                });
+            }, QUERY_EFFECT_ERROR_MESSAGE, { injector: context.deps.injector });
+        },
+    });
+};
+const withPolling = (options) => {
+    return createQueryFeature({
+        type: "withPolling" /* QueryFeatureType.WithPolling */,
+        fn: (context) => {
+            if (!context.flags.shouldAutoExecuteMethod) {
+                throw withPollingUsedOnUnsupportedHttpMethod(context.creatorInternals.method);
+            }
+            let intervalId = null;
+            queryEffect(() => {
+                const args = context.state.args();
+                untracked(() => {
+                    if (intervalId !== null)
+                        clearInterval(intervalId);
+                    if (args === null)
+                        return;
+                    if (options.executeInitially) {
+                        context.execute({ args });
+                    }
+                    intervalId = window.setInterval(() => {
+                        context.execute({ args });
+                    }, options.interval);
+                });
+            }, QUERY_EFFECT_ERROR_MESSAGE, { injector: context.deps.injector });
+            context.deps.destroyRef.onDestroy(() => intervalId !== null && clearInterval(intervalId));
+        },
+    });
+};
+const withLogging = (options) => {
+    return createQueryFeature({
+        type: "withLogging" /* QueryFeatureType.WithLogging */,
+        fn: (context) => {
+            effect(() => {
+                const event = context.state.latestHttpEvent();
+                if (event === null)
+                    return;
+                untracked(() => {
+                    options.logFn(event);
+                });
+            }, { injector: context.deps.injector });
+        },
+    });
+};
+const withErrorHandling = (options) => {
+    return createQueryFeature({
+        type: "withErrorHandling" /* QueryFeatureType.WithErrorHandling */,
+        fn: (context) => {
+            effect(() => {
+                const error = context.state.error();
+                if (error === null)
+                    return;
+                untracked(() => {
+                    options.handler(error);
+                });
+            }, { injector: context.deps.injector });
+        },
+    });
+};
+const withSuccessHandling = (options) => {
+    return createQueryFeature({
+        type: "withSuccessHandling" /* QueryFeatureType.WithSuccessHandling */,
+        fn: (context) => {
+            effect(() => {
+                const response = context.state.response();
+                if (response === null)
+                    return;
+                untracked(() => {
+                    options.handler(response);
+                });
+            }, { injector: context.deps.injector });
+        },
+    });
+};
+const withAutoRefresh = (options) => {
+    return createQueryFeature({
+        type: "withAutoRefresh" /* QueryFeatureType.WithAutoRefresh */,
+        fn: (context) => {
+            if (!context.flags.shouldAutoExecuteMethod) {
+                throw withAutoRefreshUsedOnUnsupportedHttpMethod(context.creatorInternals.method);
+            }
+            if (context.queryConfig.onlyManualExecution && !options.ignoreOnlyManualExecution) {
+                throw withAutoRefreshUsedOnUnsupportedHttpMethod(context.creatorInternals.method);
+            }
+            queryEffect(() => {
+                for (const signal of options.signalChanges) {
+                    signal();
+                }
+                untracked(() => {
+                    const args = context.state.args();
+                    if (args === null)
+                        return;
+                    context.execute({ args });
+                });
+            }, QUERY_EFFECT_ERROR_MESSAGE, { injector: context.deps.injector });
+        },
+    });
+};
+
+const transformArrayResponse = (responses) => responses.filter((r) => !!r).flatMap((r) => r);
+const transformPaginatedResponse = (responses) => responses.filter((r) => !!r).flatMap((r) => r.items);
+const createQueryStack = (computation, options) => {
+    const { append = false, appendFn = (oldQueries, newQueries) => {
+        const queries = [...oldQueries, ...newQueries];
+        const lastQuery = newQueries[newQueries.length - 1] ?? oldQueries[oldQueries.length - 1] ?? null;
+        return { queries, lastQuery };
+    }, transform, } = options ?? {};
+    const injector = inject(Injector);
+    const queries = signal([]);
+    const lastQuery = signal(null);
+    effect(() => {
+        const newQueryOrQueries = runInInjectionContext(injector, () => computation());
+        const newQueries = Array.isArray(newQueryOrQueries) ? newQueryOrQueries : [newQueryOrQueries].filter((q) => !!q);
+        untracked(() => {
+            const oldQueries = queries();
+            if (append) {
+                const { queries: appendedQueries, lastQuery: lastAppendedQuery } = appendFn(oldQueries, newQueries);
+                queries.set(appendedQueries);
+                lastQuery.set(lastAppendedQuery);
+            }
+            else {
+                for (const oldQuery of oldQueries) {
+                    if (!newQueries.some((q) => q.id() === oldQuery.id())) {
+                        oldQuery.destroy();
+                    }
+                }
+                queries.set(newQueries);
+                lastQuery.set(newQueries[newQueries.length - 1] ?? null);
+            }
+        });
+    });
+    const loading = computed(() => queries().some((q) => q.loading()));
+    const error = computed(() => queries()
+        .map((q) => q.error())
+        .find((e) => e !== null) ?? null);
+    const response = computed(() => {
+        const responses = queries().map((q) => q.response());
+        return transform?.(responses) ?? responses;
+    });
+    const execute = (options) => {
+        for (const query of queries()) {
+            query.execute({ options: { skipCache: options?.skipCache } });
+        }
+    };
+    const clear = () => {
+        for (const query of queries()) {
+            query.destroy();
+        }
+        queries.set([]);
+        lastQuery.set(null);
+    };
+    const stack = {
+        queries: queries.asReadonly(),
+        lastQuery: lastQuery.asReadonly(),
+        loading,
+        error,
+        response,
+        execute,
+        clear,
+    };
+    return stack;
+};
+
+const ethletePaginationAdapter = (response) => {
+    const pagination = {
+        items: response.items,
+        totalPages: response.totalPageCount,
+        currentPage: response.currentPage,
+        itemsPerPage: response.itemsPerPage,
+        totalHits: response.totalHits,
+    };
+    return pagination;
+};
+const ggLikePaginationAdapter = (response) => {
+    const pagination = {
+        items: response.items,
+        totalPages: response.totalPageCount,
+        currentPage: response.currentPage,
+        itemsPerPage: response.itemsPerPage,
+        totalHits: response.totalHits,
+    };
+    return pagination;
+};
+const dynLikePaginationAdapter = (response) => {
+    const pagination = {
+        items: response.items,
+        totalPages: response.totalPages,
+        currentPage: response.currentPage,
+        itemsPerPage: response.limit,
+        totalHits: response.totalHits,
+    };
+    return pagination;
+};
+const contentfulGqlLikePaginationAdapter = (response) => {
+    const totalPages = Math.max(Math.ceil(response.total / response.limit), 1); // If there are no items, there is still one page
+    const currentPage = Math.max(Math.ceil(response.skip / response.limit) + 1, 1);
+    const pagination = {
+        items: response.items,
+        totalPages,
+        currentPage,
+        itemsPerPage: response.limit,
+        totalHits: response.total,
+    };
+    return pagination;
+};
+const createPagedQuery = (options) => {
+    const { responseNormalizer, queryCreator } = options;
+    const currentPageArgs = signal(null);
+    const initialPage = signal(options.initialPage ?? 1);
+    const loadedMinPage = signal(initialPage());
+    const loadedMaxPage = signal(initialPage());
+    const lastResetTimestamp = signal(Date.now());
+    const pageDirection = signal('next');
+    const stack = createQueryStack(() => {
+        const args = currentPageArgs();
+        if (!args)
+            return null;
+        return queryCreator(withArgs(() => {
+            return args;
+        }));
+    }, {
+        append: true,
+        appendFn: (oldQueries, newQueries) => {
+            const newQuery = newQueries[0];
+            const dir = pageDirection();
+            if (!newQuery) {
+                const lastQuery = oldQueries[oldQueries.length - 1] ?? null;
+                return { queries: oldQueries, lastQuery };
+            }
+            else if (dir === 'previous') {
+                return { queries: [newQuery, ...oldQueries], lastQuery: newQuery };
+            }
+            else {
+                return { queries: [...oldQueries, newQuery], lastQuery: newQuery };
+            }
+        },
+        transform: transformArrayResponse,
+    });
+    effect(() => {
+        lastResetTimestamp();
+        const args = options.args(initialPage());
+        untracked(() => {
+            stack.clear();
+            currentPageArgs.set(args);
+            loadedMinPage.set(initialPage());
+            loadedMaxPage.set(initialPage());
+        });
+    });
+    const pagination = computed(() => {
+        const res = stack.lastQuery()?.response();
+        if (!res)
+            return null;
+        return responseNormalizer(res);
+    });
+    const fetchPreviousPage = () => {
+        const page = loadedMinPage() - 1;
+        if (page < 1) {
+            if (isDevMode()) {
+                throw pagedQueryPreviousPageCalledButAlreadyAtFirstPage();
+            }
+            return;
+        }
+        currentPageArgs.set(options.args(page));
+        loadedMinPage.set(page);
+        pageDirection.set('previous');
+    };
+    const fetchNextPage = () => {
+        const page = loadedMaxPage() + 1;
+        const currentPagination = pagination();
+        if (!currentPagination) {
+            if (isDevMode()) {
+                throw pagedQueryNextPageCalledWithoutPreviousPage();
+            }
+            return;
+        }
+        if (page > currentPagination.totalPages) {
+            if (isDevMode()) {
+                throw pagedQueryPageBiggerThanTotalPages(page, currentPagination.totalPages);
+            }
+            return;
+        }
+        currentPageArgs.set(options.args(page));
+        loadedMaxPage.set(page);
+        pageDirection.set('next');
+    };
+    const reset = (resetOptions) => {
+        const page = resetOptions?.initialPage ?? initialPage();
+        initialPage.set(page);
+        pageDirection.set('next');
+        lastResetTimestamp.set(Date.now());
+    };
+    const canFetchPreviousPage = computed(() => loadedMinPage() > 1);
+    const canFetchNextPage = computed(() => {
+        const currentPagination = pagination();
+        return currentPagination ? loadedMaxPage() < currentPagination.totalPages : false;
+    });
+    const items = computed(() => {
+        return stack
+            .response()
+            .map((r) => responseNormalizer(r).items)
+            .flat();
+    });
+    const isFirstLoad = computed(() => {
+        return stack.queries().length === 1 && !!stack.lastQuery()?.loading();
+    });
+    const execute = (options) => {
+        if (options?.where) {
+            const queriesToExecute = [];
+            for (const [index, query] of stack.queries().entries()) {
+                // TODO: Use the where condition here.
+                if (query.response()) {
+                    queriesToExecute.push(query);
+                    if (index !== 0) {
+                        const prevQuery = stack.queries()[index - 1];
+                        if (prevQuery) {
+                            queriesToExecute.push(prevQuery);
+                        }
+                    }
+                    if (index !== stack.queries().length - 1) {
+                        const nextQuery = stack.queries()[index + 1];
+                        if (nextQuery) {
+                            queriesToExecute.push(nextQuery);
+                        }
+                    }
+                }
+            }
+            for (const query of queriesToExecute) {
+                query.execute({ options: { skipCache: options.skipCache } });
+            }
+        }
+        else {
+            stack.execute({ skipCache: options?.skipCache });
+        }
+    };
+    const pagedQuery = {
+        pagination,
+        fetchPreviousPage,
+        fetchNextPage,
+        canFetchPreviousPage,
+        canFetchNextPage,
+        items,
+        direction: pageDirection.asReadonly(),
+        loading: stack.loading,
+        error: stack.error,
+        lastQuery: stack.lastQuery,
+        isFirstLoad,
+        queries: stack.queries(),
+        reset,
+        execute,
+    };
+    return pagedQuery;
+};
+
 const setupQueryDependencies = (options) => {
     const environmentInjector = inject(EnvironmentInjector);
     const queryEnvironmentInjector = createEnvironmentInjector([], environmentInjector);
@@ -3519,9 +3905,9 @@ const createExecuteFn = (executeOptions) => {
     const executeState = setupQueryExecuteState();
     const reset = () => resetExecuteState({ executeState, executeOptions });
     const exec = (executeArgs) => {
-        const { args = executeOptions.state.args() } = executeArgs ?? {};
+        const { args = executeOptions.state.args(), options } = executeArgs ?? {};
         cleanupPreviousExecute({ executeOptions, executeState });
-        queryExecute({ executeOptions, executeState, args });
+        queryExecute({ executeOptions, executeState, args, options });
     };
     exec['reset'] = reset;
     exec['currentRepositoryKey'] = executeState.previousKey.asReadonly();
@@ -3648,7 +4034,7 @@ const createQueryRepository = (config) => {
             if (cacheEntry) {
                 bind(key, options.destroyRef, cacheEntry.request);
                 if (runQueryOptions?.skipCache || cacheEntry.request.isStale()) {
-                    cacheEntry.request.execute();
+                    cacheEntry.request.execute({ skipCache: runQueryOptions?.skipCache });
                 }
                 return { key, request: cacheEntry.request };
             }
@@ -3906,193 +4292,6 @@ const createSecurePatchQuery = (client, authProvider) => {
     return (creatorOptions) => createSecureQueryCreator(creatorOptions, { method: 'PATCH', client, authProvider });
 };
 
-/* eslint-disable @typescript-eslint/no-empty-function */
-const createQueryFeature = (config) => {
-    return config;
-};
-const withArgs = (args) => {
-    return createQueryFeature({
-        type: "withArgs" /* QueryFeatureType.WithArgs */,
-        fn: (context) => {
-            const currArgs = computed(() => args());
-            queryEffect(() => {
-                const currArgsNow = currArgs();
-                if (currArgsNow === null)
-                    return;
-                untracked(() => {
-                    if (currArgsNow === QUERY_ARGS_RESET) {
-                        context.state.args.set(null);
-                        return;
-                    }
-                    context.state.args.set(currArgsNow);
-                    if (context.flags.shouldAutoExecute)
-                        context.execute({ args: currArgsNow });
-                });
-            }, QUERY_EFFECT_ERROR_MESSAGE, { injector: context.deps.injector });
-        },
-    });
-};
-const withPolling = (options) => {
-    return createQueryFeature({
-        type: "withPolling" /* QueryFeatureType.WithPolling */,
-        fn: (context) => {
-            if (!context.flags.shouldAutoExecuteMethod) {
-                throw withPollingUsedOnUnsupportedHttpMethod(context.creatorInternals.method);
-            }
-            let intervalId = null;
-            queryEffect(() => {
-                const args = context.state.args();
-                untracked(() => {
-                    if (intervalId !== null)
-                        clearInterval(intervalId);
-                    if (args === null)
-                        return;
-                    if (options.executeInitially) {
-                        context.execute({ args });
-                    }
-                    intervalId = window.setInterval(() => {
-                        context.execute({ args });
-                    }, options.interval);
-                });
-            }, QUERY_EFFECT_ERROR_MESSAGE, { injector: context.deps.injector });
-            context.deps.destroyRef.onDestroy(() => intervalId !== null && clearInterval(intervalId));
-        },
-    });
-};
-const withLogging = (options) => {
-    return createQueryFeature({
-        type: "withLogging" /* QueryFeatureType.WithLogging */,
-        fn: (context) => {
-            effect(() => {
-                const event = context.state.latestHttpEvent();
-                if (event === null)
-                    return;
-                untracked(() => {
-                    options.logFn(event);
-                });
-            }, { injector: context.deps.injector });
-        },
-    });
-};
-const withErrorHandling = (options) => {
-    return createQueryFeature({
-        type: "withErrorHandling" /* QueryFeatureType.WithErrorHandling */,
-        fn: (context) => {
-            effect(() => {
-                const error = context.state.error();
-                if (error === null)
-                    return;
-                untracked(() => {
-                    options.handler(error);
-                });
-            }, { injector: context.deps.injector });
-        },
-    });
-};
-const withSuccessHandling = (options) => {
-    return createQueryFeature({
-        type: "withSuccessHandling" /* QueryFeatureType.WithSuccessHandling */,
-        fn: (context) => {
-            effect(() => {
-                const response = context.state.response();
-                if (response === null)
-                    return;
-                untracked(() => {
-                    options.handler(response);
-                });
-            }, { injector: context.deps.injector });
-        },
-    });
-};
-const withAutoRefresh = (options) => {
-    return createQueryFeature({
-        type: "withAutoRefresh" /* QueryFeatureType.WithAutoRefresh */,
-        fn: (context) => {
-            if (!context.flags.shouldAutoExecuteMethod) {
-                throw withAutoRefreshUsedOnUnsupportedHttpMethod(context.creatorInternals.method);
-            }
-            if (context.queryConfig.onlyManualExecution && !options.ignoreOnlyManualExecution) {
-                throw withAutoRefreshUsedOnUnsupportedHttpMethod(context.creatorInternals.method);
-            }
-            queryEffect(() => {
-                for (const signal of options.signalChanges) {
-                    signal();
-                }
-                untracked(() => {
-                    const args = context.state.args();
-                    if (args === null)
-                        return;
-                    context.execute({ args });
-                });
-            }, QUERY_EFFECT_ERROR_MESSAGE, { injector: context.deps.injector });
-        },
-    });
-};
-
-const transformArrayResponse = (responses) => responses.filter((r) => !!r).flatMap((r) => r);
-const transformPaginatedResponse = (responses) => responses.filter((r) => !!r).flatMap((r) => r.items);
-const createQueryStack = (computation, options) => {
-    const { append = false, appendFn = (oldQueries, newQueries) => {
-        const queries = [...oldQueries, ...newQueries];
-        const lastQuery = newQueries[newQueries.length - 1] ?? oldQueries[oldQueries.length - 1] ?? null;
-        return { queries, lastQuery };
-    }, transform, } = options ?? {};
-    const injector = inject(Injector);
-    const queries = signal([]);
-    const lastQuery = signal(null);
-    effect(() => {
-        const newQueryOrQueries = runInInjectionContext(injector, () => computation());
-        const newQueries = Array.isArray(newQueryOrQueries) ? newQueryOrQueries : [newQueryOrQueries];
-        untracked(() => {
-            const oldQueries = queries();
-            if (append) {
-                const { queries: appendedQueries, lastQuery: lastAppendedQuery } = appendFn(oldQueries, newQueries);
-                queries.set(appendedQueries);
-                lastQuery.set(lastAppendedQuery);
-            }
-            else {
-                for (const oldQuery of oldQueries) {
-                    if (!newQueries.some((q) => q.id() === oldQuery.id())) {
-                        oldQuery.destroy();
-                    }
-                }
-                queries.set(newQueries);
-                lastQuery.set(newQueries[newQueries.length - 1] ?? null);
-            }
-        });
-    });
-    const loading = computed(() => queries().some((q) => q.loading()));
-    const error = computed(() => queries()
-        .map((q) => q.error())
-        .find((e) => e !== null) ?? null);
-    const response = computed(() => {
-        const responses = queries().map((q) => q.response());
-        return transform?.(responses) ?? responses;
-    });
-    const execute = () => {
-        for (const query of queries()) {
-            query.execute();
-        }
-    };
-    const clear = () => {
-        for (const query of queries()) {
-            query.destroy();
-        }
-        queries.set([]);
-        lastQuery.set(null);
-    };
-    const stack = {
-        queries: queries.asReadonly(),
-        lastQuery: lastQuery.asReadonly(),
-        loading,
-        error,
-        response,
-        execute,
-        clear,
-    };
-    return stack;
-};
-
 var index = /*#__PURE__*/Object.freeze({
     __proto__: null,
     QUERY_ARGS_RESET: QUERY_ARGS_RESET,
@@ -4101,6 +4300,7 @@ var index = /*#__PURE__*/Object.freeze({
     applyQueryFeatures: applyQueryFeatures,
     bearerExpiresInPropertyNotNumber: bearerExpiresInPropertyNotNumber,
     cleanupPreviousExecute: cleanupPreviousExecute,
+    contentfulGqlLikePaginationAdapter: contentfulGqlLikePaginationAdapter,
     cookieLoginTriedButCookieDisabled: cookieLoginTriedButCookieDisabled,
     createBearerAuthProvider: createBearerAuthProvider,
     createBearerAuthProviderConfig: createBearerAuthProviderConfig,
@@ -4108,6 +4308,7 @@ var index = /*#__PURE__*/Object.freeze({
     createExecuteFn: createExecuteFn,
     createGetQuery: createGetQuery,
     createHttpRequest: createHttpRequest,
+    createPagedQuery: createPagedQuery,
     createPatchQuery: createPatchQuery,
     createPostQuery: createPostQuery,
     createPutQuery: createPutQuery,
@@ -4131,12 +4332,18 @@ var index = /*#__PURE__*/Object.freeze({
     defaultResponseTransformerResponseNotContainingRefreshToken: defaultResponseTransformerResponseNotContainingRefreshToken,
     defaultResponseTransformerResponseNotObject: defaultResponseTransformerResponseNotObject,
     disableCookieCalledWithoutCookieConfig: disableCookieCalledWithoutCookieConfig,
+    dynLikePaginationAdapter: dynLikePaginationAdapter,
     enableCookieCalledWithoutCookieConfig: enableCookieCalledWithoutCookieConfig,
+    ethletePaginationAdapter: ethletePaginationAdapter,
     extractExpiresInSeconds: extractExpiresInSeconds,
     getQueryFeatureUsage: getQueryFeatureUsage,
+    ggLikePaginationAdapter: ggLikePaginationAdapter,
     loginCalledWithoutConfig: loginCalledWithoutConfig,
     loginWithTokenCalledWithoutConfig: loginWithTokenCalledWithoutConfig,
     maybeExecute: maybeExecute,
+    pagedQueryNextPageCalledWithoutPreviousPage: pagedQueryNextPageCalledWithoutPreviousPage,
+    pagedQueryPageBiggerThanTotalPages: pagedQueryPageBiggerThanTotalPages,
+    pagedQueryPreviousPageCalledButAlreadyAtFirstPage: pagedQueryPreviousPageCalledButAlreadyAtFirstPage,
     provideBearerAuthProvider: provideBearerAuthProvider,
     provideQueryClient: provideQueryClient,
     queryEffect: queryEffect,