@ethlete/query 5.17.0 → 5.18.0

package/esm2022/lib/experimental/secure-query-execute.mjs

@@ -0,0 +1,77 @@
+import { HttpHeaders } from '@angular/common/http';
+import { inject } from '@angular/core';
+import { toObservable } from '@angular/core/rxjs-interop';
+import { of, Subscription, switchMap, tap } from 'rxjs';
+import { cleanupPreviousExecute, queryExecute, resetExecuteState, setupQueryExecuteState } from './query-execute-utils';
+const AUTH_HEADER = 'Authorization';
+export const createSecureExecuteFn = (options) => {
+    const executeState = setupQueryExecuteState();
+    const authProvider = inject(options.creatorInternals.authProvider.token);
+    let authQuerySubscription = Subscription.EMPTY;
+    const reset = () => {
+        authQuerySubscription.unsubscribe();
+        authQuerySubscription = Subscription.EMPTY;
+        resetExecuteState({ executeState, executeOptions: options });
+    };
+    const error = (query) => {
+        const state = options.state;
+        state.error.set(query.error());
+        state.loading.set(null);
+        state.response.set(null);
+        state.latestHttpEvent.set(null);
+        state.args.set(null);
+    };
+    const authAndExec = (args) => {
+        const tokens = authProvider.tokens();
+        let headers = args?.headers || new HttpHeaders();
+        if (!tokens) {
+            throw new Error('Tokens are not available inside authAndExec');
+        }
+        if (!headers.has(AUTH_HEADER)) {
+            headers = headers.set(AUTH_HEADER, `Bearer ${tokens.accessToken}`);
+        }
+        const updatedArgs = { ...(args ?? {}), headers };
+        queryExecute({
+            executeOptions: options,
+            executeState,
+            args: updatedArgs,
+        });
+    };
+    const exec = (args = options.state.args()) => {
+        authQuerySubscription.unsubscribe();
+        authQuerySubscription = Subscription.EMPTY;
+        cleanupPreviousExecute({ executeOptions: options, executeState, args });
+        const authQuery = authProvider.latestExecutedQuery();
+        if (!authQuery || authQuery.loading()) {
+            options.state.loading.set({ executeTime: Date.now(), progress: null });
+            authQuerySubscription = toObservable(authProvider.latestExecutedQuery, { injector: options.deps.injector })
+                .pipe(switchMap((query) => {
+                if (!query)
+                    return of(null);
+                return toObservable(query.isAlive, { injector: options.deps.injector }).pipe(tap((isAlive) => {
+                    if (isAlive)
+                        return;
+                    if (query.error()) {
+                        error(query);
+                    }
+                    else if (query.response()) {
+                        authAndExec(args);
+                    }
+                }));
+            }))
+                .subscribe();
+        }
+        else if (authQuery.response()) {
+            authAndExec(args);
+        }
+        else if (authQuery.error()) {
+            error(authQuery);
+        }
+        else {
+            throw new Error('Invalid state ocurred inside createSecureExecuteFn');
+        }
+    };
+    exec['reset'] = reset;
+    return exec;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"secure-query-execute.js","sourceRoot":"","sources":["../../../../../../libs/query/src/lib/experimental/secure-query-execute.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpHeaders } from '@angular/common/http';\nimport { inject } from '@angular/core';\nimport { toObservable } from '@angular/core/rxjs-interop';\nimport { of, Subscription, switchMap, tap } from 'rxjs';\nimport { AnyQuerySnapshot, QueryArgs, RequestArgs } from './query';\nimport { CreateQueryExecuteOptions, QueryExecute } from './query-execute';\nimport { cleanupPreviousExecute, queryExecute, resetExecuteState, setupQueryExecuteState } from './query-execute-utils';\nimport { InternalSecureCreateQueryCreatorOptions } from './secure-query-creator';\n\nconst AUTH_HEADER = 'Authorization';\n\nexport type CreateSecureQueryExecuteOptions<TArgs extends QueryArgs> = Omit<\n  CreateQueryExecuteOptions<TArgs>,\n  'creatorInternals'\n> & {\n  creatorInternals: InternalSecureCreateQueryCreatorOptions;\n};\n\nexport const createSecureExecuteFn = <TArgs extends QueryArgs>(\n  options: CreateSecureQueryExecuteOptions<TArgs>,\n): QueryExecute<TArgs> => {\n  const executeState = setupQueryExecuteState();\n  const authProvider = inject(options.creatorInternals.authProvider.token);\n\n  let authQuerySubscription = Subscription.EMPTY;\n\n  const reset = () => {\n    authQuerySubscription.unsubscribe();\n    authQuerySubscription = Subscription.EMPTY;\n    resetExecuteState({ executeState, executeOptions: options });\n  };\n\n  const error = (query: AnyQuerySnapshot) => {\n    const state = options.state;\n\n    state.error.set(query.error());\n    state.loading.set(null);\n    state.response.set(null);\n    state.latestHttpEvent.set(null);\n    state.args.set(null);\n  };\n\n  const authAndExec = (args: RequestArgs<TArgs> | null) => {\n    const tokens = authProvider.tokens();\n    let headers = args?.headers || new HttpHeaders();\n\n    if (!tokens) {\n      throw new Error('Tokens are not available inside authAndExec');\n    }\n\n    if (!headers.has(AUTH_HEADER)) {\n      headers = headers.set(AUTH_HEADER, `Bearer ${tokens.accessToken}`);\n    }\n\n    const updatedArgs = { ...(args ?? ({} as RequestArgs<TArgs>)), headers };\n\n    queryExecute({\n      executeOptions: options,\n      executeState,\n      args: updatedArgs,\n    });\n  };\n\n  const exec = (args = options.state.args()) => {\n    authQuerySubscription.unsubscribe();\n    authQuerySubscription = Subscription.EMPTY;\n    cleanupPreviousExecute({ executeOptions: options, executeState, args });\n\n    const authQuery = authProvider.latestExecutedQuery();\n\n    if (!authQuery || authQuery.loading()) {\n      options.state.loading.set({ executeTime: Date.now(), progress: null });\n\n      authQuerySubscription = toObservable(authProvider.latestExecutedQuery, { injector: options.deps.injector })\n        .pipe(\n          switchMap((query) => {\n            if (!query) return of(null);\n\n            return toObservable(query.isAlive, { injector: options.deps.injector }).pipe(\n              tap((isAlive) => {\n                if (isAlive) return;\n\n                if (query.error()) {\n                  error(query);\n                } else if (query.response()) {\n                  authAndExec(args);\n                }\n              }),\n            );\n          }),\n        )\n        .subscribe();\n    } else if (authQuery.response()) {\n      authAndExec(args);\n    } else if (authQuery.error()) {\n      error(authQuery);\n    } else {\n      throw new Error('Invalid state ocurred inside createSecureExecuteFn');\n    }\n  };\n\n  exec['reset'] = reset;\n\n  return exec;\n};\n"]}

package/esm2022/lib/experimental/secure-query.mjs

@@ -0,0 +1,41 @@
+import { setupQueryDependencies } from './query-dependencies';
+import { createQuerySnapshotFn } from './query-snapshot';
+import { setupQueryState } from './query-state';
+import { applyQueryFeatures, getQueryFeatureUsage, maybeExecute } from './query-utils';
+import { createSecureExecuteFn } from './secure-query-execute';
+export const createSecureQuery = (options) => {
+    const deps = setupQueryDependencies({ clientConfig: options.creatorInternals.client });
+    const state = setupQueryState({});
+    const { creator, creatorInternals, queryConfig } = options;
+    const flags = getQueryFeatureUsage(options);
+    const execute = createSecureExecuteFn({
+        deps,
+        state,
+        creator,
+        creatorInternals,
+        queryConfig: options.queryConfig,
+    });
+    const createSnapshot = createQuerySnapshotFn({ state, deps });
+    const featureFnContext = {
+        state,
+        queryConfig,
+        creatorConfig: creator,
+        creatorInternals,
+        execute,
+        flags,
+    };
+    applyQueryFeatures(options, featureFnContext);
+    maybeExecute({ execute, flags });
+    const query = {
+        execute,
+        args: state.args.asReadonly(),
+        response: state.response.asReadonly(),
+        latestHttpEvent: state.latestHttpEvent.asReadonly(),
+        loading: state.loading.asReadonly(),
+        error: state.error.asReadonly(),
+        lastTimeExecutedAt: state.lastTimeExecutedAt.asReadonly(),
+        createSnapshot,
+    };
+    return query;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VjdXJlLXF1ZXJ5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9xdWVyeS9zcmMvbGliL2V4cGVyaW1lbnRhbC9zZWN1cmUtcXVlcnkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLHNCQUFzQixFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFFOUQsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDekQsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUNoRCxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsb0JBQW9CLEVBQUUsWUFBWSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRXZGLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBTS9ELE1BQU0sQ0FBQyxNQUFNLGlCQUFpQixHQUFHLENBQTBCLE9BQXdDLEVBQUUsRUFBRTtJQUNyRyxNQUFNLElBQUksR0FBRyxzQkFBc0IsQ0FBQyxFQUFFLFlBQVksRUFBRSxPQUFPLENBQUMsZ0JBQWdCLENBQUMsTUFBTSxFQUFFLENBQUMsQ0FBQztJQUN2RixNQUFNLEtBQUssR0FBRyxlQUFlLENBQVEsRUFBRSxDQUFDLENBQUM7SUFDekMsTUFBTSxFQUFFLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxXQUFXLEVBQUUsR0FBRyxPQUFPLENBQUM7SUFDM0QsTUFBTSxLQUFLLEdBQUcsb0JBQW9CLENBQUMsT0FBTyxDQUFDLENBQUM7SUFFNUMsTUFBTSxPQUFPLEdBQUcscUJBQXFCLENBQVE7UUFDM0MsSUFBSTtRQUNKLEtBQUs7UUFDTCxPQUFPO1FBQ1AsZ0JBQWdCO1FBQ2hCLFdBQVcsRUFBRSxPQUFPLENBQUMsV0FBVztLQUNqQyxDQUFDLENBQUM7SUFDSCxNQUFNLGNBQWMsR0FBRyxxQkFBcUIsQ0FBQyxFQUFFLEtBQUssRUFBRSxJQUFJLEVBQUUsQ0FBQyxDQUFDO0lBRTlELE1BQU0sZ0JBQWdCLEdBQStCO1FBQ25ELEtBQUs7UUFDTCxXQUFXO1FBQ1gsYUFBYSxFQUFFLE9BQU87UUFDdEIsZ0JBQWdCO1FBQ2hCLE9BQU87UUFDUCxLQUFLO0tBQ04sQ0FBQztJQUVGLGtCQUFrQixDQUFDLE9BQU8sRUFBRSxnQkFBZ0IsQ0FBQyxDQUFDO0lBRTlDLFlBQVksQ0FBUSxFQUFFLE9BQU8sRUFBRSxLQUFLLEVBQUUsQ0FBQyxDQUFDO0lBRXhDLE1BQU0sS0FBSyxHQUFpQjtRQUMxQixPQUFPO1FBQ1AsSUFBSSxFQUFFLEtBQUssQ0FBQyxJQUFJLENBQUMsVUFBVSxFQUFFO1FBQzdCLFFBQVEsRUFBRSxLQUFLLENBQUMsUUFBUSxDQUFDLFVBQVUsRUFBRTtRQUNyQyxlQUFlLEVBQUUsS0FBSyxDQUFDLGVBQWUsQ0FBQyxVQUFVLEVBQUU7UUFDbkQsT0FBTyxFQUFFLEtBQUssQ0FBQyxPQUFPLENBQUMsVUFBVSxFQUFFO1FBQ25DLEtBQUssRUFBRSxLQUFLLENBQUMsS0FBSyxDQUFDLFVBQVUsRUFBRTtRQUMvQixrQkFBa0IsRUFBRSxLQUFLLENBQUMsa0JBQWtCLENBQUMsVUFBVSxFQUFFO1FBQ3pELGNBQWM7S0FDZixDQUFDO0lBRUYsT0FBTyxLQUFLLENBQUM7QUFDZixDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDcmVhdGVRdWVyeU9wdGlvbnMsIFF1ZXJ5LCBRdWVyeUFyZ3MgfSBmcm9tICcuL3F1ZXJ5JztcbmltcG9ydCB7IHNldHVwUXVlcnlEZXBlbmRlbmNpZXMgfSBmcm9tICcuL3F1ZXJ5LWRlcGVuZGVuY2llcyc7XG5pbXBvcnQgeyBRdWVyeUZlYXR1cmVDb250ZXh0IH0gZnJvbSAnLi9xdWVyeS1mZWF0dXJlcyc7XG5pbXBvcnQgeyBjcmVhdGVRdWVyeVNuYXBzaG90Rm4gfSBmcm9tICcuL3F1ZXJ5LXNuYXBzaG90JztcbmltcG9ydCB7IHNldHVwUXVlcnlTdGF0ZSB9IGZyb20gJy4vcXVlcnktc3RhdGUnO1xuaW1wb3J0IHsgYXBwbHlRdWVyeUZlYXR1cmVzLCBnZXRRdWVyeUZlYXR1cmVVc2FnZSwgbWF5YmVFeGVjdXRlIH0gZnJvbSAnLi9xdWVyeS11dGlscyc7XG5pbXBvcnQgeyBJbnRlcm5hbFNlY3VyZUNyZWF0ZVF1ZXJ5Q3JlYXRvck9wdGlvbnMgfSBmcm9tICcuL3NlY3VyZS1xdWVyeS1jcmVhdG9yJztcbmltcG9ydCB7IGNyZWF0ZVNlY3VyZUV4ZWN1dGVGbiB9IGZyb20gJy4vc2VjdXJlLXF1ZXJ5LWV4ZWN1dGUnO1xuXG5leHBvcnQgdHlwZSBDcmVhdGVTZWN1cmVRdWVyeU9wdGlvbnM8VEFyZ3MgZXh0ZW5kcyBRdWVyeUFyZ3M+ID0gT21pdDxDcmVhdGVRdWVyeU9wdGlvbnM8VEFyZ3M+LCAnY3JlYXRvckludGVybmFscyc+ICYge1xuICBjcmVhdG9ySW50ZXJuYWxzOiBJbnRlcm5hbFNlY3VyZUNyZWF0ZVF1ZXJ5Q3JlYXRvck9wdGlvbnM7XG59O1xuXG5leHBvcnQgY29uc3QgY3JlYXRlU2VjdXJlUXVlcnkgPSA8VEFyZ3MgZXh0ZW5kcyBRdWVyeUFyZ3M+KG9wdGlvbnM6IENyZWF0ZVNlY3VyZVF1ZXJ5T3B0aW9uczxUQXJncz4pID0+IHtcbiAgY29uc3QgZGVwcyA9IHNldHVwUXVlcnlEZXBlbmRlbmNpZXMoeyBjbGllbnRDb25maWc6IG9wdGlvbnMuY3JlYXRvckludGVybmFscy5jbGllbnQgfSk7XG4gIGNvbnN0IHN0YXRlID0gc2V0dXBRdWVyeVN0YXRlPFRBcmdzPih7fSk7XG4gIGNvbnN0IHsgY3JlYXRvciwgY3JlYXRvckludGVybmFscywgcXVlcnlDb25maWcgfSA9IG9wdGlvbnM7XG4gIGNvbnN0IGZsYWdzID0gZ2V0UXVlcnlGZWF0dXJlVXNhZ2Uob3B0aW9ucyk7XG5cbiAgY29uc3QgZXhlY3V0ZSA9IGNyZWF0ZVNlY3VyZUV4ZWN1dGVGbjxUQXJncz4oe1xuICAgIGRlcHMsXG4gICAgc3RhdGUsXG4gICAgY3JlYXRvcixcbiAgICBjcmVhdG9ySW50ZXJuYWxzLFxuICAgIHF1ZXJ5Q29uZmlnOiBvcHRpb25zLnF1ZXJ5Q29uZmlnLFxuICB9KTtcbiAgY29uc3QgY3JlYXRlU25hcHNob3QgPSBjcmVhdGVRdWVyeVNuYXBzaG90Rm4oeyBzdGF0ZSwgZGVwcyB9KTtcblxuICBjb25zdCBmZWF0dXJlRm5Db250ZXh0OiBRdWVyeUZlYXR1cmVDb250ZXh0PFRBcmdzPiA9IHtcbiAgICBzdGF0ZSxcbiAgICBxdWVyeUNvbmZpZyxcbiAgICBjcmVhdG9yQ29uZmlnOiBjcmVhdG9yLFxuICAgIGNyZWF0b3JJbnRlcm5hbHMsXG4gICAgZXhlY3V0ZSxcbiAgICBmbGFncyxcbiAgfTtcblxuICBhcHBseVF1ZXJ5RmVhdHVyZXMob3B0aW9ucywgZmVhdHVyZUZuQ29udGV4dCk7XG5cbiAgbWF5YmVFeGVjdXRlPFRBcmdzPih7IGV4ZWN1dGUsIGZsYWdzIH0pO1xuXG4gIGNvbnN0IHF1ZXJ5OiBRdWVyeTxUQXJncz4gPSB7XG4gICAgZXhlY3V0ZSxcbiAgICBhcmdzOiBzdGF0ZS5hcmdzLmFzUmVhZG9ubHkoKSxcbiAgICByZXNwb25zZTogc3RhdGUucmVzcG9uc2UuYXNSZWFkb25seSgpLFxuICAgIGxhdGVzdEh0dHBFdmVudDogc3RhdGUubGF0ZXN0SHR0cEV2ZW50LmFzUmVhZG9ubHkoKSxcbiAgICBsb2FkaW5nOiBzdGF0ZS5sb2FkaW5nLmFzUmVhZG9ubHkoKSxcbiAgICBlcnJvcjogc3RhdGUuZXJyb3IuYXNSZWFkb25seSgpLFxuICAgIGxhc3RUaW1lRXhlY3V0ZWRBdDogc3RhdGUubGFzdFRpbWVFeGVjdXRlZEF0LmFzUmVhZG9ubHkoKSxcbiAgICBjcmVhdGVTbmFwc2hvdCxcbiAgfTtcblxuICByZXR1cm4gcXVlcnk7XG59O1xuIl19

package/esm2022/lib/query/query.types.mjs

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query.types.js","sourceRoot":"","sources":["../../../../../../libs/query/src/lib/query/query.types.ts"],"names":[],"mappings":"","sourcesContent":["import { Observable } from 'rxjs';\nimport { EntityStore } from '../entity';\nimport { AnyQueryCreator, ConstructQuery, QueryDataOf, QueryResponseOf } from '../query-creator';\nimport { QueryForm } from '../query-form';\nimport { Method, PathParams, QueryParams, RequestError, RequestHeaders, RequestProgress } from '../request';\nimport { Query } from './query';\n\nexport interface QueryAutoRefreshConfig {\n  /**\n   * Refresh the query when the query client's headers change.\n   * @default true\n   */\n  queryClientDefaultHeadersChange?: boolean;\n\n  /**\n   * Refresh the query when the window regains focus.\n   *\n   * This can only be disabled if `autoRefreshQueriesOnWindowFocus` is enabled on the query client.\n   * @default true\n   */\n  windowFocus?: boolean;\n}\n\nexport interface EntitySetParams<Store, Response, Arguments, Id> {\n  /**\n   * The response data.\n   */\n  response: Response;\n\n  /**\n   * The id(s) returned by the `id` function.\n   */\n  id: Id;\n\n  /**\n   * The arguments passed to the query.\n   */\n  args: Arguments;\n\n  /**\n   * The entity store.\n   */\n  store: Store;\n}\n\nexport interface EntityGetParams<Store, Response, Arguments, Id> {\n  /**\n   * The response data.\n   */\n  response: Response;\n\n  /**\n   * The id(s) returned by the `id` function.\n   */\n  id: Id;\n\n  /**\n   * The arguments passed to the query.\n   */\n  args: Arguments;\n\n  /**\n   * The entity store.\n   */\n  store: Store;\n}\n\nexport interface EntityIdParams<Response, Arguments> {\n  /**\n   * The response data.\n   */\n  response: Response;\n\n  /**\n   * The arguments passed to the query.\n   */\n  args: Arguments;\n}\n\nexport interface QueryEntityConfig<Store, Data, Response, Arguments, Id> {\n  /**\n   * The entity store to use for the query.\n   */\n  store: Store;\n\n  /**\n   * A function that returns the id of the entity. Can also return an array of ids.\n   */\n  id: (data: EntityIdParams<Response, Arguments>) => Id;\n\n  /**\n   * A function that returns the response data (can be a subset of the response).\n   */\n  get?: (data: EntityGetParams<Store, Response, Arguments, Id>) => Observable<Data>;\n\n  /**\n   * A function to update the entity store every time a new response is received.\n   */\n  set?: (data: EntitySetParams<Store, Response, Arguments, Id>) => void;\n}\n\nexport type QueryConfigBase<\n  Response,\n  Arguments extends BaseArguments | undefined,\n  Store extends EntityStore<unknown>,\n  Data,\n  Id,\n> = {\n  /**\n   * The http method to use for the query.\n   */\n  method: Method;\n\n  /**\n   * Determines if the auth provider should be used for this query.\n   * The query **will throw** if the query client's auth provider is unset.\n   */\n  secure?: boolean;\n\n  /**\n   * Determines if the query should emit progress events.\n   */\n  reportProgress?: boolean;\n\n  /**\n   * Determines the query's response type.\n   * @default 'json'\n   */\n  responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';\n\n  /**\n   * Whether this request should be sent with outgoing credentials (cookies).\n   * @default false\n   */\n  withCredentials?: boolean;\n\n  /**\n   * Configuration for handling auto refresh triggers.\n   *\n   * **Note:** This is only available for queries that can be refreshed. (`GET`, `HEAD`, `OPTIONS`, `GQL_QUERY`)\n   */\n  autoRefreshOn?: QueryAutoRefreshConfig;\n\n  /**\n   * Whether to automatically stop polling for this query when the window loses focus.\n   * Polling will resume when the window regains focus.\n   *\n   * This can only be disabled if `enableSmartPolling` is enabled on the query client.\n   * @default true\n   */\n  enableSmartPolling?: boolean;\n\n  /**\n   * Object containing the query's type information.\n   */\n  types?: {\n    /**\n     * The type of the successful response.\n     */\n    response?: Response;\n\n    /**\n     * Arguments for executing the query.\n     *\n     * - `pathParams`: The path parameters for the query. (in front of the ? in the url)\n     * - `queryParams`: The query parameters for the query. (after the ? in the url)\n     * - `body`: The body for the query. Unavailable for GET, HEAD and OPTIONS requests.\n     * - `headers`: The headers for the query.\n     * - `variables`: The variables for the query. (graphql only)\n     */\n    args?: Arguments;\n  };\n\n  /**\n   * Object containing the query's entity store information.\n   */\n  entity?: QueryEntityConfig<Store, Data, Response, Arguments, Id>;\n};\n\nexport type RestQueryConfig<\n  Route extends RouteType<Arguments>,\n  Response,\n  Arguments extends BaseArguments | undefined,\n  Store extends EntityStore<unknown>,\n  Data,\n  Id,\n> = QueryConfigBase<Response, Arguments, Store, Data, Id> & {\n  /**\n   * The api route to use for the query.\n   */\n  route: Route;\n};\n\nexport type GqlTransferOption = 'GET' | 'POST';\n\nexport interface GqlQueryConfig<\n  Route extends RouteType<Arguments> | undefined,\n  Response,\n  Arguments extends BaseArguments | undefined,\n  Store extends EntityStore<unknown>,\n  Data,\n  Id,\n> extends QueryConfigBase<Response, Arguments, Store, Data, Id> {\n  /**\n   * The graphql query to use for the query.\n   */\n  query: string;\n\n  /**\n   * Determines if the query should be sent via GET or POST.\n   * - `GET`: The query will be sent via query parameters.\n   * - `POST`: The query will be sent via the body.\n   * @default 'POST'\n   */\n  transferVia?: GqlTransferOption;\n\n  /**\n   * Subroute to use for the query.\n   */\n  route?: Route;\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type AnyRestQueryConfig = RestQueryConfig<any, any, any, any, any, any>;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type AnyGqlQueryConfig = GqlQueryConfig<any, any, any, any, any, any>;\n\nexport type QueryConfigWithoutMethod<\n  Route extends RouteType<Arguments>,\n  Response,\n  Arguments extends BaseArguments | undefined,\n  Store extends EntityStore<unknown>,\n  Data,\n  Id,\n> = Omit<RestQueryConfig<Route, Response, Arguments, Store, Data, Id>, 'method'>;\n\nexport type GqlQueryConfigWithoutMethod<\n  Route extends RouteType<Arguments>,\n  Response,\n  Arguments extends BaseArguments | undefined,\n  Store extends EntityStore<unknown>,\n  Data,\n  Id,\n> = Omit<GqlQueryConfig<Route, Response, Arguments, Store, Data, Id>, 'method'>;\n\nexport type BaseArguments = WithHeaders &\n  WithVariables &\n  WithBody &\n  WithQueryParams &\n  WithPathParams &\n  WithMock<unknown>;\n\nexport interface WithHeaders {\n  /**\n   * The headers to send with the query.\n   */\n  headers?: Record<string, string>;\n}\n\nexport interface QueryMockConfig<MockResponse> {\n  /**\n   * The mock response to use for the query.\n   */\n  response?: MockResponse;\n\n  /**\n   * The mock error to use for the query.\n   */\n  error?: RequestError;\n\n  /**\n   * The delay in milliseconds to wait before resolving the mock.\n   * If progress is enabled, the delay will be used for each progress event.\n   * @default 200\n   */\n  delay?: number;\n\n  /**\n   * Whether to report progress for the mock.\n   * For testing e.g. file uploads.\n   */\n  progress?: {\n    /**\n     * The number of progress events to report.\n     * @default 5\n     */\n    eventCount?: number;\n\n    /**\n     * The type of progress event to report.\n     * @default 'upload'\n     */\n    eventType?: 'download' | 'upload';\n\n    /**\n     * The total size of the file to report progress for in bytes.\n     * @default 1_000_000 (1MB)\n     */\n    fileSize?: number;\n\n    /**\n     * If true, the total size of the file will be omitted from the progress event.\n     * Useful for testing e.g. download progress when the server does not provide a total size.\n     */\n    omitTotal?: boolean;\n\n    /**\n     * If true, the partial text will be omitted from the progress event.\n     * Useful for testing e.g. download progress when the server does not provide a partial text.\n     */\n    omitPartialText?: boolean;\n  };\n\n  /**\n   * This will mock the request failing and getting retried 3 times. After, the request will succeed with the provided response.\n   * Can not be used with `progress` enabled.\n   * @default false\n   */\n  retryIntoResponse?: boolean;\n}\n\nexport interface WithMock<MockResponse> {\n  mock?: QueryMockConfig<MockResponse>;\n}\n\nexport interface QueryConfig {\n  /**\n   * Whether this query should be added to the internal query store.\n   *\n   * Generally this should be left on `false` unless you know what you are doing.\n   * @default false\n   */\n  skipQueryStore?: boolean;\n\n  /**\n   * The cache key to use for this query.\n   * Useful for queries that are equal but should be stored separately.\n   * Will be generated automatically if not provided.\n   *\n   * Generally this should be left on `undefined` unless you know what you are doing.\n   */\n  queryStoreCacheKey?: string;\n}\n\nexport interface WithConfig {\n  /**\n   * Additional configuration for this query.\n   */\n  config?: QueryConfig;\n}\n\nexport interface WithVariables {\n  /**\n   * The variables for the query. (graphql only)\n   */\n  variables?: Record<string, unknown>;\n}\n\nexport interface WithBody {\n  /**\n   * The body for the query. Unavailable for GET, HEAD and OPTIONS requests.\n   */\n  body?: unknown;\n}\n\nexport interface WithQueryParams {\n  /**\n   * The query parameters for the query. (after the ? in the url)\n   */\n  queryParams?: QueryParams;\n}\n\nexport interface WithPathParams {\n  /**\n   * The path parameters for the query. (in front of the ? in the url)\n   */\n  pathParams?: PathParams;\n}\n\nexport type QueryTrigger = 'program' | 'poll' | 'auto';\n\n// eslint-disable-next-line @typescript-eslint/ban-types\nexport type EmptyObject = {};\n\nexport interface ExecuteQueryOptions {\n  /**\n   * Whether to skip the cache for this query. This will force the query to be executed. It might still be caught by the native browser cache.\n   * @default false\n   */\n  skipCache?: boolean;\n\n  /**\n   * Whether to cancel the previous request if it is still loading.\n   * @default false\n   */\n  cancelPrevious?: boolean;\n\n  /**\n   * The trigger type for this query.\n   * - `program`: The query was triggered by the user.\n   * - `poll`: The query was triggered by polling.\n   * - `auto`: The query was triggered by an auto refresh event.\n   * @default 'program'\n   * @internal\n   */\n  _triggeredVia?: QueryTrigger;\n\n  /**\n   * Whether this is a retry of an unauthorized request.\n   * @internal\n   */\n  _isUnauthorizedRetry?: boolean;\n}\n\nexport type RouteType<Arguments extends BaseArguments | undefined> = Arguments extends {\n  pathParams: infer PathParams;\n}\n  ? (p: PathParams) => RouteString\n  : RouteString;\n\nexport type RouteString = `/${string}`;\n\nexport type AnyRoute = ((p: PathParams) => string) | RouteString;\n\nexport interface PollConfig {\n  /**\n   * The interval in milliseconds to poll the query.\n   */\n  interval: number;\n\n  /**\n   * A observable that will stop the polling when it emits.\n   */\n  takeUntil: Observable<unknown>;\n\n  /**\n   * Whether to trigger the query immediately after polling starts.\n   */\n  triggerImmediately?: boolean;\n}\n\nexport const enum QueryStateType {\n  Prepared = 'PREPARED',\n  Loading = 'LOADING',\n  Success = 'SUCCESS',\n  Failure = 'FAILURE',\n  Cancelled = 'CANCELLED',\n}\n\nexport interface Prepared {\n  type: QueryStateType.Prepared;\n  meta: QueryStateMeta;\n}\n\nexport interface Success<Response = unknown> {\n  type: QueryStateType.Success;\n  response: Response;\n  headers: RequestHeaders;\n  meta: QueryStateSuccessMeta;\n}\n\nexport interface Failure {\n  type: QueryStateType.Failure;\n  error: RequestError;\n  meta: QueryStateMeta;\n}\n\nexport interface Loading {\n  type: QueryStateType.Loading;\n  meta: QueryStateMeta;\n  partialText?: string;\n  progress?: RequestProgress;\n}\n\nexport interface Cancelled {\n  type: QueryStateType.Cancelled;\n  meta: QueryStateMeta;\n}\n\nexport interface QueryStateMeta {\n  id: number;\n  triggeredVia: QueryTrigger;\n  isWaitingForRetry?: boolean;\n  retryNumber?: number;\n  retryDelay?: number;\n}\n\nexport interface QueryStateSuccessMeta extends QueryStateMeta {\n  expiresAt?: number;\n}\n\nexport type QueryState<Response = unknown> = Loading | Success<Response> | Failure | Cancelled | Prepared;\n\nexport type QueryStateResponseOf<T extends QueryState = QueryState> =\n  T extends Success<infer Response> ? Response : never;\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type AnyQuery = Query<any, any, any, any, any, any>;\n\nexport type AnyQueryCreatorCollection = { [name: string]: AnyQueryCreator };\n\nexport type QueryCollectionOf<T extends { [name: string]: AnyQueryCreator }> = {\n  [K in keyof T]: { type: K; query: ConstructQuery<T[K]> };\n}[keyof T];\n\nexport type AnyQueryCollection = QueryCollectionOf<AnyQueryCreatorCollection>;\n\nexport type QueryOf<T extends AnyQueryCollection | AnyQuery | null> = T extends AnyQuery\n  ? T\n  : T extends AnyQueryCollection\n    ? T['query']\n    : never;\n\nexport type AnyQueryCollectionResponse<T extends AnyQueryCollection> = QueryResponseOf<T['query']>;\nexport type AnyQueryCollectionData<T extends AnyQueryCollection> = QueryDataOf<T['query']>;\n\nexport type QueryCollectionKeysOf<T extends AnyQueryCollection | AnyQuery | null> = T extends AnyQueryCollection\n  ? T['type']\n  : never;\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport interface ResetPageOnErrorOperatorConfig<J extends QueryForm<any>> {\n  /**\n   * The query form to reset the page of.\n   */\n  queryForm: J;\n\n  /**\n   * The key of the page control in the query form.\n   * @default 'page'\n   */\n  pageControlKey?: string;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query.types.js","sourceRoot":"","sources":["../../../../../../libs/query/src/lib/query/query.types.ts"],"names":[],"mappings":"","sourcesContent":["import { Observable } from 'rxjs';\nimport { EntityStore } from '../entity';\nimport { AnyQueryCreator, ConstructQuery, QueryDataOf, QueryResponseOf } from '../query-creator';\nimport { QueryForm } from '../query-form';\nimport { Method, PathParams, QueryParams, RequestError, RequestHeaders, RequestProgress } from '../request';\nimport { Query } from './query';\n\nexport interface QueryAutoRefreshConfig {\n  /**\n   * Refresh the query when the query client's headers change.\n   * @default true\n   */\n  queryClientDefaultHeadersChange?: boolean;\n\n  /**\n   * Refresh the query when the window regains focus.\n   *\n   * This can only be disabled if `autoRefreshQueriesOnWindowFocus` is enabled on the query client.\n   * @default true\n   */\n  windowFocus?: boolean;\n}\n\nexport interface EntitySetParams<Store, Response, Arguments, Id> {\n  /**\n   * The response data.\n   */\n  response: Response;\n\n  /**\n   * The id(s) returned by the `id` function.\n   */\n  id: Id;\n\n  /**\n   * The arguments passed to the query.\n   */\n  args: Arguments;\n\n  /**\n   * The entity store.\n   */\n  store: Store;\n}\n\nexport interface EntityGetParams<Store, Response, Arguments, Id> {\n  /**\n   * The response data.\n   */\n  response: Response;\n\n  /**\n   * The id(s) returned by the `id` function.\n   */\n  id: Id;\n\n  /**\n   * The arguments passed to the query.\n   */\n  args: Arguments;\n\n  /**\n   * The entity store.\n   */\n  store: Store;\n}\n\nexport interface EntityIdParams<Response, Arguments> {\n  /**\n   * The response data.\n   */\n  response: Response;\n\n  /**\n   * The arguments passed to the query.\n   */\n  args: Arguments;\n}\n\nexport interface QueryEntityConfig<Store, Data, Response, Arguments, Id> {\n  /**\n   * The entity store to use for the query.\n   */\n  store: Store;\n\n  /**\n   * A function that returns the id of the entity. Can also return an array of ids.\n   */\n  id: (data: EntityIdParams<Response, Arguments>) => Id;\n\n  /**\n   * A function that returns the response data (can be a subset of the response).\n   */\n  get?: (data: EntityGetParams<Store, Response, Arguments, Id>) => Observable<Data>;\n\n  /**\n   * A function to update the entity store every time a new response is received.\n   */\n  set?: (data: EntitySetParams<Store, Response, Arguments, Id>) => void;\n}\n\nexport type QueryConfigBase<\n  Response,\n  Arguments extends BaseArguments | undefined,\n  Store extends EntityStore<unknown>,\n  Data,\n  Id,\n> = {\n  /**\n   * The http method to use for the query.\n   */\n  method: Method;\n\n  /**\n   * Determines if the auth provider should be used for this query.\n   * The query **will throw** if the query client's auth provider is unset.\n   */\n  secure?: boolean;\n\n  /**\n   * Determines if the query should emit progress events.\n   */\n  reportProgress?: boolean;\n\n  /**\n   * Determines the query's response type.\n   * @default 'json'\n   */\n  responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';\n\n  /**\n   * Whether this request should be sent with outgoing credentials (cookies).\n   * @default false\n   */\n  withCredentials?: boolean;\n\n  /**\n   * Configuration for handling auto refresh triggers.\n   *\n   * **Note:** This is only available for queries that can be refreshed. (`GET`, `HEAD`, `OPTIONS`, `GQL_QUERY`)\n   */\n  autoRefreshOn?: QueryAutoRefreshConfig;\n\n  /**\n   * Whether to automatically stop polling for this query when the window loses focus.\n   * Polling will resume when the window regains focus.\n   *\n   * This can only be disabled if `enableSmartPolling` is enabled on the query client.\n   * @default true\n   */\n  enableSmartPolling?: boolean;\n\n  /**\n   * Object containing the query's type information.\n   */\n  types?: {\n    /**\n     * The type of the successful response.\n     */\n    response?: Response;\n\n    /**\n     * Arguments for executing the query.\n     *\n     * - `pathParams`: The path parameters for the query. (in front of the ? in the url)\n     * - `queryParams`: The query parameters for the query. (after the ? in the url)\n     * - `body`: The body for the query. Unavailable for GET, HEAD and OPTIONS requests.\n     * - `headers`: The headers for the query.\n     * - `variables`: The variables for the query. (graphql only)\n     */\n    args?: Arguments;\n  };\n\n  /**\n   * Object containing the query's entity store information.\n   */\n  entity?: QueryEntityConfig<Store, Data, Response, Arguments, Id>;\n};\n\nexport type RestQueryConfig<\n  Route extends RouteType<Arguments>,\n  Response,\n  Arguments extends BaseArguments | undefined,\n  Store extends EntityStore<unknown>,\n  Data,\n  Id,\n> = QueryConfigBase<Response, Arguments, Store, Data, Id> & {\n  /**\n   * The api route to use for the query.\n   */\n  route: Route;\n};\n\nexport type GqlTransferOption = 'GET' | 'POST';\n\nexport interface GqlQueryConfig<\n  Route extends RouteType<Arguments> | undefined,\n  Response,\n  Arguments extends BaseArguments | undefined,\n  Store extends EntityStore<unknown>,\n  Data,\n  Id,\n> extends QueryConfigBase<Response, Arguments, Store, Data, Id> {\n  /**\n   * The graphql query to use for the query.\n   */\n  query: string;\n\n  /**\n   * Determines if the query should be sent via GET or POST.\n   * - `GET`: The query will be sent via query parameters.\n   * - `POST`: The query will be sent via the body.\n   * @default 'POST'\n   */\n  transferVia?: GqlTransferOption;\n\n  /**\n   * Subroute to use for the query.\n   */\n  route?: Route;\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type AnyRestQueryConfig = RestQueryConfig<any, any, any, any, any, any>;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type AnyGqlQueryConfig = GqlQueryConfig<any, any, any, any, any, any>;\n\nexport type QueryConfigWithoutMethod<\n  Route extends RouteType<Arguments>,\n  Response,\n  Arguments extends BaseArguments | undefined,\n  Store extends EntityStore<unknown>,\n  Data,\n  Id,\n> = Omit<RestQueryConfig<Route, Response, Arguments, Store, Data, Id>, 'method'>;\n\nexport type GqlQueryConfigWithoutMethod<\n  Route extends RouteType<Arguments>,\n  Response,\n  Arguments extends BaseArguments | undefined,\n  Store extends EntityStore<unknown>,\n  Data,\n  Id,\n> = Omit<GqlQueryConfig<Route, Response, Arguments, Store, Data, Id>, 'method'>;\n\nexport type BaseArguments = WithHeaders &\n  WithVariables &\n  WithBody &\n  WithQueryParams &\n  WithPathParams &\n  WithMock<unknown>;\n\nexport interface WithHeaders {\n  /**\n   * The headers to send with the query.\n   */\n  headers?: Record<string, string>;\n}\n\nexport interface QueryMockConfig<MockResponse> {\n  /**\n   * The mock response to use for the query.\n   */\n  response?: MockResponse;\n\n  /**\n   * The mock error to use for the query.\n   */\n  error?: RequestError;\n\n  /**\n   * The delay in milliseconds to wait before resolving the mock.\n   * If progress is enabled, the delay will be used for each progress event.\n   * @default 200\n   */\n  delay?: number;\n\n  /**\n   * Whether to report progress for the mock.\n   * For testing e.g. file uploads.\n   */\n  progress?: {\n    /**\n     * The number of progress events to report.\n     * @default 5\n     */\n    eventCount?: number;\n\n    /**\n     * The type of progress event to report.\n     * @default 'upload'\n     */\n    eventType?: 'download' | 'upload';\n\n    /**\n     * The total size of the file to report progress for in bytes.\n     * @default 1_000_000 (1MB)\n     */\n    fileSize?: number;\n\n    /**\n     * If true, the total size of the file will be omitted from the progress event.\n     * Useful for testing e.g. download progress when the server does not provide a total size.\n     */\n    omitTotal?: boolean;\n\n    /**\n     * If true, the partial text will be omitted from the progress event.\n     * Useful for testing e.g. download progress when the server does not provide a partial text.\n     */\n    omitPartialText?: boolean;\n  };\n\n  /**\n   * This will mock the request failing and getting retried 3 times. After, the request will succeed with the provided response.\n   * Can not be used with `progress` enabled.\n   * @default false\n   */\n  retryIntoResponse?: boolean;\n}\n\nexport interface WithMock<MockResponse> {\n  mock?: QueryMockConfig<MockResponse>;\n}\n\nexport interface QueryConfig {\n  /**\n   * Whether this query should be added to the internal query store.\n   *\n   * Generally this should be left on `false` unless you know what you are doing.\n   * @default false\n   */\n  skipQueryStore?: boolean;\n\n  /**\n   * The cache key to use for this query.\n   * Useful for queries that are equal but should be stored separately.\n   * Will be generated automatically if not provided.\n   *\n   * Generally this should be left on `undefined` unless you know what you are doing.\n   */\n  queryStoreCacheKey?: string;\n}\n\nexport interface WithConfig {\n  /**\n   * Additional configuration for this query.\n   */\n  config?: QueryConfig;\n}\n\nexport interface WithVariables {\n  /**\n   * The variables for the query. (graphql only)\n   */\n  variables?: Record<string, unknown>;\n}\n\nexport interface WithBody {\n  /**\n   * The body for the query. Unavailable for GET, HEAD and OPTIONS requests.\n   */\n  body?: unknown;\n}\n\nexport interface WithQueryParams {\n  /**\n   * The query parameters for the query. (after the ? in the url)\n   */\n  queryParams?: QueryParams;\n}\n\nexport interface WithPathParams {\n  /**\n   * The path parameters for the query. (in front of the ? in the url)\n   */\n  pathParams?: PathParams;\n}\n\nexport type QueryTrigger = 'program' | 'poll' | 'auto';\n\n// eslint-disable-next-line @typescript-eslint/no-empty-object-type\nexport type EmptyObject = {};\n\nexport interface ExecuteQueryOptions {\n  /**\n   * Whether to skip the cache for this query. This will force the query to be executed. It might still be caught by the native browser cache.\n   * @default false\n   */\n  skipCache?: boolean;\n\n  /**\n   * Whether to cancel the previous request if it is still loading.\n   * @default false\n   */\n  cancelPrevious?: boolean;\n\n  /**\n   * The trigger type for this query.\n   * - `program`: The query was triggered by the user.\n   * - `poll`: The query was triggered by polling.\n   * - `auto`: The query was triggered by an auto refresh event.\n   * @default 'program'\n   * @internal\n   */\n  _triggeredVia?: QueryTrigger;\n\n  /**\n   * Whether this is a retry of an unauthorized request.\n   * @internal\n   */\n  _isUnauthorizedRetry?: boolean;\n}\n\nexport type RouteType<Arguments extends BaseArguments | undefined> = Arguments extends {\n  pathParams: infer PathParams;\n}\n  ? (p: PathParams) => RouteString\n  : RouteString;\n\nexport type RouteString = `/${string}`;\n\nexport type AnyRoute = ((p: PathParams) => string) | RouteString;\n\nexport interface PollConfig {\n  /**\n   * The interval in milliseconds to poll the query.\n   */\n  interval: number;\n\n  /**\n   * A observable that will stop the polling when it emits.\n   */\n  takeUntil: Observable<unknown>;\n\n  /**\n   * Whether to trigger the query immediately after polling starts.\n   */\n  triggerImmediately?: boolean;\n}\n\nexport const enum QueryStateType {\n  Prepared = 'PREPARED',\n  Loading = 'LOADING',\n  Success = 'SUCCESS',\n  Failure = 'FAILURE',\n  Cancelled = 'CANCELLED',\n}\n\nexport interface Prepared {\n  type: QueryStateType.Prepared;\n  meta: QueryStateMeta;\n}\n\nexport interface Success<Response = unknown> {\n  type: QueryStateType.Success;\n  response: Response;\n  headers: RequestHeaders;\n  meta: QueryStateSuccessMeta;\n}\n\nexport interface Failure {\n  type: QueryStateType.Failure;\n  error: RequestError;\n  meta: QueryStateMeta;\n}\n\nexport interface Loading {\n  type: QueryStateType.Loading;\n  meta: QueryStateMeta;\n  partialText?: string;\n  progress?: RequestProgress;\n}\n\nexport interface Cancelled {\n  type: QueryStateType.Cancelled;\n  meta: QueryStateMeta;\n}\n\nexport interface QueryStateMeta {\n  id: number;\n  triggeredVia: QueryTrigger;\n  isWaitingForRetry?: boolean;\n  retryNumber?: number;\n  retryDelay?: number;\n}\n\nexport interface QueryStateSuccessMeta extends QueryStateMeta {\n  expiresAt?: number;\n}\n\nexport type QueryState<Response = unknown> = Loading | Success<Response> | Failure | Cancelled | Prepared;\n\nexport type QueryStateResponseOf<T extends QueryState = QueryState> =\n  T extends Success<infer Response> ? Response : never;\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type AnyQuery = Query<any, any, any, any, any, any>;\n\nexport type AnyQueryCreatorCollection = { [name: string]: AnyQueryCreator };\n\nexport type QueryCollectionOf<T extends { [name: string]: AnyQueryCreator }> = {\n  [K in keyof T]: { type: K; query: ConstructQuery<T[K]> };\n}[keyof T];\n\nexport type AnyQueryCollection = QueryCollectionOf<AnyQueryCreatorCollection>;\n\nexport type QueryOf<T extends AnyQueryCollection | AnyQuery | null> = T extends AnyQuery\n  ? T\n  : T extends AnyQueryCollection\n    ? T['query']\n    : never;\n\nexport type AnyQueryCollectionResponse<T extends AnyQueryCollection> = QueryResponseOf<T['query']>;\nexport type AnyQueryCollectionData<T extends AnyQueryCollection> = QueryDataOf<T['query']>;\n\nexport type QueryCollectionKeysOf<T extends AnyQueryCollection | AnyQuery | null> = T extends AnyQueryCollection\n  ? T['type']\n  : never;\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport interface ResetPageOnErrorOperatorConfig<J extends QueryForm<any>> {\n  /**\n   * The query form to reset the page of.\n   */\n  queryForm: J;\n\n  /**\n   * The key of the page control in the query form.\n   * @default 'page'\n   */\n  pageControlKey?: string;\n}\n"]}