@ethlete/query 5.17.0 → 5.18.0

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

@@ -0,0 +1,126 @@
+/* eslint-disable @typescript-eslint/no-empty-function */
+import { computed, DestroyRef, effect, inject, untracked } from '@angular/core';
+import { withAutoRefreshUsedOnUnsupportedHttpMethod, withPollingUsedOnUnsupportedHttpMethod } from './query-errors';
+import { QUERY_ARGS_RESET, QUERY_EFFECT_ERROR_MESSAGE, queryEffect, } from './query-utils';
+const createQueryFeature = (config) => {
+    return config;
+};
+export 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(currArgsNow);
+                });
+            }, QUERY_EFFECT_ERROR_MESSAGE);
+        },
+    });
+};
+export 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);
+            inject(DestroyRef).onDestroy(() => intervalId !== null && clearInterval(intervalId));
+        },
+    });
+};
+export 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);
+                });
+            });
+        },
+    });
+};
+export 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);
+                });
+            });
+        },
+    });
+};
+export 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);
+                });
+            });
+        },
+    });
+};
+export 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);
+        },
+    });
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query-features.js","sourceRoot":"","sources":["../../../../../../libs/query/src/lib/experimental/query-features.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-empty-function */\n\nimport { HttpErrorResponse, HttpEvent } from '@angular/common/http';\nimport { computed, DestroyRef, effect, inject, Signal, untracked } from '@angular/core';\nimport { QueryArgs, RequestArgs, ResponseType } from './query';\nimport { CreateQueryCreatorOptions, InternalCreateQueryCreatorOptions, QueryConfig } from './query-creator';\nimport { withAutoRefreshUsedOnUnsupportedHttpMethod, withPollingUsedOnUnsupportedHttpMethod } from './query-errors';\nimport { QueryState } from './query-state';\nimport {\n  QUERY_ARGS_RESET,\n  QUERY_EFFECT_ERROR_MESSAGE,\n  QueryArgsReset,\n  queryEffect,\n  QueryFeatureFlags,\n} from './query-utils';\n\nexport const enum QueryFeatureType {\n  WithArgs = 'withArgs',\n  WithLogging = 'withLogging',\n  WithErrorHandling = 'withErrorHandling',\n  WithSuccessHandling = 'withSuccessHandling',\n  WithPolling = 'withPolling',\n  WithAutoRefresh = 'withAutoRefresh',\n}\n\nexport type QueryFeatureContext<TArgs extends QueryArgs> = {\n  state: QueryState<TArgs>;\n  queryConfig: QueryConfig;\n  creatorConfig: CreateQueryCreatorOptions<TArgs>;\n  creatorInternals: InternalCreateQueryCreatorOptions;\n  execute: (args: RequestArgs<TArgs>) => void;\n\n  flags: QueryFeatureFlags;\n};\n\nexport type QueryFeatureFn<TArgs extends QueryArgs> = (context: QueryFeatureContext<TArgs>) => void;\n\nexport type QueryFeature<TArgs extends QueryArgs> = {\n  type: QueryFeatureType;\n  fn: (context: QueryFeatureContext<TArgs>) => void;\n};\n\nconst createQueryFeature = <TArgs extends QueryArgs>(config: { type: QueryFeatureType; fn: QueryFeatureFn<TArgs> }) => {\n  return config as QueryFeature<TArgs>;\n};\n\nexport const withArgs = <TArgs extends QueryArgs>(args: () => NoInfer<RequestArgs<TArgs>> | QueryArgsReset | null) => {\n  return createQueryFeature<TArgs>({\n    type: QueryFeatureType.WithArgs,\n    fn: (context) => {\n      const currArgs = computed(() => args());\n\n      queryEffect(() => {\n        const currArgsNow = currArgs();\n\n        if (currArgsNow === null) return;\n\n        untracked(() => {\n          if (currArgsNow === QUERY_ARGS_RESET) {\n            context.state.args.set(null);\n            return;\n          }\n\n          context.state.args.set(currArgsNow);\n\n          if (context.flags.shouldAutoExecute) context.execute(currArgsNow);\n        });\n      }, QUERY_EFFECT_ERROR_MESSAGE);\n    },\n  });\n};\n\nexport const withPolling = <TArgs extends QueryArgs>(options: { interval: number; executeInitially?: boolean }) => {\n  return createQueryFeature<TArgs>({\n    type: QueryFeatureType.WithPolling,\n    fn: (context) => {\n      if (!context.flags.shouldAutoExecuteMethod) {\n        throw withPollingUsedOnUnsupportedHttpMethod(context.creatorInternals.method);\n      }\n\n      let intervalId: number | null = null;\n\n      queryEffect(() => {\n        const args = context.state.args();\n\n        untracked(() => {\n          if (intervalId !== null) clearInterval(intervalId);\n\n          if (args === null) return;\n\n          if (options.executeInitially) {\n            context.execute(args);\n          }\n\n          intervalId = window.setInterval(() => {\n            context.execute(args);\n          }, options.interval);\n        });\n      }, QUERY_EFFECT_ERROR_MESSAGE);\n\n      inject(DestroyRef).onDestroy(() => intervalId !== null && clearInterval(intervalId));\n    },\n  });\n};\n\nexport const withLogging = <TArgs extends QueryArgs>(options: {\n  logFn: (v: HttpEvent<ResponseType<TArgs>> | null) => void;\n}) => {\n  return createQueryFeature<TArgs>({\n    type: QueryFeatureType.WithLogging,\n    fn: (context) => {\n      effect(() => {\n        const event = context.state.latestHttpEvent();\n\n        if (event === null) return;\n\n        untracked(() => {\n          options.logFn(event);\n        });\n      });\n    },\n  });\n};\n\nexport const withErrorHandling = <TArgs extends QueryArgs>(options: { handler: (e: HttpErrorResponse) => void }) => {\n  return createQueryFeature<TArgs>({\n    type: QueryFeatureType.WithErrorHandling,\n    fn: (context) => {\n      effect(() => {\n        const error = context.state.error();\n\n        if (error === null) return;\n\n        untracked(() => {\n          options.handler(error);\n        });\n      });\n    },\n  });\n};\n\nexport const withSuccessHandling = <TArgs extends QueryArgs>(options: {\n  handler: (data: NonNullable<ResponseType<TArgs>>) => void;\n}) => {\n  return createQueryFeature<TArgs>({\n    type: QueryFeatureType.WithSuccessHandling,\n    fn: (context) => {\n      effect(() => {\n        const response = context.state.response();\n\n        if (response === null) return;\n\n        untracked(() => {\n          options.handler(response as NonNullable<ResponseType<TArgs>>);\n        });\n      });\n    },\n  });\n};\n\nexport const withAutoRefresh = <TArgs extends QueryArgs>(options: {\n  signalChanges: Signal<unknown>[];\n  ignoreOnlyManualExecution?: boolean;\n}) => {\n  return createQueryFeature<TArgs>({\n    type: QueryFeatureType.WithAutoRefresh,\n    fn: (context) => {\n      if (!context.flags.shouldAutoExecuteMethod) {\n        throw withAutoRefreshUsedOnUnsupportedHttpMethod(context.creatorInternals.method);\n      }\n\n      if (context.queryConfig.onlyManualExecution && !options.ignoreOnlyManualExecution) {\n        throw withAutoRefreshUsedOnUnsupportedHttpMethod(context.creatorInternals.method);\n      }\n\n      queryEffect(() => {\n        for (const signal of options.signalChanges) {\n          signal();\n        }\n\n        untracked(() => {\n          const args = context.state.args();\n\n          if (args === null) return;\n\n          context.execute(args);\n        });\n      }, QUERY_EFFECT_ERROR_MESSAGE);\n    },\n  });\n};\n"]}

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

@@ -0,0 +1,91 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-empty-function */
+import { HttpClient } from '@angular/common/http';
+import { inject } from '@angular/core';
+import { buildQueryCacheKey, shouldCacheQuery } from '../query-client';
+import { buildRoute } from '../request';
+import { createHttpRequest } from './http-request';
+export const createQueryRepository = (config) => {
+    const httpClient = inject(HttpClient);
+    const cache = new Map();
+    const request = (options) => {
+        const shouldCache = shouldCacheQuery(options.method);
+        const route = buildRoute({
+            base: config.baseUrl,
+            route: options.route,
+            pathParams: options.pathParams,
+            queryParams: options.queryParams,
+            queryParamConfig: config.queryString,
+        });
+        const key = shouldCache &&
+            buildQueryCacheKey(`${options.key ? options.key + '_' : ''}${route}`, {
+                body: options.body,
+                queryParams: options.queryParams,
+                pathParams: options.pathParams,
+                // TODO: remaining props
+            });
+        if (shouldCache && key) {
+            const cacheEntry = cache.get(key);
+            if (cacheEntry) {
+                bind(key, options.destroyRef, cacheEntry.request);
+                if (!options.skipExecution)
+                    cacheEntry.request.execute();
+                return { key, request: cacheEntry.request };
+            }
+        }
+        const request = createHttpRequest({
+            fullPath: route,
+            body: options.body,
+            reportProgress: options.reportProgress,
+            withCredentials: options.withCredentials,
+            transferCache: options.transferCache,
+            responseType: options.responseType || 'json',
+            method: options.method,
+            headers: options.headers,
+            httpClient,
+            cacheAdapter: config.cacheAdapter,
+            retryFn: config.retryFn,
+        });
+        if (!options.skipExecution)
+            request.execute();
+        if (shouldCache && key) {
+            bind(key, options.destroyRef, request);
+        }
+        return { key, request };
+    };
+    const unbind = (key, destroyRef) => {
+        if (!key)
+            return;
+        const cacheEntry = cache.get(key);
+        if (!cacheEntry)
+            return;
+        cacheEntry.consumers.delete(destroyRef);
+        if (cacheEntry.consumers.size === 0) {
+            cacheEntry.request.destroy();
+            cache.delete(key);
+        }
+    };
+    const bind = (key, destroyRef, request) => {
+        if (!key)
+            return;
+        const destroyListener = destroyRef.onDestroy(() => unbind(key, destroyRef));
+        const cacheEntry = cache.get(key);
+        if (cacheEntry) {
+            cacheEntry.consumers.set(destroyRef, destroyListener);
+        }
+        else {
+            const consumers = new Map([]);
+            consumers.set(destroyRef, destroyListener);
+            cache.set(key, {
+                consumers,
+                request,
+            });
+        }
+    };
+    const repository = {
+        request,
+        unbind,
+    };
+    return repository;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query-repository.js","sourceRoot":"","sources":["../../../../../../libs/query/src/lib/experimental/query-repository.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable @typescript-eslint/no-empty-function */\n\nimport { HttpClient, HttpHeaders } from '@angular/common/http';\nimport { DestroyRef, inject } from '@angular/core';\nimport { buildQueryCacheKey, shouldCacheQuery } from '../query-client';\nimport { buildRoute } from '../request';\nimport { HttpRequest, createHttpRequest } from './http-request';\nimport { BodyType, PathParamsType, QueryArgs, QueryParamsType } from './query';\nimport { QueryClientConfig } from './query-client-config';\nimport { QueryMethod, RouteType } from './query-creator';\n\nexport type QueryRepositoryRequestOptions<TArgs extends QueryArgs> = {\n  method: QueryMethod;\n  route: RouteType<TArgs>;\n  pathParams?: PathParamsType<TArgs>;\n  queryParams?: QueryParamsType<TArgs>;\n  body?: BodyType<TArgs>;\n  headers?: HttpHeaders;\n  reportProgress?: boolean;\n  withCredentials?: boolean;\n  transferCache?: boolean | { includeHeaders?: string[] };\n  responseType?: 'json';\n  key?: string;\n\n  skipExecution?: boolean;\n\n  destroyRef: DestroyRef;\n};\n\nexport type QueryRepository = {\n  request: <TArgs extends QueryArgs>(\n    options: QueryRepositoryRequestOptions<TArgs>,\n  ) => { key: string | false; request: HttpRequest<TArgs> };\n  unbind: (key: string | false, destroyRef: DestroyRef) => void;\n};\n\nexport const createQueryRepository = (config: QueryClientConfig): QueryRepository => {\n  const httpClient = inject(HttpClient);\n\n  const cache = new Map<\n    string,\n    {\n      consumers: Map<DestroyRef, () => void>;\n      request: HttpRequest<QueryArgs>;\n    }\n  >();\n\n  const request = <TArgs extends QueryArgs>(options: QueryRepositoryRequestOptions<TArgs>) => {\n    const shouldCache = shouldCacheQuery(options.method);\n\n    const route = buildRoute({\n      base: config.baseUrl,\n      route: options.route,\n      pathParams: options.pathParams,\n      queryParams: options.queryParams,\n      queryParamConfig: config.queryString,\n    });\n\n    const key =\n      shouldCache &&\n      buildQueryCacheKey(`${options.key ? options.key + '_' : ''}${route}`, {\n        body: options.body,\n        queryParams: options.queryParams,\n        pathParams: options.pathParams,\n        // TODO: remaining props\n      });\n\n    if (shouldCache && key) {\n      const cacheEntry = cache.get(key);\n\n      if (cacheEntry) {\n        bind(key, options.destroyRef, cacheEntry.request);\n\n        if (!options.skipExecution) cacheEntry.request.execute();\n\n        return { key, request: cacheEntry.request as HttpRequest<TArgs> };\n      }\n    }\n\n    const request = createHttpRequest<TArgs>({\n      fullPath: route,\n      body: options.body,\n      reportProgress: options.reportProgress,\n      withCredentials: options.withCredentials,\n      transferCache: options.transferCache,\n      responseType: options.responseType || 'json',\n      method: options.method,\n      headers: options.headers,\n      httpClient,\n      cacheAdapter: config.cacheAdapter,\n      retryFn: config.retryFn,\n    });\n\n    if (!options.skipExecution) request.execute();\n\n    if (shouldCache && key) {\n      bind(key, options.destroyRef, request);\n    }\n\n    return { key, request };\n  };\n\n  const unbind = (key: string | false, destroyRef: DestroyRef) => {\n    if (!key) return;\n\n    const cacheEntry = cache.get(key);\n\n    if (!cacheEntry) return;\n\n    cacheEntry.consumers.delete(destroyRef);\n\n    if (cacheEntry.consumers.size === 0) {\n      cacheEntry.request.destroy();\n      cache.delete(key);\n    }\n  };\n\n  const bind = (key: string | false, destroyRef: DestroyRef, request: HttpRequest<QueryArgs>) => {\n    if (!key) return;\n\n    const destroyListener = destroyRef.onDestroy(() => unbind(key, destroyRef));\n\n    const cacheEntry = cache.get(key);\n\n    if (cacheEntry) {\n      cacheEntry.consumers.set(destroyRef, destroyListener);\n    } else {\n      const consumers: Map<DestroyRef, () => void> = new Map([]);\n\n      consumers.set(destroyRef, destroyListener);\n\n      cache.set(key, {\n        consumers,\n        request,\n      });\n    }\n  };\n\n  const repository: QueryRepository = {\n    request,\n    unbind,\n  };\n\n  return repository;\n};\n"]}

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

@@ -0,0 +1,44 @@
+import { effect, signal, untracked } from '@angular/core';
+import { setupQueryState } from './query-state';
+export const createQuerySnapshotFn = (options) => {
+    const { state, deps } = options;
+    const snapshotFn = () => {
+        const snapshotState = setupQueryState({});
+        const isAlive = signal(true);
+        const killEffectRef = effect(() => {
+            const currentLoading = state.loading();
+            const currentError = state.error();
+            const currentResponse = state.response();
+            const currentArgs = state.args();
+            const currentLatestHttpEvent = state.latestHttpEvent();
+            const currentLastTimeExecutedAt = state.lastTimeExecutedAt();
+            untracked(() => {
+                snapshotState.args.set(currentArgs);
+                snapshotState.error.set(currentError);
+                snapshotState.lastTimeExecutedAt.set(currentLastTimeExecutedAt);
+                snapshotState.latestHttpEvent.set(currentLatestHttpEvent);
+                snapshotState.loading.set(currentLoading);
+                snapshotState.response.set(currentResponse);
+                if (currentLoading)
+                    return;
+                if (!currentResponse && !currentError)
+                    return;
+                // kill the effect once loading is done and we either have a response or an error
+                killEffectRef.destroy();
+                isAlive.set(false);
+            });
+        }, { injector: deps.injector });
+        const snapshot = {
+            args: snapshotState.args.asReadonly(),
+            response: snapshotState.response.asReadonly(),
+            latestHttpEvent: snapshotState.latestHttpEvent.asReadonly(),
+            loading: snapshotState.loading.asReadonly(),
+            error: snapshotState.error.asReadonly(),
+            lastTimeExecutedAt: snapshotState.lastTimeExecutedAt.asReadonly(),
+            isAlive: isAlive.asReadonly(),
+        };
+        return snapshot;
+    };
+    return snapshotFn;
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,20 @@
+/* eslint-disable @typescript-eslint/no-empty-function */
+import { signal } from '@angular/core';
+export const setupQueryState = (options) => {
+    const response = signal(null);
+    const args = signal(null);
+    const latestHttpEvent = signal(null);
+    const error = signal(null);
+    const loading = signal(null);
+    const lastTimeExecutedAt = signal(null);
+    const state = {
+        response,
+        args,
+        latestHttpEvent,
+        loading,
+        error,
+        lastTimeExecutedAt,
+    };
+    return state;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicXVlcnktc3RhdGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL3F1ZXJ5L3NyYy9saWIvZXhwZXJpbWVudGFsL3F1ZXJ5LXN0YXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLHlEQUF5RDtBQUd6RCxPQUFPLEVBQWtCLE1BQU0sRUFBRSxNQUFNLGVBQWUsQ0FBQztBQWdCdkQsTUFBTSxDQUFDLE1BQU0sZUFBZSxHQUFHLENBQTBCLE9BQStCLEVBQUUsRUFBRTtJQUMxRixNQUFNLFFBQVEsR0FBRyxNQUFNLENBQTZCLElBQUksQ0FBQyxDQUFDO0lBQzFELE1BQU0sSUFBSSxHQUFHLE1BQU0sQ0FBNEIsSUFBSSxDQUFDLENBQUM7SUFDckQsTUFBTSxlQUFlLEdBQUcsTUFBTSxDQUF3QyxJQUFJLENBQUMsQ0FBQztJQUM1RSxNQUFNLEtBQUssR0FBRyxNQUFNLENBQTJCLElBQUksQ0FBQyxDQUFDO0lBQ3JELE1BQU0sT0FBTyxHQUFHLE1BQU0sQ0FBaUMsSUFBSSxDQUFDLENBQUM7SUFDN0QsTUFBTSxrQkFBa0IsR0FBRyxNQUFNLENBQWdCLElBQUksQ0FBQyxDQUFDO0lBRXZELE1BQU0sS0FBSyxHQUFzQjtRQUMvQixRQUFRO1FBQ1IsSUFBSTtRQUNKLGVBQWU7UUFDZixPQUFPO1FBQ1AsS0FBSztRQUNMLGtCQUFrQjtLQUNuQixDQUFDO0lBRUYsT0FBTyxLQUFLLENBQUM7QUFDZixDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiBlc2xpbnQtZGlzYWJsZSBAdHlwZXNjcmlwdC1lc2xpbnQvbm8tZW1wdHktZnVuY3Rpb24gKi9cblxuaW1wb3J0IHsgSHR0cEVycm9yUmVzcG9uc2UsIEh0dHBFdmVudCB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbi9odHRwJztcbmltcG9ydCB7IFdyaXRhYmxlU2lnbmFsLCBzaWduYWwgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IEh0dHBSZXF1ZXN0TG9hZGluZ1N0YXRlIH0gZnJvbSAnLi9odHRwLXJlcXVlc3QnO1xuaW1wb3J0IHsgUXVlcnlBcmdzLCBSZXF1ZXN0QXJncywgUmVzcG9uc2VUeXBlIH0gZnJvbSAnLi9xdWVyeSc7XG5cbi8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBAdHlwZXNjcmlwdC1lc2xpbnQvbm8tZW1wdHktb2JqZWN0LXR5cGVcbmV4cG9ydCB0eXBlIFNldHVwUXVlcnlTdGF0ZU9wdGlvbnMgPSB7fTtcblxuZXhwb3J0IHR5cGUgUXVlcnlTdGF0ZTxUQXJncyBleHRlbmRzIFF1ZXJ5QXJncz4gPSB7XG4gIHJlc3BvbnNlOiBXcml0YWJsZVNpZ25hbDxSZXNwb25zZVR5cGU8VEFyZ3M+IHwgbnVsbD47XG4gIGFyZ3M6IFdyaXRhYmxlU2lnbmFsPFJlcXVlc3RBcmdzPFRBcmdzPiB8IG51bGw+O1xuICBsYXRlc3RIdHRwRXZlbnQ6IFdyaXRhYmxlU2lnbmFsPEh0dHBFdmVudDxSZXNwb25zZVR5cGU8VEFyZ3M+PiB8IG51bGw+O1xuICBsb2FkaW5nOiBXcml0YWJsZVNpZ25hbDxIdHRwUmVxdWVzdExvYWRpbmdTdGF0ZSB8IG51bGw+O1xuICBlcnJvcjogV3JpdGFibGVTaWduYWw8SHR0cEVycm9yUmVzcG9uc2UgfCBudWxsPjtcbiAgbGFzdFRpbWVFeGVjdXRlZEF0OiBXcml0YWJsZVNpZ25hbDxudW1iZXIgfCBudWxsPjtcbn07XG5cbmV4cG9ydCBjb25zdCBzZXR1cFF1ZXJ5U3RhdGUgPSA8VEFyZ3MgZXh0ZW5kcyBRdWVyeUFyZ3M+KG9wdGlvbnM6IFNldHVwUXVlcnlTdGF0ZU9wdGlvbnMpID0+IHtcbiAgY29uc3QgcmVzcG9uc2UgPSBzaWduYWw8UmVzcG9uc2VUeXBlPFRBcmdzPiB8IG51bGw+KG51bGwpO1xuICBjb25zdCBhcmdzID0gc2lnbmFsPFJlcXVlc3RBcmdzPFRBcmdzPiB8IG51bGw+KG51bGwpO1xuICBjb25zdCBsYXRlc3RIdHRwRXZlbnQgPSBzaWduYWw8SHR0cEV2ZW50PFJlc3BvbnNlVHlwZTxUQXJncz4+IHwgbnVsbD4obnVsbCk7XG4gIGNvbnN0IGVycm9yID0gc2lnbmFsPEh0dHBFcnJvclJlc3BvbnNlIHwgbnVsbD4obnVsbCk7XG4gIGNvbnN0IGxvYWRpbmcgPSBzaWduYWw8SHR0cFJlcXVlc3RMb2FkaW5nU3RhdGUgfCBudWxsPihudWxsKTtcbiAgY29uc3QgbGFzdFRpbWVFeGVjdXRlZEF0ID0gc2lnbmFsPG51bWJlciB8IG51bGw+KG51bGwpO1xuXG4gIGNvbnN0IHN0YXRlOiBRdWVyeVN0YXRlPFRBcmdzPiA9IHtcbiAgICByZXNwb25zZSxcbiAgICBhcmdzLFxuICAgIGxhdGVzdEh0dHBFdmVudCxcbiAgICBsb2FkaW5nLFxuICAgIGVycm9yLFxuICAgIGxhc3RUaW1lRXhlY3V0ZWRBdCxcbiAgfTtcblxuICByZXR1cm4gc3RhdGU7XG59O1xuIl19

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

@@ -0,0 +1,148 @@
+/* eslint-disable @typescript-eslint/no-empty-function */
+import { HttpErrorResponse, HttpStatusCode } from '@angular/common/http';
+import { effect, isDevMode } from '@angular/core';
+import { isSymfonyPagerfantaOutOfRangeError } from '../symfony';
+import { queryFeatureUsedMultipleTimes, withArgsQueryFeatureMissingButRouteIsFunction } from './query-errors';
+/**
+ * Returning this inside e.g. a withComputedArgs feature will reset the query args to null.
+ * This will also pause polling and auto refresh until new args are set.
+ */
+export const QUERY_ARGS_RESET = Symbol('QUERY_ARGS_RESET');
+export const QUERY_EFFECT_ERROR_MESSAGE = 'Effect triggered too often. This is probably due to a circular dependency inside the query.';
+/** A angular effect that will throw an error in dev mode if it is called too often. This indicates a circular dependency inside the effect. */
+export const queryEffect = (fn, errorMessage, options) => {
+    let lastTriggerTs = 0;
+    let illegalWrites = 0;
+    effect(() => {
+        if (isDevMode()) {
+            const now = performance.now();
+            if (now - lastTriggerTs < 100) {
+                illegalWrites++;
+                if (illegalWrites > 5) {
+                    throw new Error(errorMessage);
+                }
+            }
+            lastTriggerTs = now;
+        }
+        fn();
+    }, options);
+};
+export const shouldAutoExecuteQuery = (method) => {
+    return method === 'GET' || method === 'HEAD' || method === 'OPTIONS';
+};
+export const extractExpiresInSeconds = (headers) => {
+    const cacheControl = headers.get('cache-control');
+    const age = headers.get('age');
+    const expires = headers.get('expires');
+    // In seconds
+    let expiresIn = null;
+    let maxAge = null;
+    if (cacheControl?.includes('no-cache')) {
+        return null;
+    }
+    if (cacheControl?.includes('max-age')) {
+        const m = cacheControl.split('max-age=')[1];
+        if (m) {
+            maxAge = parseInt(m);
+        }
+    }
+    else if (cacheControl?.includes('s-maxage')) {
+        const m = cacheControl.split('s-maxage=')[1];
+        if (m) {
+            maxAge = parseInt(m);
+        }
+    }
+    if (maxAge && age) {
+        const ageSeconds = parseInt(age);
+        expiresIn = maxAge - ageSeconds;
+    }
+    else if (maxAge) {
+        expiresIn = maxAge / 2; // We assume the response is half way to its expiration
+    }
+    else if (expires) {
+        // Used by some apis to tell the response will never expire
+        // In this case we let the response expire after 1 hour
+        if (expires === '-1') {
+            expiresIn = 3600;
+        }
+        else {
+            const expiresDate = new Date(expires);
+            // check if the date is valid
+            if (expiresDate.toString() !== 'Invalid Date') {
+                expiresIn = Math.floor((expiresDate.getTime() - Date.now()) / 1000);
+            }
+        }
+    }
+    return expiresIn;
+};
+export const shouldRetryRequest = (options) => {
+    const { retryCount, error } = options;
+    const defaultRetryDelay = 1000 + 1000 * retryCount;
+    if (retryCount > 3) {
+        return { retry: false };
+    }
+    if (!(error instanceof HttpErrorResponse)) {
+        return { retry: false };
+    }
+    const { status, error: detail, headers } = error;
+    // Retry on 5xx errors
+    if (status >= 500) {
+        // Don't retry if a requested page is out of range
+        if (isSymfonyPagerfantaOutOfRangeError(detail)) {
+            return { retry: false };
+        }
+        return { retry: true, delay: defaultRetryDelay };
+    }
+    // Retry on 408 or 425 errors
+    if (status === HttpStatusCode.RequestTimeout || status === HttpStatusCode.TooEarly) {
+        return { retry: true, delay: defaultRetryDelay };
+    }
+    // Retry on 429 errors
+    if (status === HttpStatusCode.TooManyRequests) {
+        const retryAfter = headers.get('retry-after') || headers.get('x-retry-after');
+        if (retryAfter) {
+            const delay = parseInt(retryAfter) * 1000;
+            return { retry: true, delay: Number.isNaN(delay) ? defaultRetryDelay : delay };
+        }
+        return { retry: true, delay: defaultRetryDelay };
+    }
+    // Code 0 usually means the internet connection is down. We retry in this case.
+    // It could also be a CORS issue but that should not be the case in production.
+    if (status === 0) {
+        return { retry: true, delay: defaultRetryDelay };
+    }
+    return { retry: false };
+};
+export const getQueryFeatureUsage = (options) => {
+    const { creator, creatorInternals, features, queryConfig } = options;
+    const hasWithArgsFeature = features.some((f) => f.type == "withArgs" /* QueryFeatureType.WithArgs */);
+    const shouldAutoExecuteMethod = shouldAutoExecuteQuery(creatorInternals.method);
+    const shouldAutoExecute = shouldAutoExecuteMethod && !queryConfig.onlyManualExecution;
+    const hasRouteFunction = typeof creator.route === 'function';
+    if (hasRouteFunction && !hasWithArgsFeature) {
+        throw withArgsQueryFeatureMissingButRouteIsFunction();
+    }
+    const featureFnContext = {
+        hasWithArgsFeature,
+        shouldAutoExecuteMethod,
+        shouldAutoExecute,
+        hasRouteFunction,
+    };
+    return featureFnContext;
+};
+export const applyQueryFeatures = (options, context) => {
+    const featureTypes = new Set();
+    for (const feature of options.features) {
+        if (featureTypes.has(feature.type)) {
+            throw queryFeatureUsedMultipleTimes(feature.type);
+        }
+        featureTypes.add(feature.type);
+        feature.fn(context);
+    }
+};
+export const maybeExecute = (options) => {
+    if (options.flags.shouldAutoExecute && !options.flags.hasRouteFunction && !options.flags.hasWithArgsFeature) {
+        options.execute();
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query-utils.js","sourceRoot":"","sources":["../../../../../../libs/query/src/lib/experimental/query-utils.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-empty-function */\n\nimport { HttpErrorResponse, HttpHeaders, HttpStatusCode } from '@angular/common/http';\nimport { CreateEffectOptions, effect, isDevMode } from '@angular/core';\nimport { isSymfonyPagerfantaOutOfRangeError } from '../symfony';\nimport { CreateQueryOptions, QueryArgs } from './query';\nimport { QueryMethod } from './query-creator';\nimport { queryFeatureUsedMultipleTimes, withArgsQueryFeatureMissingButRouteIsFunction } from './query-errors';\nimport { QueryExecute } from './query-execute';\nimport { QueryFeatureContext, QueryFeatureType } from './query-features';\n\n/**\n * Returning this inside e.g. a withComputedArgs feature will reset the query args to null.\n * This will also pause polling and auto refresh until new args are set.\n */\nexport const QUERY_ARGS_RESET = Symbol('QUERY_ARGS_RESET');\nexport type QueryArgsReset = typeof QUERY_ARGS_RESET;\n\nexport const QUERY_EFFECT_ERROR_MESSAGE =\n  'Effect triggered too often. This is probably due to a circular dependency inside the query.';\n\n/** A angular effect that will throw an error in dev mode if it is called too often. This indicates a circular dependency inside the effect. */\nexport const queryEffect = (fn: () => void, errorMessage: string, options?: CreateEffectOptions) => {\n  let lastTriggerTs = 0;\n  let illegalWrites = 0;\n\n  effect(() => {\n    if (isDevMode()) {\n      const now = performance.now();\n\n      if (now - lastTriggerTs < 100) {\n        illegalWrites++;\n\n        if (illegalWrites > 5) {\n          throw new Error(errorMessage);\n        }\n      }\n\n      lastTriggerTs = now;\n    }\n\n    fn();\n  }, options);\n};\n\nexport const shouldAutoExecuteQuery = (method: QueryMethod) => {\n  return method === 'GET' || method === 'HEAD' || method === 'OPTIONS';\n};\n\nexport const extractExpiresInSeconds = (headers: HttpHeaders) => {\n  const cacheControl = headers.get('cache-control');\n  const age = headers.get('age');\n  const expires = headers.get('expires');\n\n  // In seconds\n  let expiresIn: number | null = null;\n  let maxAge: number | null = null;\n\n  if (cacheControl?.includes('no-cache')) {\n    return null;\n  }\n\n  if (cacheControl?.includes('max-age')) {\n    const m = cacheControl.split('max-age=')[1];\n\n    if (m) {\n      maxAge = parseInt(m);\n    }\n  } else if (cacheControl?.includes('s-maxage')) {\n    const m = cacheControl.split('s-maxage=')[1];\n\n    if (m) {\n      maxAge = parseInt(m);\n    }\n  }\n\n  if (maxAge && age) {\n    const ageSeconds = parseInt(age);\n\n    expiresIn = maxAge - ageSeconds;\n  } else if (maxAge) {\n    expiresIn = maxAge / 2; // We assume the response is half way to its expiration\n  } else if (expires) {\n    // Used by some apis to tell the response will never expire\n    // In this case we let the response expire after 1 hour\n    if (expires === '-1') {\n      expiresIn = 3600;\n    } else {\n      const expiresDate = new Date(expires);\n\n      // check if the date is valid\n      if (expiresDate.toString() !== 'Invalid Date') {\n        expiresIn = Math.floor((expiresDate.getTime() - Date.now()) / 1000);\n      }\n    }\n  }\n\n  return expiresIn;\n};\n\nexport type ShouldRetryRequestOptions = {\n  retryCount: number;\n  error: HttpErrorResponse;\n};\n\nexport type ShouldRetryRequestResult =\n  | {\n      retry: false;\n    }\n  | {\n      retry: true;\n      delay: number;\n    };\n\nexport type ShouldRetryRequestFn = (options: ShouldRetryRequestOptions) => ShouldRetryRequestResult;\n\nexport const shouldRetryRequest = (options: ShouldRetryRequestOptions): ShouldRetryRequestResult => {\n  const { retryCount, error } = options;\n  const defaultRetryDelay = 1000 + 1000 * retryCount;\n\n  if (retryCount > 3) {\n    return { retry: false };\n  }\n\n  if (!(error instanceof HttpErrorResponse)) {\n    return { retry: false };\n  }\n\n  const { status, error: detail, headers } = error;\n\n  // Retry on 5xx errors\n  if (status >= 500) {\n    // Don't retry if a requested page is out of range\n    if (isSymfonyPagerfantaOutOfRangeError(detail)) {\n      return { retry: false };\n    }\n\n    return { retry: true, delay: defaultRetryDelay };\n  }\n\n  // Retry on 408 or 425 errors\n  if (status === HttpStatusCode.RequestTimeout || status === HttpStatusCode.TooEarly) {\n    return { retry: true, delay: defaultRetryDelay };\n  }\n\n  // Retry on 429 errors\n  if (status === HttpStatusCode.TooManyRequests) {\n    const retryAfter = headers.get('retry-after') || headers.get('x-retry-after');\n\n    if (retryAfter) {\n      const delay = parseInt(retryAfter) * 1000;\n      return { retry: true, delay: Number.isNaN(delay) ? defaultRetryDelay : delay };\n    }\n\n    return { retry: true, delay: defaultRetryDelay };\n  }\n\n  // Code 0 usually means the internet connection is down. We retry in this case.\n  // It could also be a CORS issue but that should not be the case in production.\n  if (status === 0) {\n    return { retry: true, delay: defaultRetryDelay };\n  }\n\n  return { retry: false };\n};\n\nexport type QueryFeatureFlags = {\n  hasWithArgsFeature: boolean;\n  shouldAutoExecuteMethod: boolean;\n  shouldAutoExecute: boolean;\n  hasRouteFunction: boolean;\n};\n\nexport const getQueryFeatureUsage = <TArgs extends QueryArgs>(options: CreateQueryOptions<TArgs>) => {\n  const { creator, creatorInternals, features, queryConfig } = options;\n\n  const hasWithArgsFeature = features.some((f) => f.type == QueryFeatureType.WithArgs);\n  const shouldAutoExecuteMethod = shouldAutoExecuteQuery(creatorInternals.method);\n  const shouldAutoExecute = shouldAutoExecuteMethod && !queryConfig.onlyManualExecution;\n  const hasRouteFunction = typeof creator.route === 'function';\n\n  if (hasRouteFunction && !hasWithArgsFeature) {\n    throw withArgsQueryFeatureMissingButRouteIsFunction();\n  }\n\n  const featureFnContext: QueryFeatureFlags = {\n    hasWithArgsFeature,\n    shouldAutoExecuteMethod,\n    shouldAutoExecute,\n    hasRouteFunction,\n  };\n\n  return featureFnContext;\n};\n\nexport const applyQueryFeatures = <TArgs extends QueryArgs>(\n  options: CreateQueryOptions<TArgs>,\n  context: QueryFeatureContext<TArgs>,\n) => {\n  const featureTypes = new Set<QueryFeatureType>();\n\n  for (const feature of options.features) {\n    if (featureTypes.has(feature.type)) {\n      throw queryFeatureUsedMultipleTimes(feature.type);\n    }\n\n    featureTypes.add(feature.type);\n    feature.fn(context);\n  }\n};\n\nexport const maybeExecute = <TArgs extends QueryArgs>(options: {\n  flags: QueryFeatureFlags;\n  execute: QueryExecute<TArgs>;\n}) => {\n  if (options.flags.shouldAutoExecute && !options.flags.hasRouteFunction && !options.flags.hasWithArgsFeature) {\n    options.execute();\n  }\n};\n"]}

package/esm2022/lib/experimental/query.mjs

@@ -0,0 +1,37 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-empty-function */
+import { setupQueryDependencies } from './query-dependencies';
+import { createExecuteFn } from './query-execute';
+import { createQuerySnapshotFn } from './query-snapshot';
+import { setupQueryState } from './query-state';
+import { applyQueryFeatures, getQueryFeatureUsage, maybeExecute } from './query-utils';
+export const createQuery = (options) => {
+    const deps = setupQueryDependencies({ clientConfig: options.creatorInternals.client });
+    const state = setupQueryState({});
+    const { creator, creatorInternals, queryConfig } = options;
+    const flags = getQueryFeatureUsage(options);
+    const execute = createExecuteFn({ 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,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

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

@@ -0,0 +1,15 @@
+import { splitQueryConfig, } from './query-creator';
+import { createSecureQuery } from './secure-query';
+export const createSecureQueryCreator = (options, internals) => {
+    function queryCreator(...args) {
+        const { features, queryConfig } = splitQueryConfig(args);
+        return createSecureQuery({
+            creator: options,
+            creatorInternals: internals,
+            features,
+            queryConfig,
+        });
+    }
+    return queryCreator;
+};
+//# sourceMappingURL=data:application/json;base64,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