@ethlete/query 5.24.0 → 5.25.1

package/lib/experimental/auth/bearer-auth-provider-config.d.ts

@@ -55,6 +55,16 @@ export type BearerAuthProviderCookieConfig<TTokenRefreshArgs extends QueryArgs>
      * @default (token) => ({ token })
      */
     refreshArgsTransformer?: (token: string) => RequestArgs<TTokenRefreshArgs>;
+    /**
+     * An array of routes where the auto login via cookie should not be triggered.
+     *
+     * This checks the current route against the array of routes using the `startsWith` method.
+     * Make sure to start each route with a `/`.
+     *
+     * @default []
+     * @example ['/login', '/register']
+     */
+    autoLoginExcludeRoutes?: string[];
 };
 export type CreateBearerAuthProviderConfigOptions<TLoginArgs extends QueryArgs, TTokenLoginArgs extends QueryArgs, TTokenRefreshArgs extends QueryArgs, TSelectRoleArgs extends QueryArgs> = {
     /**

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

@@ -9,7 +9,7 @@ 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 declare const fakePaginationAdapter: (totalHits?: number) => <T>(response: T) => NormalizedPagination<T>;
-export type CreatePagedQueryStackOptions<TArgs extends QueryArgs> = {
+export type CreatePagedQueryStackOptions<TArgs extends QueryArgs, TNormPagination extends NormalizedPagination<unknown>> = {
     /**
      * The normalizer function that will be used to normalize the response to a format that the paged query can understand.
      *
@@ -20,7 +20,7 @@ export type CreatePagedQueryStackOptions<TArgs extends QueryArgs> = {
      * - `contentfulGqlLikePaginationAdapter`
      * - `fakePaginationAdapter` (for testing purposes)
      */
-    responseNormalizer: (response: ResponseType<TArgs>) => NormalizedPagination<ResponseType<TArgs>>;
+    responseNormalizer: (response: ResponseType<TArgs>) => TNormPagination;
     /**
      * The query creator function that will be used to create the paged query.
      */
@@ -62,7 +62,7 @@ export type PagedQueryStackResetOptions = {
      */
     initialPage?: number;
 };
-export type PagedQueryStackExecuteOptions<TArgs extends QueryArgs> = {
+export type PagedQueryStackExecuteOptions<TNormPagination extends NormalizedPagination<unknown>> = {
     /**
      * 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.
@@ -71,7 +71,7 @@ export type PagedQueryStackExecuteOptions<TArgs extends QueryArgs> = {
      * @example
      * myPagedQuery.execute({ where: (item) => item.id === 4 });
      */
-    where?: (item: ResponseType<TArgs>, index: number, array: ResponseType<TArgs>[]) => boolean;
+    where?: (item: TNormPagination['items'][number], index: number, array: TNormPagination['items']) => boolean;
     /**
      * If true, the cache will be used (if not expired) and the request will not be made.
      * @default false
@@ -79,12 +79,12 @@ export type PagedQueryStackExecuteOptions<TArgs extends QueryArgs> = {
     allowCache?: boolean;
 };
 export type PagedQueryStackDirection = 'next' | 'previous';
-export type AnyPagedQueryStack = PagedQueryStack<AnyQuery>;
-export type PagedQueryStack<TQuery extends AnyQuery> = {
+export type AnyPagedQueryStack = PagedQueryStack<AnyQuery, NormalizedPagination<unknown>>;
+export type PagedQueryStack<TQuery extends AnyQuery, TNormPagination extends NormalizedPagination<unknown>> = {
     /**
      * The current pagination state of the paged query.
      */
-    pagination: Signal<NormalizedPagination<ResponseType<QueryArgsOf<TQuery>>> | null>;
+    pagination: Signal<TNormPagination | null>;
     /**
      * Fetches the previous page of the paged query.
      *
@@ -112,7 +112,7 @@ export type PagedQueryStack<TQuery extends AnyQuery> = {
     /**
      * The items of the paged query.
      */
-    items: Signal<ResponseType<QueryArgsOf<TQuery>>[]>;
+    items: Signal<TNormPagination['items']>;
     /**
      * Whether the paged query is loading or not.
      */
@@ -140,10 +140,10 @@ export type PagedQueryStack<TQuery extends AnyQuery> = {
     /**
      * Executes the paged query.
      */
-    execute: (options?: PagedQueryStackExecuteOptions<QueryArgsOf<TQuery>>) => void;
+    execute: (options?: PagedQueryStackExecuteOptions<TNormPagination>) => void;
     /**
      * The current direction of the paged query.
      */
     direction: Signal<PagedQueryStackDirection>;
 };
-export declare const createPagedQueryStack: <TCreator extends AnyQueryCreator, TArgs extends QueryArgsOf<TCreator>>(options: CreatePagedQueryStackOptions<TArgs>) => PagedQueryStack<Query<TArgs>>;
+export declare const createPagedQueryStack: <TCreator extends AnyQueryCreator, TArgs extends QueryArgsOf<TCreator>, TNormPagination extends NormalizedPagination<unknown>>(options: CreatePagedQueryStackOptions<TArgs, TNormPagination>) => PagedQueryStack<Query<TArgs>, TNormPagination>;

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

@@ -23,7 +23,8 @@ export declare const enum QueryRuntimeErrorCode {
     PAGED_QUERY_STACK_PAGE_BIGGER_THAN_TOTAL_PAGES = 400,
     PAGED_QUERY_STACK_NEXT_PAGE_CALLED_WITHOUT_PREVIOUS_PAGE = 401,
     PAGED_QUERY_STACK_PREVIOUS_PAGE_CALLED_BUT_ALREADY_AT_FIRST_PAGE = 402,
-    QUERY_STACK_WITH_ARGS_USED = 500
+    QUERY_STACK_WITH_ARGS_USED = 500,
+    QUERY_STACK_WITH_RESPONSE_UPDATE_USED = 501
 }
 export declare const queryFeatureUsedMultipleTimes: (type: QueryFeatureType) => RuntimeError<QueryRuntimeErrorCode.QUERY_FEATURE_USED_MULTIPLE_TIMES>;
 export declare const withArgsQueryFeatureMissingButRouteIsFunction: () => RuntimeError<QueryRuntimeErrorCode.WITH_ARGS_QUERY_FEATURE_MISSING_BUT_ROUTE_IS_FUNCTION>;
@@ -48,3 +49,4 @@ export declare const pagedQueryStackPageBiggerThanTotalPages: (page: number, tot
 export declare const pagedQueryStackNextPageCalledWithoutPreviousPage: () => RuntimeError<QueryRuntimeErrorCode.PAGED_QUERY_STACK_NEXT_PAGE_CALLED_WITHOUT_PREVIOUS_PAGE>;
 export declare const pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage: () => RuntimeError<QueryRuntimeErrorCode.PAGED_QUERY_STACK_PREVIOUS_PAGE_CALLED_BUT_ALREADY_AT_FIRST_PAGE>;
 export declare const queryStackWithArgsUsed: () => RuntimeError<QueryRuntimeErrorCode.QUERY_STACK_WITH_ARGS_USED>;
+export declare const queryStackWithResponseUpdateUsed: () => RuntimeError<QueryRuntimeErrorCode.QUERY_STACK_WITH_RESPONSE_UPDATE_USED>;

package/lib/experimental/http/query-features.d.ts

@@ -11,7 +11,8 @@ export declare const enum QueryFeatureType {
     WithErrorHandling = "withErrorHandling",
     WithSuccessHandling = "withSuccessHandling",
     WithPolling = "withPolling",
-    WithAutoRefresh = "withAutoRefresh"
+    WithAutoRefresh = "withAutoRefresh",
+    WithResponseUpdate = "withResponseUpdate"
 }
 export type QueryFeatureContext<TArgs extends QueryArgs> = {
     state: QueryState<TArgs>;
@@ -82,4 +83,38 @@ export type WithAutoRefreshFeatureOptions = {
  * @throws If the query has the `onlyManualExecution` query config flag set and `ignoreOnlyManualExecution` is not set
  */
 export declare const withAutoRefresh: <TArgs extends QueryArgs>(options: WithAutoRefreshFeatureOptions) => QueryFeature<TArgs>;
+export type WithResponseUpdateFeatureFnData<TArgs extends QueryArgs> = {
+    /** The current response of the query */
+    currentResponse: ResponseType<TArgs> | null;
+};
+export type WithResponseUpdateFeatureOptions<TArgs extends QueryArgs> = {
+    /**
+     * A function that will be called with the latest response
+     * If the function returns `null`, the response will not be updated.
+     * Otherwise, the response will be updated with the returned value.
+     * The function will be called in a reactive signal context.
+     * If the query get's executed after the response was updated, the response will be set the the fresh data received from the server.
+     *
+     * This feature is most useful in combination with web sockets where the data received from the socket might be more up-to-date than the data received previously.
+     *
+     * @example
+     * const matchEvents = mySocket.joinRoom('match-events');
+     *
+     * const myMatchQuery = getMatch(
+     *  withArgs(() => ({ matchId: 1 })),
+     *  withResponseUpdate(({ currentResponse }) => {
+     *   const matchEvent = matchEvents();
+     *
+     *   if (!matchEvent) return null;
+     *
+     *   // Do some checks here. This is just a very simple example.
+     *   // To apply partial updates, you can use the spread operator in combination with the current response.
+     *
+     *   return matchEvent;
+     *  })
+     * )
+     */
+    updater: (data: WithResponseUpdateFeatureFnData<TArgs>) => ResponseType<TArgs> | null;
+};
+export declare const withResponseUpdate: <TArgs extends QueryArgs>(options: WithResponseUpdateFeatureOptions<TArgs>) => QueryFeature<TArgs>;
 export {};

package/lib/experimental/http/query-state.d.ts

@@ -1,8 +1,11 @@
 import { HttpErrorResponse, HttpEvent } from '@angular/common/http';
 import { WritableSignal } from '@angular/core';
-import { HttpRequestLoadingState } from './http-request';
+import { HttpRequest, HttpRequestLoadingState } from './http-request';
 import { QueryArgs, RequestArgs, ResponseType } from './query';
 export type SetupQueryStateOptions = {};
+export type QueryStateSubtle<TArgs extends QueryArgs> = {
+    request: WritableSignal<HttpRequest<TArgs> | null>;
+};
 export type QueryState<TArgs extends QueryArgs> = {
     response: WritableSignal<ResponseType<TArgs> | null>;
     args: WritableSignal<RequestArgs<TArgs> | null>;
@@ -10,5 +13,6 @@ export type QueryState<TArgs extends QueryArgs> = {
     loading: WritableSignal<HttpRequestLoadingState | null>;
     error: WritableSignal<HttpErrorResponse | null>;
     lastTimeExecutedAt: WritableSignal<number | null>;
+    subtle: QueryStateSubtle<TArgs>;
 };
 export declare const setupQueryState: <TArgs extends QueryArgs>(options: SetupQueryStateOptions) => QueryState<TArgs>;

package/lib/experimental/http/query.d.ts

@@ -49,9 +49,11 @@ export type QuerySnapshot<TArgs extends QueryArgs> = QueryBase<TArgs> & {
 };
 export type AnyQuerySnapshot = QuerySnapshot<any>;
 export type AnyQuery = Query<any>;
-export type QuerySubtle = {
+export type QuerySubtle<TArgs extends QueryArgs> = {
     /** Destroys the query and cleans up all resources. The query should not be used after this method is called. */
     destroy: () => void;
+    /** Manually sets the response of the query. This will not trigger a new execution of the query. */
+    setResponse: (response: ResponseType<TArgs>) => void;
 };
 export type Query<TArgs extends QueryArgs> = QueryBase<TArgs> & {
     /** Executes the query */
@@ -61,6 +63,6 @@ export type Query<TArgs extends QueryArgs> = QueryBase<TArgs> & {
     /** Resets the query state to its initial state */
     reset: () => void;
     /** Advanced query features. **WARNING!** Incorrectly using these features will likely **BREAK** your application. You have been warned! */
-    subtle: QuerySubtle;
+    subtle: QuerySubtle<TArgs>;
 };
 export declare const createQuery: <TArgs extends QueryArgs>(options: CreateQueryOptions<TArgs>) => Query<TArgs>;

package/lib/experimental/ws/web-socket-client-config.d.ts

@@ -1,10 +1,12 @@
 import { InjectionToken } from '@angular/core';
 import { SocketMessageView, WebSocketClient } from './web-socket-client';
 export type CreateWebSocketClientConfig = {
+    /** A unique name for the client */
     name: string;
+    /** The URL of the socket io server */
     url: string;
 };
-export type WebSocketClientRef<T extends SocketMessageView = SocketMessageView> = InjectionToken<WebSocketClient<T>>;
+export type WebSocketClientRef<TMessageData extends SocketMessageView = SocketMessageView> = InjectionToken<WebSocketClient<TMessageData>>;
 export type WebSocketClientConfig = CreateWebSocketClientConfig & {
     /** A generated token for dependency injection */
     token: WebSocketClientRef;

package/lib/experimental/ws/web-socket-client.d.ts

@@ -1,20 +1,37 @@
-import { Signal } from '@angular/core';
+import { Signal, WritableSignal } from '@angular/core';
 import { WebSocketClientConfig } from './web-socket-client-config';
-export type SocketMessageView = {
+/** A default socket io message view */
+export type SocketMessageView<TMessageData = unknown> = {
     room: string;
     event: string;
-    data: unknown | null;
+    data: TMessageData;
 };
-export type WebSocketClient<T extends SocketMessageView> = {
-    joinRoom: (room: string) => void;
-    joinComputedRoom: (room: () => string | null) => void;
+export type WebSocketClientSubtle = {
+    /** Leave a socket io room */
     leaveRoom: (room: string) => void;
-    leaveAllRooms: () => void;
-    currentEvent: Signal<T | null>;
+};
+export type WebSocketClient<TMessageData extends SocketMessageView> = {
+    /**
+     * Join a socket io room
+     * If a function is passed, it will be evaluated in a reactive signal context.
+     * If the function returns null, no room will be joined.
+     * If the function returns a string, the previous room will be left and the new room will be joined.
+     */
+    joinRoom: (room: string | (() => string | null)) => Signal<WebSocketRoom<TMessageData> | null>;
+    /** Whether the client is connected to the server */
     isConnected: Signal<boolean>;
+    /** Advanced web socket features. **WARNING!** Incorrectly using these features will likely **BREAK** your application. You have been warned! */
+    subtle: WebSocketClientSubtle;
+};
+export type InternalWebSocketRoom<TMessageData extends SocketMessageView> = {
+    latestMessage: WritableSignal<TMessageData | null>;
+};
+export type WebSocketRoom<TMessageData extends SocketMessageView> = {
+    /** The latest message received in the room */
+    latestMessage: Signal<TMessageData | null>;
 };
-export declare const createWebSocketClient: <T extends SocketMessageView>(config: WebSocketClientConfig) => WebSocketClient<T>;
+export declare const createWebSocketClient: <TMessageData extends SocketMessageView>(config: WebSocketClientConfig) => WebSocketClient<TMessageData>;
 export declare const provideWebSocketClient: (config: WebSocketClientConfig) => {
     provide: import("./web-socket-client-config").WebSocketClientRef<SocketMessageView>;
-    useFactory: () => WebSocketClient<SocketMessageView>;
+    useFactory: () => WebSocketClient<SocketMessageView<unknown>>;
 };

package/lib/experimental/ws/web-socket-errors.d.ts

@@ -1,9 +1,7 @@
 import { RuntimeError } from '@ethlete/core';
-export declare const enum QueryRuntimeErrorCode {
-    ROOM_ALREADY_JOINED = 1000,
-    ROOM_NOT_JOINED = 1001,
-    MESSAGE_MALFORMED = 1002
+export declare const enum WebSocketRuntimeErrorCode {
+    ROOM_NOT_JOINED = 1000,
+    MESSAGE_MALFORMED = 1001
 }
-export declare const roomAlreadyJoined: (room: string) => RuntimeError<QueryRuntimeErrorCode.ROOM_ALREADY_JOINED>;
-export declare const roomNotJoined: (room: string) => RuntimeError<QueryRuntimeErrorCode.ROOM_NOT_JOINED>;
-export declare const messageMalformed: () => RuntimeError<QueryRuntimeErrorCode.MESSAGE_MALFORMED>;
+export declare const roomNotJoined: (room: string) => RuntimeError<WebSocketRuntimeErrorCode.ROOM_NOT_JOINED>;
+export declare const messageMalformed: () => RuntimeError<WebSocketRuntimeErrorCode.MESSAGE_MALFORMED>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ethlete/query",
-  "version": "5.24.0",
+  "version": "5.25.1",
   "sideEffects": false,
   "peerDependencies": {
     "@angular/common": "19.1.4",