@ethlete/query 5.25.0 → 5.26.0

package/lib/experimental/gql/gql-query-creator-templates.d.ts

@@ -1,11 +1,12 @@
+import { GQL } from '../../gql';
 import { QueryClientConfig } from '../http';
 import { GqlQueryArgs } from './gql-query';
 import { CreateGqlQueryCreatorOptions } from './gql-query-creator';
 /** A query creator that creates a GQL query where the payload is sent via GET (query params) */
-export declare const createGqlQueryViaGet: (client: QueryClientConfig) => <TArgs extends GqlQueryArgs>(creatorOptions: CreateGqlQueryCreatorOptions<TArgs>) => import("../http").QueryCreator<TArgs>;
+export declare const createGqlQueryViaGet: (client: QueryClientConfig) => <TArgs extends GqlQueryArgs>(query: GQL, creatorOptions?: CreateGqlQueryCreatorOptions<TArgs>) => import("../http").QueryCreator<TArgs>;
 /** A query creator that creates a GQL query where the payload is sent via POST (body) */
-export declare const createGqlQueryViaPost: (client: QueryClientConfig) => <TArgs extends GqlQueryArgs>(creatorOptions: CreateGqlQueryCreatorOptions<TArgs>) => import("../http").QueryCreator<TArgs>;
+export declare const createGqlQueryViaPost: (client: QueryClientConfig) => <TArgs extends GqlQueryArgs>(query: GQL, creatorOptions?: CreateGqlQueryCreatorOptions<TArgs>) => import("../http").QueryCreator<TArgs>;
 /** A query creator that creates a GQL mutation where the payload is sent via GET (query params) */
-export declare const createGqlMutationViaGet: (client: QueryClientConfig) => <TArgs extends GqlQueryArgs>(creatorOptions: CreateGqlQueryCreatorOptions<TArgs>) => import("../http").QueryCreator<TArgs>;
+export declare const createGqlMutationViaGet: (client: QueryClientConfig) => <TArgs extends GqlQueryArgs>(query: GQL, creatorOptions?: CreateGqlQueryCreatorOptions<TArgs>) => import("../http").QueryCreator<TArgs>;
 /** A query creator that creates a GQL mutation where the payload is sent via POST (body) */
-export declare const createGqlMutationViaPost: (client: QueryClientConfig) => <TArgs extends GqlQueryArgs>(creatorOptions: CreateGqlQueryCreatorOptions<TArgs>) => import("../http").QueryCreator<TArgs>;
+export declare const createGqlMutationViaPost: (client: QueryClientConfig) => <TArgs extends GqlQueryArgs>(query: GQL, creatorOptions?: CreateGqlQueryCreatorOptions<TArgs>) => import("../http").QueryCreator<TArgs>;

package/lib/experimental/gql/gql-query-creator.d.ts

@@ -1,7 +1,6 @@
 import { CreateQueryCreatorOptions, QueryClientConfig, QueryCreator, RouteType } from '../http';
 import { GqlQueryArgs } from './gql-query';
-export type CreateGqlQueryCreatorOptions<TArgs extends GqlQueryArgs> = Omit<CreateQueryCreatorOptions<TArgs>, 'route'> & {
-    query: string;
+export type CreateGqlQueryCreatorOptions<TArgs extends GqlQueryArgs> = Omit<CreateQueryCreatorOptions, 'route'> & {
     route?: RouteType<TArgs>;
 };
 export type GqlQueryMethod = 'QUERY' | 'MUTATE';
@@ -10,5 +9,6 @@ export type InternalCreateGqlQueryCreatorOptions = {
     method: GqlQueryMethod;
     transport: GqlQueryTransport;
     client: QueryClientConfig;
+    query: string;
 };
-export declare const createGqlQueryCreator: <TArgs extends GqlQueryArgs>(options: CreateGqlQueryCreatorOptions<TArgs>, internals: InternalCreateGqlQueryCreatorOptions) => QueryCreator<TArgs>;
+export declare const createGqlQueryCreator: <TArgs extends GqlQueryArgs>(options: CreateGqlQueryCreatorOptions<TArgs> | undefined, internals: InternalCreateGqlQueryCreatorOptions) => QueryCreator<TArgs>;

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

@@ -4,7 +4,7 @@ import { CreateGqlQueryCreatorOptions, InternalCreateGqlQueryCreatorOptions } fr
 export type CreateGqlQueryExecuteOptions<TArgs extends QueryArgs> = {
     deps: QueryDependencies;
     state: QueryState<TArgs>;
-    creator: CreateGqlQueryCreatorOptions<TArgs>;
+    creator?: CreateGqlQueryCreatorOptions<TArgs>;
     creatorInternals: InternalCreateGqlQueryCreatorOptions;
     queryConfig: QueryConfig;
 };

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

@@ -4,7 +4,7 @@ export type GqlQueryArgs = QueryArgs & {
     variables?: Record<string, unknown>;
 };
 export type CreateGqlQueryOptions<TArgs extends GqlQueryArgs> = Omit<CreateQueryOptions<TArgs>, 'creator' | 'creatorInternals'> & {
-    creator: CreateGqlQueryCreatorOptions<TArgs>;
+    creator?: CreateGqlQueryCreatorOptions<TArgs>;
     creatorInternals: InternalCreateGqlQueryCreatorOptions;
 };
 export type GqlVariablesType<T extends GqlQueryArgs | null> = T extends GqlQueryArgs ? T['variables'] : never;

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-creator-templates.d.ts

@@ -1,24 +1,24 @@
 import { AnyBearerAuthProviderConfig } from '../auth/bearer-auth-provider-config';
 import { QueryArgs } from './query';
 import { QueryClientConfig } from './query-client-config';
-import { CreateQueryCreatorOptions } from './query-creator';
+import { CreateQueryCreatorOptions, RouteType } from './query-creator';
 /** A query creator that creates a GET query */
-export declare const createGetQuery: (client: QueryClientConfig) => <TArgs extends QueryArgs>(creatorOptions: CreateQueryCreatorOptions<TArgs>) => import("./query-creator").QueryCreator<TArgs>;
+export declare const createGetQuery: (client: QueryClientConfig) => <TArgs extends QueryArgs>(route: RouteType<TArgs>, creatorOptions?: CreateQueryCreatorOptions) => import("./query-creator").QueryCreator<TArgs>;
 /** A query creator that creates a secure GET query (requires authentication) */
-export declare const createSecureGetQuery: (client: QueryClientConfig, authProvider: AnyBearerAuthProviderConfig) => <TArgs extends QueryArgs>(creatorOptions: CreateQueryCreatorOptions<TArgs>) => import("./query-creator").QueryCreator<TArgs>;
+export declare const createSecureGetQuery: (client: QueryClientConfig, authProvider: AnyBearerAuthProviderConfig) => <TArgs extends QueryArgs>(route: RouteType<TArgs>, creatorOptions?: CreateQueryCreatorOptions) => import("./query-creator").QueryCreator<TArgs>;
 /** A query creator that creates a POST query */
-export declare const createPostQuery: (client: QueryClientConfig) => <TArgs extends QueryArgs>(creatorOptions: CreateQueryCreatorOptions<TArgs>) => import("./query-creator").QueryCreator<TArgs>;
+export declare const createPostQuery: (client: QueryClientConfig) => <TArgs extends QueryArgs>(route: RouteType<TArgs>, creatorOptions?: CreateQueryCreatorOptions) => import("./query-creator").QueryCreator<TArgs>;
 /** A query creator that creates a secure POST query (requires authentication) */
-export declare const createSecurePostQuery: (client: QueryClientConfig, authProvider: AnyBearerAuthProviderConfig) => <TArgs extends QueryArgs>(creatorOptions: CreateQueryCreatorOptions<TArgs>) => import("./query-creator").QueryCreator<TArgs>;
+export declare const createSecurePostQuery: (client: QueryClientConfig, authProvider: AnyBearerAuthProviderConfig) => <TArgs extends QueryArgs>(route: RouteType<TArgs>, creatorOptions?: CreateQueryCreatorOptions) => import("./query-creator").QueryCreator<TArgs>;
 /** A query creator that creates a PUT query */
-export declare const createPutQuery: (client: QueryClientConfig) => <TArgs extends QueryArgs>(creatorOptions: CreateQueryCreatorOptions<TArgs>) => import("./query-creator").QueryCreator<TArgs>;
+export declare const createPutQuery: (client: QueryClientConfig) => <TArgs extends QueryArgs>(route: RouteType<TArgs>, creatorOptions?: CreateQueryCreatorOptions) => import("./query-creator").QueryCreator<TArgs>;
 /** A query creator that creates a secure PUT query (requires authentication) */
-export declare const createSecurePutQuery: (client: QueryClientConfig, authProvider: AnyBearerAuthProviderConfig) => <TArgs extends QueryArgs>(creatorOptions: CreateQueryCreatorOptions<TArgs>) => import("./query-creator").QueryCreator<TArgs>;
+export declare const createSecurePutQuery: (client: QueryClientConfig, authProvider: AnyBearerAuthProviderConfig) => <TArgs extends QueryArgs>(route: RouteType<TArgs>, creatorOptions?: CreateQueryCreatorOptions) => import("./query-creator").QueryCreator<TArgs>;
 /** A query creator that creates a DELETE query */
-export declare const createDeleteQuery: (client: QueryClientConfig) => <TArgs extends QueryArgs>(creatorOptions: CreateQueryCreatorOptions<TArgs>) => import("./query-creator").QueryCreator<TArgs>;
+export declare const createDeleteQuery: (client: QueryClientConfig) => <TArgs extends QueryArgs>(route: RouteType<TArgs>, creatorOptions?: CreateQueryCreatorOptions) => import("./query-creator").QueryCreator<TArgs>;
 /** A query creator that creates a secure DELETE query (requires authentication) */
-export declare const createSecureDeleteQuery: (client: QueryClientConfig, authProvider: AnyBearerAuthProviderConfig) => <TArgs extends QueryArgs>(creatorOptions: CreateQueryCreatorOptions<TArgs>) => import("./query-creator").QueryCreator<TArgs>;
+export declare const createSecureDeleteQuery: (client: QueryClientConfig, authProvider: AnyBearerAuthProviderConfig) => <TArgs extends QueryArgs>(route: RouteType<TArgs>, creatorOptions?: CreateQueryCreatorOptions) => import("./query-creator").QueryCreator<TArgs>;
 /** A query creator that creates a PATCH query */
-export declare const createPatchQuery: (client: QueryClientConfig) => <TArgs extends QueryArgs>(creatorOptions: CreateQueryCreatorOptions<TArgs>) => import("./query-creator").QueryCreator<TArgs>;
+export declare const createPatchQuery: (client: QueryClientConfig) => <TArgs extends QueryArgs>(route: RouteType<TArgs>, creatorOptions?: CreateQueryCreatorOptions) => import("./query-creator").QueryCreator<TArgs>;
 /** A query creator that creates a secure PATCH query (requires authentication) */
-export declare const createSecurePatchQuery: (client: QueryClientConfig, authProvider: AnyBearerAuthProviderConfig) => <TArgs extends QueryArgs>(creatorOptions: CreateQueryCreatorOptions<TArgs>) => import("./query-creator").QueryCreator<TArgs>;
+export declare const createSecurePatchQuery: (client: QueryClientConfig, authProvider: AnyBearerAuthProviderConfig) => <TArgs extends QueryArgs>(route: RouteType<TArgs>, creatorOptions?: CreateQueryCreatorOptions) => import("./query-creator").QueryCreator<TArgs>;

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

@@ -6,13 +6,7 @@ export type RouteType<TArgs extends QueryArgs> = PathParamsType<TArgs> extends {
     [key: string]: unknown;
 } ? (args: TArgs['pathParams']) => RouteString : RouteString;
 export type RouteString = `/${string}`;
-export type CreateQueryCreatorOptions<TArgs extends QueryArgs> = {
-    /**
-     * The route of the query.
-     * If the query has path params, the route should be a function that takes the path params as an argument.
-     * Otherwise, it should be a string.
-     */
-    route: RouteType<TArgs>;
+export type CreateQueryCreatorOptions = {
     /**
      * If true, the query loading state will include progress information.
      * This is useful for file uploads and downloads.
@@ -53,7 +47,13 @@ export type AnyQueryCreator = QueryCreator<any>;
 export type QueryArgsOf<T extends AnyQueryCreator | AnyQuery> = T extends QueryCreator<infer TArgs> ? TArgs : T extends Query<infer TArgs> ? TArgs : never;
 export type RunQueryCreator<TCreator extends AnyQueryCreator> = ReturnType<TCreator>;
 export type QueryMethod = 'GET' | 'OPTIONS' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'TRACE' | 'CONNECT';
-export type InternalCreateQueryCreatorOptions = {
+export type InternalCreateQueryCreatorOptions<TArgs extends QueryArgs> = {
+    /**
+     * The route of the query.
+     * If the query has path params, the route should be a function that takes the path params as an argument.
+     * Otherwise, it should be a string.
+     */
+    route: RouteType<TArgs>;
     method: QueryMethod;
     client: QueryClientConfig;
 };
@@ -70,4 +70,4 @@ export declare const splitQueryConfig: <TArgs extends QueryArgs>(args: (QueryFea
     features: QueryFeature<TArgs>[];
     queryConfig: QueryConfig;
 };
-export declare const createQueryCreator: <TArgs extends QueryArgs>(options: CreateQueryCreatorOptions<TArgs>, internals: InternalCreateQueryCreatorOptions) => QueryCreator<TArgs>;
+export declare const createQueryCreator: <TArgs extends QueryArgs>(options: CreateQueryCreatorOptions | undefined, internals: InternalCreateQueryCreatorOptions<TArgs>) => QueryCreator<TArgs>;

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

@@ -8,8 +8,8 @@ import { QueryState } from './query-state';
 export type CreateQueryExecuteOptions<TArgs extends QueryArgs> = {
     deps: QueryDependencies;
     state: QueryState<TArgs>;
-    creator: CreateQueryCreatorOptions<TArgs>;
-    creatorInternals: InternalCreateQueryCreatorOptions;
+    creator?: CreateQueryCreatorOptions;
+    creatorInternals: InternalCreateQueryCreatorOptions<TArgs>;
     queryConfig: QueryConfig;
 };
 export type QueryExecuteArgs<TArgs extends QueryArgs> = {

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

@@ -17,8 +17,8 @@ export type QueryParamsType<T extends QueryArgs | null> = T extends QueryArgs ?
 export type BodyType<T extends QueryArgs | null> = T extends QueryArgs ? T['body'] : never;
 export type RequestArgs<T extends QueryArgs | null> = T extends QueryArgs ? Omit<T, 'response'> : never;
 export type CreateQueryOptions<TArgs extends QueryArgs> = {
-    creator: CreateQueryCreatorOptions<TArgs>;
-    creatorInternals: InternalCreateQueryCreatorOptions;
+    creator?: CreateQueryCreatorOptions;
+    creatorInternals: InternalCreateQueryCreatorOptions<TArgs>;
     features: QueryFeature<TArgs>[];
     queryConfig: QueryConfig;
 };

package/lib/experimental/http/secure-query-creator.d.ts

@@ -1,7 +1,7 @@
 import { AnyBearerAuthProviderConfig } from '../auth/bearer-auth-provider-config';
 import { QueryArgs } from './query';
 import { CreateQueryCreatorOptions, InternalCreateQueryCreatorOptions, QueryCreator } from './query-creator';
-export type InternalSecureCreateQueryCreatorOptions = InternalCreateQueryCreatorOptions & {
+export type InternalSecureCreateQueryCreatorOptions<TArgs extends QueryArgs> = InternalCreateQueryCreatorOptions<TArgs> & {
     authProvider: AnyBearerAuthProviderConfig;
 };
-export declare const createSecureQueryCreator: <TArgs extends QueryArgs>(options: CreateQueryCreatorOptions<TArgs>, internals: InternalSecureCreateQueryCreatorOptions) => QueryCreator<TArgs>;
+export declare const createSecureQueryCreator: <TArgs extends QueryArgs>(options: CreateQueryCreatorOptions | undefined, internals: InternalSecureCreateQueryCreatorOptions<TArgs>) => QueryCreator<TArgs>;

package/lib/experimental/http/secure-query-execute.d.ts

@@ -2,6 +2,6 @@ import { QueryArgs } from './query';
 import { CreateQueryExecuteOptions, InternalQueryExecute } from './query-execute';
 import { InternalSecureCreateQueryCreatorOptions } from './secure-query-creator';
 export type CreateSecureQueryExecuteOptions<TArgs extends QueryArgs> = Omit<CreateQueryExecuteOptions<TArgs>, 'creatorInternals'> & {
-    creatorInternals: InternalSecureCreateQueryCreatorOptions;
+    creatorInternals: InternalSecureCreateQueryCreatorOptions<TArgs>;
 };
 export declare const createSecureExecuteFn: <TArgs extends QueryArgs>(options: CreateSecureQueryExecuteOptions<TArgs>) => InternalQueryExecute<TArgs>;

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

@@ -1,6 +1,6 @@
 import { CreateQueryOptions, QueryArgs } from './query';
 import { InternalSecureCreateQueryCreatorOptions } from './secure-query-creator';
 export type CreateSecureQueryOptions<TArgs extends QueryArgs> = Omit<CreateQueryOptions<TArgs>, 'creatorInternals'> & {
-    creatorInternals: InternalSecureCreateQueryCreatorOptions;
+    creatorInternals: InternalSecureCreateQueryCreatorOptions<TArgs>;
 };
 export declare const createSecureQuery: <TArgs extends QueryArgs>(options: CreateSecureQueryOptions<TArgs>) => import("./query").Query<TArgs>;

package/lib/gql/gql.d.ts

@@ -4,4 +4,7 @@ export type TransformedGqlQuery = {
     operationName?: string;
 };
 export declare const transformGql: (str: string) => (variables: Record<string, unknown> | null | undefined) => TransformedGqlQuery;
-export declare const gql: (strings: TemplateStringsArray, ...values: string[]) => string;
+export type GQL = string & {
+    gql: 'tag';
+};
+export declare const gql: (strings: TemplateStringsArray, ...values: string[]) => GQL;

package/package.json

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