@ethlete/query 5.22.0 → 5.23.0

package/lib/experimental/http-request.d.ts

@@ -92,7 +92,7 @@ export type HttpRequestLoadingProgressState = {
 export type HttpRequest<TArgs extends QueryArgs> = {
     /** Executes the request */
     execute: (options?: {
-        skipCache?: boolean;
+        allowCache?: boolean;
     }) => boolean;
     /** Destroys the request (cancels it if in progress) */
     destroy: () => boolean;

package/lib/experimental/paged-query.d.ts

@@ -6,14 +6,59 @@ export declare const ggLikePaginationAdapter: <T>(response: GgLikePaginated<T>)
 export declare const dynLikePaginationAdapter: <T>(response: DynLikePaginated<T>) => NormalizedPagination<T>;
 export declare const contentfulGqlLikePaginationAdapter: <T>(response: ContentfulGqlLikePaginated<T>) => NormalizedPagination<T>;
 export type CreatePagedQueryOptions<TArgs extends QueryArgs> = {
+    /**
+     * The normalizer function that will be used to normalize the response to a format that the paged query can understand.
+     *
+     * There are some built-in normalizers that can be used:
+     * - `ethletePaginationAdapter`
+     * - `ggLikePaginationAdapter`
+     * - `dynLikePaginationAdapter`
+     * - `contentfulGqlLikePaginationAdapter`
+     */
     responseNormalizer: (response: ResponseType<TArgs>) => NormalizedPagination<ResponseType<TArgs>>;
+    /**
+     * The query creator function that will be used to create the paged query.
+     */
     queryCreator: QueryCreator<TArgs>;
+    /**
+     * The arguments to create the query.
+     * The current page will be passed as an argument.
+     * This function can be treated like a computed function. It reacts to signal changes.
+     * If a signal changes, the paged query will be reset to the initial page.
+     *
+     * @example (page) => ({ queryParams: { page, limit:20 } }),
+     */
     args: (page: number) => RequestArgs<TArgs>;
+    /**
+     * The page to start this paged query from.
+     * @default 1
+     */
     initialPage?: number;
 };
 export type PagedQueryResetOptions = {
+    /**
+     * The page to reset this paged query to.
+     * This will clear everything and start from this page.
+     * @default 1 // or the value passed in the `initialPage` option when creating the paged query.
+     */
     initialPage?: number;
 };
+export type PagedQueryExecuteOptions<TArgs extends QueryArgs> = {
+    /**
+     * If provided, only the queries that match the condition will be executed.
+     * This will also execute the previous and next query to the one that matched the condition.
+     * If not provided, all queries will be executed.
+     *
+     * @example
+     * myPagedQuery.execute({ where: (item) => item.id === 4 });
+     */
+    where?: (item: ResponseType<TArgs>, index: number, array: ResponseType<TArgs>[]) => boolean;
+    /**
+     * If true, the cache will be used (if not expired) and the request will not be made.
+     * @default false
+     */
+    allowCache?: boolean;
+};
 export declare const createPagedQuery: <TArgs extends QueryArgs>(options: CreatePagedQueryOptions<TArgs>) => {
     pagination: import("@angular/core").Signal<NormalizedPagination<ResponseType<TArgs>> | null>;
     fetchPreviousPage: () => void;
@@ -28,8 +73,5 @@ export declare const createPagedQuery: <TArgs extends QueryArgs>(options: Create
     isFirstLoad: import("@angular/core").Signal<boolean>;
     queries: Query<TArgs>[];
     reset: (resetOptions?: PagedQueryResetOptions) => void;
-    execute: (options?: {
-        where?: (items: ResponseType<TArgs>) => boolean;
-        skipCache?: boolean;
-    }) => void;
+    execute: (options?: PagedQueryExecuteOptions<TArgs>) => void;
 };

package/lib/experimental/query-errors.d.ts

@@ -20,7 +20,7 @@ export declare const enum RuntimeErrorCode {
     UNABLE_TO_DECRYPT_BEARER_TOKEN = 210,
     BEARER_EXPIRES_IN_PROPERTY_NOT_NUMBER = 211,
     UNCACHEABLE_REQUEST_HAS_CACHE_KEY_PARAM = 300,
-    UNCACHEABLE_REQUEST_HAS_SKIP_CACHE_PARAM = 301,
+    UNCACHEABLE_REQUEST_HAS_ALLOW_CACHE_PARAM = 301,
     PAGED_QUERY_PAGE_BIGGER_THAN_TOTAL_PAGES = 400,
     PAGED_QUERY_NEXT_PAGE_CALLED_WITHOUT_PREVIOUS_PAGE = 401,
     PAGED_QUERY_PREVIOUS_PAGE_CALLED_BUT_ALREADY_AT_FIRST_PAGE = 402
@@ -43,7 +43,7 @@ export declare const defaultResponseTransformerResponseNotContainingRefreshToken
 export declare const unableToDecryptBearerToken: (token: string) => RuntimeError<RuntimeErrorCode.UNABLE_TO_DECRYPT_BEARER_TOKEN>;
 export declare const bearerExpiresInPropertyNotNumber: (expiresIn: unknown) => RuntimeError<RuntimeErrorCode.BEARER_EXPIRES_IN_PROPERTY_NOT_NUMBER>;
 export declare const uncacheableRequestHasCacheKeyParam: (key: string) => RuntimeError<RuntimeErrorCode.UNCACHEABLE_REQUEST_HAS_CACHE_KEY_PARAM>;
-export declare const uncacheableRequestHasSkipCacheParam: () => RuntimeError<RuntimeErrorCode.UNCACHEABLE_REQUEST_HAS_SKIP_CACHE_PARAM>;
+export declare const uncacheableRequestHasAllowCacheParam: () => RuntimeError<RuntimeErrorCode.UNCACHEABLE_REQUEST_HAS_ALLOW_CACHE_PARAM>;
 export declare const pagedQueryPageBiggerThanTotalPages: (page: number, totalPages: number) => RuntimeError<RuntimeErrorCode.PAGED_QUERY_PAGE_BIGGER_THAN_TOTAL_PAGES>;
 export declare const pagedQueryNextPageCalledWithoutPreviousPage: () => RuntimeError<RuntimeErrorCode.PAGED_QUERY_NEXT_PAGE_CALLED_WITHOUT_PREVIOUS_PAGE>;
 export declare const pagedQueryPreviousPageCalledButAlreadyAtFirstPage: () => RuntimeError<RuntimeErrorCode.PAGED_QUERY_PREVIOUS_PAGE_CALLED_BUT_ALREADY_AT_FIRST_PAGE>;

package/lib/experimental/query-execute-utils.d.ts

@@ -12,7 +12,7 @@ export type QueryExecuteState = {
 };
 export declare const setupQueryExecuteState: () => QueryExecuteState;
 export type RunQueryExecuteOptions = {
-    skipCache?: boolean;
+    allowCache?: boolean;
 };
 export type QueryExecuteOptions<TArgs extends QueryArgs> = {
     executeOptions: CreateQueryExecuteOptions<TArgs>;

package/lib/experimental/query-stack.d.ts

@@ -14,7 +14,7 @@ export type QueryStack<T extends AnyQuery, J = ReturnType<T['response']>[]> = {
     response: Signal<J>;
     /** Executes all queries in the stack. */
     execute: (options?: {
-        skipCache?: boolean;
+        allowCache?: boolean;
     }) => void;
     /** Destroys all queries in the stack and empties it. This should only be used if `append` is true. */
     clear: () => void;

package/lib/experimental/query-utils.d.ts

@@ -27,7 +27,7 @@ export type ShouldRetryRequestResult = {
     delay: number;
 };
 export type ShouldRetryRequestFn = (options: ShouldRetryRequestOptions) => ShouldRetryRequestResult;
-export declare const shouldRetryRequest: (options: ShouldRetryRequestOptions) => ShouldRetryRequestResult;
+export declare const shouldRetryRequest: (options: ShouldRetryRequestOptions | HttpErrorResponse) => ShouldRetryRequestResult;
 export type QueryFeatureFlags = {
     hasWithArgsFeature: boolean;
     shouldAutoExecuteMethod: boolean;

package/lib/utils/data.utils.d.ts

@@ -53,7 +53,10 @@ export declare function queryComputed<T extends AnyQuery | null>(computation: ()
 export declare function queryComputedTillTruthy<T extends AnyQuery | null>(computation: () => T, options?: CreateComputedOptions<T> & QueryContainerConfig & ToObservableOptions): Signal<T | null>;
 export declare function queryArrayComputed<T extends AnyQuery[] | null>(computation: () => T, options?: CreateComputedOptions<T> & QueryContainerConfig & ToObservableOptions): Signal<T>;
 export declare function toQuerySubject<T extends AnyQuery | null>(source: Signal<T>, options?: ToObservableOptions & QueryContainerConfig): Observable<T>;
-export declare function queryStateSignal<T extends Signal<AnyQuery | AnyQueryCollection | null>>(source: T, options?: QueryFilterConfig): Signal<QueryState<QueryDataOf<QueryOf<ReturnType<T>>>> | null>;
-export declare function queryStateResponseSignal<T extends Signal<AnyQuery | AnyQueryCollection | null>>(source: T, options?: QueryFilterConfig): Signal<QueryDataOf<QueryOf<ReturnType<T>>> | null>;
+export declare function queryStateSignal<T extends Signal<AnyQuery | AnyQueryCollection | null>>(source: T, options?: QueryFilterConfig): import("@angular/core").WritableSignal<QueryState<QueryDataOf<QueryOf<ReturnType<T>>>> | null>;
+export type QueryStateSignal<T extends Signal<AnyQuery | AnyQueryCollection | null>> = Signal<QueryDataOf<QueryOf<ReturnType<T>>> | null> & {
+    reset: () => void;
+};
+export declare function queryStateResponseSignal<T extends Signal<AnyQuery | AnyQueryCollection | null>>(source: T, options?: QueryFilterConfig): QueryStateSignal<T>;
 export declare function queryStateErrorSignal<T extends Signal<AnyQuery | AnyQueryCollection | null>>(source: T): Signal<import("@ethlete/query").RequestError<unknown> | null>;
 export declare function queryStateLoadingSignal<T extends Signal<AnyQuery | AnyQueryCollection | null>>(source: T): Signal<import("../query").Loading | null>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ethlete/query",
-  "version": "5.22.0",
+  "version": "5.23.0",
   "peerDependencies": {
     "@angular/common": "^18.1.0 || ^19.0.0",
     "@angular/core": "^18.1.0 || ^19.0.0",