@ethlete/query 5.17.0 → 5.19.0

package/esm2022/lib/experimental/http-request.mjs

@@ -0,0 +1,153 @@
+/* eslint-disable @typescript-eslint/no-empty-function */
+import { HttpErrorResponse, HttpEventType, } from '@angular/common/http';
+import { computed, signal } from '@angular/core';
+import { Subscription, catchError, retry, tap, throwError, timer } from 'rxjs';
+import { buildTimestampFromSeconds } from '../request';
+import { extractExpiresInSeconds, shouldRetryRequest, } from './query-utils';
+export const SPEED_BUFFER_TIME_IN_MS = 2000;
+export const createHttpRequest = (options) => {
+    let currentStreamSubscription = Subscription.EMPTY;
+    const currentEvent = signal(null);
+    const loading = signal(null);
+    const error = signal(null);
+    const response = signal(null);
+    const lastLoadEventTime = signal(0);
+    const lastLoadEventAmount = signal(0);
+    const lastExecuteTime = signal(0);
+    const expiresIn = signal(null);
+    const isStale = computed(() => {
+        const expiresInTs = expiresIn();
+        return expiresInTs === null || expiresInTs < Date.now();
+    });
+    const stream = options.httpClient
+        .request(options.method, options.fullPath, {
+        observe: 'events',
+        body: options.body,
+        reportProgress: options.reportProgress,
+        withCredentials: options.withCredentials,
+        transferCache: options.transferCache,
+        responseType: options.responseType || 'json',
+        context: options.context,
+        headers: options.headers,
+    })
+        .pipe(tap((event) => updateState(event)), retry({
+        delay: (error, retryCount) => {
+            const retryOptions = { error, retryCount };
+            const retryResult = options.retryFn?.(retryOptions) || shouldRetryRequest(retryOptions);
+            if (!retryResult.retry) {
+                return throwError(() => error);
+            }
+            return timer(retryResult.delay);
+        },
+    }), catchError((e) => {
+        updateErrorState(e);
+        return throwError(() => e);
+    }));
+    const execute = () => {
+        if (loading() || !isStale()) {
+            // Do not execute if there is already a request in progress or the request is not stale
+            return false;
+        }
+        currentStreamSubscription.unsubscribe();
+        lastExecuteTime.set(Date.now());
+        lastLoadEventTime.set(lastExecuteTime());
+        loading.set({
+            executeTime: lastExecuteTime(),
+            progress: null,
+        });
+        error.set(null);
+        expiresIn.set(null);
+        currentStreamSubscription = stream.subscribe();
+        return true;
+    };
+    const destroy = () => {
+        if (currentStreamSubscription.closed) {
+            return false;
+        }
+        currentStreamSubscription.unsubscribe();
+        return true;
+    };
+    const updateState = (event) => {
+        currentEvent.set(event);
+        switch (event.type) {
+            case HttpEventType.Response:
+                {
+                    loading.set(null);
+                    response.set(event.body);
+                    const expiresInSeconds = options.cacheAdapter
+                        ? options.cacheAdapter(event.headers)
+                        : extractExpiresInSeconds(event.headers);
+                    const expiresInTimestamp = buildTimestampFromSeconds(expiresInSeconds);
+                    expiresIn.set(expiresInTimestamp);
+                }
+                break;
+            case HttpEventType.UploadProgress:
+            case HttpEventType.DownloadProgress:
+                {
+                    updateLoadingState(event);
+                }
+                break;
+            case HttpEventType.Sent:
+            case HttpEventType.ResponseHeader:
+            case HttpEventType.User:
+                {
+                    // we don't care about these events
+                }
+                break;
+        }
+    };
+    const updateErrorState = (errorResponse) => {
+        let err = errorResponse instanceof HttpErrorResponse ? errorResponse : null;
+        if (!err) {
+            err = new HttpErrorResponse({
+                error: errorResponse,
+                status: 0,
+                statusText: 'Unknown Error',
+            });
+        }
+        error.set(err);
+        loading.set(null);
+        currentEvent.set({ type: 'error', error: err });
+    };
+    const updateLoadingState = (event) => {
+        if (event.total === undefined) {
+            return;
+        }
+        const progress = {
+            total: event.total,
+            loaded: event.loaded,
+            percentage: (event.loaded / event.total) * 100,
+            speed: null,
+            remainingTime: null,
+        };
+        const state = {
+            executeTime: lastExecuteTime(),
+            progress,
+        };
+        const currentTime = Date.now();
+        const elapsedTimeSinceLastEvent = currentTime - lastLoadEventTime();
+        const elapsedTimeSinceLastExecute = currentTime - lastExecuteTime();
+        const loadedAmount = event.loaded - lastLoadEventAmount();
+        // We only want to calculate speed and remaining time after 2 seconds of the execution
+        // This is to avoid showing incorrect speed and remaining time when the request is very fast
+        if (elapsedTimeSinceLastExecute > SPEED_BUFFER_TIME_IN_MS) {
+            const speed = (loadedAmount / elapsedTimeSinceLastEvent) * 1000;
+            progress.speed = speed * 1000;
+            progress.remainingTime = Math.round((event.total - event.loaded) / speed) * 1000;
+        }
+        lastLoadEventTime.set(currentTime);
+        lastLoadEventAmount.set(event.loaded);
+        loading.set(state);
+    };
+    const httpRequest = {
+        execute,
+        destroy,
+        loading: loading.asReadonly(),
+        error: error.asReadonly(),
+        response: response.asReadonly(),
+        currentEvent: currentEvent.asReadonly(),
+        isStale,
+    };
+    return httpRequest;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http-request.js","sourceRoot":"","sources":["../../../../../../libs/query/src/lib/experimental/http-request.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-empty-function */\n\nimport {\n  HttpClient,\n  HttpContext,\n  HttpErrorResponse,\n  HttpEvent,\n  HttpEventType,\n  HttpHeaders,\n  HttpProgressEvent,\n} from '@angular/common/http';\nimport { Signal, computed, signal } from '@angular/core';\nimport { Subscription, catchError, retry, tap, throwError, timer } from 'rxjs';\nimport { buildTimestampFromSeconds } from '../request';\nimport { BodyType, PathParamsType, QueryArgs, QueryParamsType, ResponseType } from './query';\nimport { CacheAdapterFn } from './query-client-config';\nimport { QueryMethod } from './query-creator';\nimport {\n  ShouldRetryRequestFn,\n  ShouldRetryRequestOptions,\n  extractExpiresInSeconds,\n  shouldRetryRequest,\n} from './query-utils';\n\nexport const SPEED_BUFFER_TIME_IN_MS = 2000;\n\nexport type CreateHttpRequestOptions<TArgs extends QueryArgs> = {\n  method: QueryMethod;\n  fullPath: string;\n  pathParams?: PathParamsType<TArgs>;\n  queryParams?: QueryParamsType<TArgs>;\n  body?: BodyType<TArgs>;\n  reportProgress?: boolean;\n  withCredentials?: boolean;\n  transferCache?: boolean | { includeHeaders?: string[] };\n  responseType?: 'json' | 'text' | 'blob' | 'arraybuffer';\n\n  context?: HttpContext;\n  headers?: HttpHeaders;\n\n  httpClient: HttpClient;\n\n  cacheAdapter?: CacheAdapterFn;\n  retryFn?: ShouldRetryRequestFn;\n};\n\nexport type HttpRequestLoadingState = {\n  executeTime: number;\n  progress: HttpRequestLoadingProgressState | null;\n};\n\nexport type HttpRequestLoadingProgressState = {\n  /** The total number of bytes to be transferred */\n  total: number;\n\n  /** The number of bytes transferred */\n  loaded: number;\n\n  /** The percentage of the transfer that is completed */\n  percentage: number;\n\n  /** The speed of the transfer in bytes per millisecond */\n  speed: number | null;\n\n  /** The estimated remaining time in milliseconds */\n  remainingTime: number | null;\n};\n\nexport type HttpRequest<TArgs extends QueryArgs> = {\n  execute: () => boolean;\n  destroy: () => boolean;\n  loading: Signal<HttpRequestLoadingState | null>;\n  error: Signal<HttpErrorResponse | null>;\n  response: Signal<ResponseType<TArgs> | null>;\n  currentEvent: Signal<HttpEvent<ResponseType<TArgs>> | HttpErrorEvent | null>;\n  isStale: Signal<boolean>;\n};\n\nexport type HttpErrorEvent = {\n  type: 'error';\n  error: HttpErrorResponse;\n};\n\nexport const createHttpRequest = <TArgs extends QueryArgs>(options: CreateHttpRequestOptions<TArgs>) => {\n  let currentStreamSubscription = Subscription.EMPTY;\n\n  const currentEvent = signal<HttpEvent<ResponseType<TArgs>> | HttpErrorEvent | null>(null);\n  const loading = signal<HttpRequestLoadingState | null>(null);\n  const error = signal<HttpErrorResponse | null>(null);\n  const response = signal<ResponseType<TArgs> | null>(null);\n\n  const lastLoadEventTime = signal(0);\n  const lastLoadEventAmount = signal(0);\n  const lastExecuteTime = signal(0);\n  const expiresIn = signal<number | null>(null);\n\n  const isStale = computed(() => {\n    const expiresInTs = expiresIn();\n\n    return expiresInTs === null || expiresInTs < Date.now();\n  });\n\n  const stream = options.httpClient\n    .request(options.method, options.fullPath, {\n      observe: 'events',\n      body: options.body,\n      reportProgress: options.reportProgress,\n      withCredentials: options.withCredentials,\n      transferCache: options.transferCache,\n      responseType: options.responseType || 'json',\n      context: options.context,\n      headers: options.headers,\n    })\n    .pipe(\n      tap((event) => updateState(event)),\n      retry({\n        delay: (error, retryCount) => {\n          const retryOptions: ShouldRetryRequestOptions = { error, retryCount };\n\n          const retryResult = options.retryFn?.(retryOptions) || shouldRetryRequest(retryOptions);\n\n          if (!retryResult.retry) {\n            return throwError(() => error);\n          }\n\n          return timer(retryResult.delay);\n        },\n      }),\n      catchError((e) => {\n        updateErrorState(e);\n\n        return throwError(() => e);\n      }),\n    );\n\n  const execute = () => {\n    if (loading() || !isStale()) {\n      // Do not execute if there is already a request in progress or the request is not stale\n      return false;\n    }\n\n    currentStreamSubscription.unsubscribe();\n\n    lastExecuteTime.set(Date.now());\n    lastLoadEventTime.set(lastExecuteTime());\n\n    loading.set({\n      executeTime: lastExecuteTime(),\n      progress: null,\n    });\n    error.set(null);\n    expiresIn.set(null);\n\n    currentStreamSubscription = stream.subscribe();\n\n    return true;\n  };\n\n  const destroy = () => {\n    if (currentStreamSubscription.closed) {\n      return false;\n    }\n\n    currentStreamSubscription.unsubscribe();\n\n    return true;\n  };\n\n  const updateState = (event: HttpEvent<ResponseType<TArgs>>) => {\n    currentEvent.set(event);\n\n    switch (event.type) {\n      case HttpEventType.Response:\n        {\n          loading.set(null);\n          response.set(event.body);\n\n          const expiresInSeconds = options.cacheAdapter\n            ? options.cacheAdapter(event.headers)\n            : extractExpiresInSeconds(event.headers);\n          const expiresInTimestamp = buildTimestampFromSeconds(expiresInSeconds);\n          expiresIn.set(expiresInTimestamp);\n        }\n        break;\n\n      case HttpEventType.UploadProgress:\n      case HttpEventType.DownloadProgress:\n        {\n          updateLoadingState(event);\n        }\n        break;\n\n      case HttpEventType.Sent:\n      case HttpEventType.ResponseHeader:\n      case HttpEventType.User:\n        {\n          // we don't care about these events\n        }\n        break;\n    }\n  };\n\n  const updateErrorState = (errorResponse: unknown) => {\n    let err = errorResponse instanceof HttpErrorResponse ? errorResponse : null;\n\n    if (!err) {\n      err = new HttpErrorResponse({\n        error: errorResponse,\n        status: 0,\n        statusText: 'Unknown Error',\n      });\n    }\n\n    error.set(err);\n    loading.set(null);\n    currentEvent.set({ type: 'error', error: err });\n  };\n\n  const updateLoadingState = (event: HttpProgressEvent) => {\n    if (event.total === undefined) {\n      return;\n    }\n\n    const progress: HttpRequestLoadingProgressState = {\n      total: event.total,\n      loaded: event.loaded,\n      percentage: (event.loaded / event.total) * 100,\n      speed: null,\n      remainingTime: null,\n    };\n\n    const state: HttpRequestLoadingState = {\n      executeTime: lastExecuteTime(),\n      progress,\n    };\n\n    const currentTime = Date.now();\n    const elapsedTimeSinceLastEvent = currentTime - lastLoadEventTime();\n    const elapsedTimeSinceLastExecute = currentTime - lastExecuteTime();\n    const loadedAmount = event.loaded - lastLoadEventAmount();\n\n    // We only want to calculate speed and remaining time after 2 seconds of the execution\n    // This is to avoid showing incorrect speed and remaining time when the request is very fast\n    if (elapsedTimeSinceLastExecute > SPEED_BUFFER_TIME_IN_MS) {\n      const speed = (loadedAmount / elapsedTimeSinceLastEvent) * 1000;\n\n      progress.speed = speed * 1000;\n      progress.remainingTime = Math.round((event.total - event.loaded) / speed) * 1000;\n    }\n\n    lastLoadEventTime.set(currentTime);\n    lastLoadEventAmount.set(event.loaded);\n\n    loading.set(state);\n  };\n\n  const httpRequest: HttpRequest<TArgs> = {\n    execute,\n    destroy,\n    loading: loading.asReadonly(),\n    error: error.asReadonly(),\n    response: response.asReadonly(),\n    currentEvent: currentEvent.asReadonly(),\n    isStale,\n  };\n\n  return httpRequest;\n};\n"]}

package/esm2022/lib/experimental/index.mjs

@@ -0,0 +1,21 @@
+export * from './bearer-auth-provider';
+export * from './bearer-auth-provider-config';
+export * from './http-request';
+export * from './query';
+export * from './query-client';
+export * from './query-client-config';
+export * from './query-creator';
+export * from './query-creator-templates';
+export * from './query-dependencies';
+export * from './query-errors';
+export * from './query-execute';
+export * from './query-execute-utils';
+export * from './query-features';
+export * from './query-repository';
+export * from './query-snapshot';
+export * from './query-state';
+export * from './query-utils';
+export * from './secure-query';
+export * from './secure-query-creator';
+export * from './secure-query-execute';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL3F1ZXJ5L3NyYy9saWIvZXhwZXJpbWVudGFsL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYywrQkFBK0IsQ0FBQztBQUM5QyxjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsU0FBUyxDQUFDO0FBQ3hCLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyx3QkFBd0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYmVhcmVyLWF1dGgtcHJvdmlkZXInO1xuZXhwb3J0ICogZnJvbSAnLi9iZWFyZXItYXV0aC1wcm92aWRlci1jb25maWcnO1xuZXhwb3J0ICogZnJvbSAnLi9odHRwLXJlcXVlc3QnO1xuZXhwb3J0ICogZnJvbSAnLi9xdWVyeSc7XG5leHBvcnQgKiBmcm9tICcuL3F1ZXJ5LWNsaWVudCc7XG5leHBvcnQgKiBmcm9tICcuL3F1ZXJ5LWNsaWVudC1jb25maWcnO1xuZXhwb3J0ICogZnJvbSAnLi9xdWVyeS1jcmVhdG9yJztcbmV4cG9ydCAqIGZyb20gJy4vcXVlcnktY3JlYXRvci10ZW1wbGF0ZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9xdWVyeS1kZXBlbmRlbmNpZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9xdWVyeS1lcnJvcnMnO1xuZXhwb3J0ICogZnJvbSAnLi9xdWVyeS1leGVjdXRlJztcbmV4cG9ydCAqIGZyb20gJy4vcXVlcnktZXhlY3V0ZS11dGlscyc7XG5leHBvcnQgKiBmcm9tICcuL3F1ZXJ5LWZlYXR1cmVzJztcbmV4cG9ydCAqIGZyb20gJy4vcXVlcnktcmVwb3NpdG9yeSc7XG5leHBvcnQgKiBmcm9tICcuL3F1ZXJ5LXNuYXBzaG90JztcbmV4cG9ydCAqIGZyb20gJy4vcXVlcnktc3RhdGUnO1xuZXhwb3J0ICogZnJvbSAnLi9xdWVyeS11dGlscyc7XG5leHBvcnQgKiBmcm9tICcuL3NlY3VyZS1xdWVyeSc7XG5leHBvcnQgKiBmcm9tICcuL3NlY3VyZS1xdWVyeS1jcmVhdG9yJztcbmV4cG9ydCAqIGZyb20gJy4vc2VjdXJlLXF1ZXJ5LWV4ZWN1dGUnO1xuIl19

package/esm2022/lib/experimental/query-client-config.mjs

@@ -0,0 +1,13 @@
+/* eslint-disable @typescript-eslint/no-empty-function */
+import { InjectionToken } from '@angular/core';
+export const createQueryClientConfig = (options) => {
+    const token = new InjectionToken(`QueryClient_${options.name}`);
+    const clientConfig = {
+        baseUrl: options.baseUrl,
+        token,
+        name: options.name,
+        queryString: options.queryString,
+    };
+    return clientConfig;
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,16 @@
+/* eslint-disable @typescript-eslint/no-empty-function */
+import { createQueryRepository } from './query-repository';
+export const createQueryClient = (config) => {
+    const repository = createQueryRepository(config);
+    const client = {
+        repository,
+    };
+    return client;
+};
+export const provideQueryClient = (config) => {
+    return {
+        provide: config.token,
+        useFactory: () => createQueryClient(config),
+    };
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicXVlcnktY2xpZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9xdWVyeS9zcmMvbGliL2V4cGVyaW1lbnRhbC9xdWVyeS1jbGllbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEseURBQXlEO0FBR3pELE9BQU8sRUFBbUIscUJBQXFCLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQU01RSxNQUFNLENBQUMsTUFBTSxpQkFBaUIsR0FBRyxDQUFDLE1BQXlCLEVBQUUsRUFBRTtJQUM3RCxNQUFNLFVBQVUsR0FBRyxxQkFBcUIsQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUVqRCxNQUFNLE1BQU0sR0FBZ0I7UUFDMUIsVUFBVTtLQUNYLENBQUM7SUFFRixPQUFPLE1BQU0sQ0FBQztBQUNoQixDQUFDLENBQUM7QUFFRixNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBRyxDQUFDLE1BQXlCLEVBQUUsRUFBRTtJQUM5RCxPQUFPO1FBQ0wsT0FBTyxFQUFFLE1BQU0sQ0FBQyxLQUFLO1FBQ3JCLFVBQVUsRUFBRSxHQUFHLEVBQUUsQ0FBQyxpQkFBaUIsQ0FBQyxNQUFNLENBQUM7S0FDNUMsQ0FBQztBQUNKLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qIGVzbGludC1kaXNhYmxlIEB0eXBlc2NyaXB0LWVzbGludC9uby1lbXB0eS1mdW5jdGlvbiAqL1xuXG5pbXBvcnQgeyBRdWVyeUNsaWVudENvbmZpZyB9IGZyb20gJy4vcXVlcnktY2xpZW50LWNvbmZpZyc7XG5pbXBvcnQgeyBRdWVyeVJlcG9zaXRvcnksIGNyZWF0ZVF1ZXJ5UmVwb3NpdG9yeSB9IGZyb20gJy4vcXVlcnktcmVwb3NpdG9yeSc7XG5cbmV4cG9ydCB0eXBlIFF1ZXJ5Q2xpZW50ID0ge1xuICByZXBvc2l0b3J5OiBRdWVyeVJlcG9zaXRvcnk7XG59O1xuXG5leHBvcnQgY29uc3QgY3JlYXRlUXVlcnlDbGllbnQgPSAoY29uZmlnOiBRdWVyeUNsaWVudENvbmZpZykgPT4ge1xuICBjb25zdCByZXBvc2l0b3J5ID0gY3JlYXRlUXVlcnlSZXBvc2l0b3J5KGNvbmZpZyk7XG5cbiAgY29uc3QgY2xpZW50OiBRdWVyeUNsaWVudCA9IHtcbiAgICByZXBvc2l0b3J5LFxuICB9O1xuXG4gIHJldHVybiBjbGllbnQ7XG59O1xuXG5leHBvcnQgY29uc3QgcHJvdmlkZVF1ZXJ5Q2xpZW50ID0gKGNvbmZpZzogUXVlcnlDbGllbnRDb25maWcpID0+IHtcbiAgcmV0dXJuIHtcbiAgICBwcm92aWRlOiBjb25maWcudG9rZW4sXG4gICAgdXNlRmFjdG9yeTogKCkgPT4gY3JlYXRlUXVlcnlDbGllbnQoY29uZmlnKSxcbiAgfTtcbn07XG4iXX0=

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

@@ -0,0 +1,33 @@
+import { createQueryCreator } from './query-creator';
+import { createSecureQueryCreator } from './secure-query-creator';
+export const createGetQuery = (client) => {
+    return (creatorOptions) => createQueryCreator(creatorOptions, { method: 'GET', client });
+};
+export const createSecureGetQuery = (client, authProvider) => {
+    return (creatorOptions) => createSecureQueryCreator(creatorOptions, { method: 'GET', client, authProvider });
+};
+export const createPostQuery = (client) => {
+    return (creatorOptions) => createQueryCreator(creatorOptions, { method: 'POST', client });
+};
+export const createSecurePostQuery = (client, authProvider) => {
+    return (creatorOptions) => createSecureQueryCreator(creatorOptions, { method: 'POST', client, authProvider });
+};
+export const createPutQuery = (client) => {
+    return (creatorOptions) => createQueryCreator(creatorOptions, { method: 'PUT', client });
+};
+export const createSecurePutQuery = (client, authProvider) => {
+    return (creatorOptions) => createSecureQueryCreator(creatorOptions, { method: 'PUT', client, authProvider });
+};
+export const createDeleteQuery = (client) => {
+    return (creatorOptions) => createQueryCreator(creatorOptions, { method: 'DELETE', client });
+};
+export const createSecureDeleteQuery = (client, authProvider) => {
+    return (creatorOptions) => createSecureQueryCreator(creatorOptions, { method: 'DELETE', client, authProvider });
+};
+export const createPatchQuery = (client) => {
+    return (creatorOptions) => createQueryCreator(creatorOptions, { method: 'PATCH', client });
+};
+export const createSecurePatchQuery = (client, authProvider) => {
+    return (creatorOptions) => createSecureQueryCreator(creatorOptions, { method: 'PATCH', client, authProvider });
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,28 @@
+import { createQuery } from './query';
+export const splitQueryConfig = (args) => {
+    let queryConfig = {};
+    let features = [];
+    const first = args[0];
+    if (first) {
+        if ('type' in first) {
+            features = args;
+        }
+        else {
+            [queryConfig, ...features] = args;
+        }
+    }
+    return { features, queryConfig };
+};
+export const createQueryCreator = (options, internals) => {
+    function queryCreator(...args) {
+        const { features, queryConfig } = splitQueryConfig(args);
+        return createQuery({
+            creator: options,
+            creatorInternals: internals,
+            features,
+            queryConfig,
+        });
+    }
+    return queryCreator;
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,14 @@
+/* eslint-disable @typescript-eslint/no-empty-function */
+import { DestroyRef, Injector, inject } from '@angular/core';
+export const setupQueryDependencies = (options) => {
+    const destroyRef = inject(DestroyRef);
+    const client = inject(options.clientConfig.token);
+    const injector = inject(Injector);
+    const dependencies = {
+        destroyRef,
+        client,
+        injector,
+    };
+    return dependencies;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicXVlcnktZGVwZW5kZW5jaWVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9xdWVyeS9zcmMvbGliL2V4cGVyaW1lbnRhbC9xdWVyeS1kZXBlbmRlbmNpZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEseURBQXlEO0FBRXpELE9BQU8sRUFBRSxVQUFVLEVBQUUsUUFBUSxFQUFFLE1BQU0sRUFBRSxNQUFNLGVBQWUsQ0FBQztBQWM3RCxNQUFNLENBQUMsTUFBTSxzQkFBc0IsR0FBRyxDQUFDLE9BQXNDLEVBQUUsRUFBRTtJQUMvRSxNQUFNLFVBQVUsR0FBRyxNQUFNLENBQUMsVUFBVSxDQUFDLENBQUM7SUFDdEMsTUFBTSxNQUFNLEdBQUcsTUFBTSxDQUFDLE9BQU8sQ0FBQyxZQUFZLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDbEQsTUFBTSxRQUFRLEdBQUcsTUFBTSxDQUFDLFFBQVEsQ0FBQyxDQUFDO0lBRWxDLE1BQU0sWUFBWSxHQUFzQjtRQUN0QyxVQUFVO1FBQ1YsTUFBTTtRQUNOLFFBQVE7S0FDVCxDQUFDO0lBRUYsT0FBTyxZQUFZLENBQUM7QUFDdEIsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyogZXNsaW50LWRpc2FibGUgQHR5cGVzY3JpcHQtZXNsaW50L25vLWVtcHR5LWZ1bmN0aW9uICovXG5cbmltcG9ydCB7IERlc3Ryb3lSZWYsIEluamVjdG9yLCBpbmplY3QgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFF1ZXJ5Q2xpZW50IH0gZnJvbSAnLi9xdWVyeS1jbGllbnQnO1xuaW1wb3J0IHsgUXVlcnlDbGllbnRDb25maWcgfSBmcm9tICcuL3F1ZXJ5LWNsaWVudC1jb25maWcnO1xuXG5leHBvcnQgdHlwZSBTZXR1cFF1ZXJ5RGVwZW5kZW5jaWVzT3B0aW9ucyA9IHtcbiAgY2xpZW50Q29uZmlnOiBRdWVyeUNsaWVudENvbmZpZztcbn07XG5cbmV4cG9ydCB0eXBlIFF1ZXJ5RGVwZW5kZW5jaWVzID0ge1xuICBkZXN0cm95UmVmOiBEZXN0cm95UmVmO1xuICBjbGllbnQ6IFF1ZXJ5Q2xpZW50O1xuICBpbmplY3RvcjogSW5qZWN0b3I7XG59O1xuXG5leHBvcnQgY29uc3Qgc2V0dXBRdWVyeURlcGVuZGVuY2llcyA9IChvcHRpb25zOiBTZXR1cFF1ZXJ5RGVwZW5kZW5jaWVzT3B0aW9ucykgPT4ge1xuICBjb25zdCBkZXN0cm95UmVmID0gaW5qZWN0KERlc3Ryb3lSZWYpO1xuICBjb25zdCBjbGllbnQgPSBpbmplY3Qob3B0aW9ucy5jbGllbnRDb25maWcudG9rZW4pO1xuICBjb25zdCBpbmplY3RvciA9IGluamVjdChJbmplY3Rvcik7XG5cbiAgY29uc3QgZGVwZW5kZW5jaWVzOiBRdWVyeURlcGVuZGVuY2llcyA9IHtcbiAgICBkZXN0cm95UmVmLFxuICAgIGNsaWVudCxcbiAgICBpbmplY3RvcixcbiAgfTtcblxuICByZXR1cm4gZGVwZW5kZW5jaWVzO1xufTtcbiJdfQ==

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

@@ -0,0 +1,55 @@
+/* eslint-disable @typescript-eslint/no-empty-function */
+import { RuntimeError } from '@ethlete/core';
+export const queryFeatureUsedMultipleTimes = (type) => {
+    return new RuntimeError(0 /* RuntimeErrorCode.QUERY_FEATURE_USED_MULTIPLE_TIMES */, `The query feature "${type}()" was used multiple times.`);
+};
+export const withArgsQueryFeatureMissingButRouteIsFunction = () => {
+    return new RuntimeError(100 /* RuntimeErrorCode.WITH_ARGS_QUERY_FEATURE_MISSING_BUT_ROUTE_IS_FUNCTION */, `This queries route is a function, but a "withArgs()" feature is missing.`);
+};
+export const withPollingUsedOnUnsupportedHttpMethod = (method) => {
+    return new RuntimeError(101 /* RuntimeErrorCode.WITH_POLLING_USED_ON_UNSUPPORTED_HTTP_METHOD */, `This is a "${method}" request, "withPolling()" is only supported for GET, HEAD, OPTIONS requests and GQL queries.`);
+};
+export const withAutoRefreshUsedOnUnsupportedHttpMethod = (method) => {
+    return new RuntimeError(102 /* RuntimeErrorCode.WITH_AUTO_REFRESH_USED_ON_UNSUPPORTED_HTTP_METHOD */, `This is a "${method}" request, "withAutoRefresh()" is only supported for GET, HEAD, OPTIONS requests and GQL queries.`);
+};
+export const withAutoRefreshUsedInManualQuery = () => {
+    return new RuntimeError(103 /* RuntimeErrorCode.WITH_AUTO_REFRESH_USED_IN_MANUAL_QUERY */, `"withAutoRefresh()" has been used inside a query that has "onlyManualExecution" set to true.` +
+        ` If this is intentional, set "ignoreOnlyManualExecution" to true inside the auto refresh config.`);
+};
+export const cookieLoginTriedButCookieDisabled = () => {
+    return new RuntimeError(200 /* RuntimeErrorCode.COOKIE_LOGIN_TRIED_BUT_COOKIE_DISABLED */, `Cookie login has been tried, but the cookie is disabled.`);
+};
+export const enableCookieCalledWithoutCookieConfig = () => {
+    return new RuntimeError(201 /* RuntimeErrorCode.ENABLE_COOKIE_CALLED_WITHOUT_COOKIE_CONFIG */, `enableCookie() has been called but there is no cookie config. Please set it during the auth provider creation.`);
+};
+export const disableCookieCalledWithoutCookieConfig = () => {
+    return new RuntimeError(202 /* RuntimeErrorCode.DISABLE_COOKIE_CALLED_WITHOUT_COOKIE_CONFIG */, `disableCookie() has been called but there is no cookie config. Please set it during the auth provider creation.`);
+};
+export const loginCalledWithoutConfig = () => {
+    return new RuntimeError(203 /* RuntimeErrorCode.LOGIN_CALLED_WITHOUT_CONFIG */, `login() has been called without a config. Please set it during the auth provider creation.`);
+};
+export const loginWithTokenCalledWithoutConfig = () => {
+    return new RuntimeError(204 /* RuntimeErrorCode.LOGIN_WITH_TOKEN_CALLED_WITHOUT_CONFIG */, `loginWithToken() has been called without a config. Please set it during the auth provider creation.`);
+};
+export const refreshTokenCalledWithoutConfig = () => {
+    return new RuntimeError(205 /* RuntimeErrorCode.REFRESH_TOKEN_CALLED_WITHOUT_CONFIG */, `refreshToken() has been called without a config. Please set it during the auth provider creation.`);
+};
+export const selectRoleCalledWithoutConfig = () => {
+    return new RuntimeError(206 /* RuntimeErrorCode.SELECT_ROLE_CALLED_WITHOUT_CONFIG */, `selectRole() has been called without a config. Please set it during the auth provider creation.`);
+};
+export const defaultResponseTransformerResponseNotObject = (currentType) => {
+    return new RuntimeError(207 /* RuntimeErrorCode.DEFAULT_RESPONSE_TRANSFORMER_RESPONSE_NOT_OBJECT */, `The default response transformer expects the response to be an object, but it is a "${currentType}".`);
+};
+export const defaultResponseTransformerResponseNotContainingAccessToken = () => {
+    return new RuntimeError(208 /* RuntimeErrorCode.DEFAULT_RESPONSE_TRANSFORMER_RESPONSE_NOT_CONTAINING_ACCESS_TOKEN */, `The default response transformer expects the response to contain an "accessToken" property.`);
+};
+export const defaultResponseTransformerResponseNotContainingRefreshToken = () => {
+    return new RuntimeError(209 /* RuntimeErrorCode.DEFAULT_RESPONSE_TRANSFORMER_RESPONSE_NOT_CONTAINING_REFRESH_TOKEN */, `The default response transformer expects the response to contain a "refreshToken" property.`);
+};
+export const unableToDecryptBearerToken = (token) => {
+    return new RuntimeError(210 /* RuntimeErrorCode.UNABLE_TO_DECRYPT_BEARER_TOKEN */, `The bearer token could not be decrypted: ${token}`);
+};
+export const bearerExpiresInPropertyNotNumber = (expiresIn) => {
+    return new RuntimeError(211 /* RuntimeErrorCode.BEARER_EXPIRES_IN_PROPERTY_NOT_NUMBER */, `The expires in property is not a number: ${expiresIn}`);
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query-errors.js","sourceRoot":"","sources":["../../../../../../libs/query/src/lib/experimental/query-errors.ts"],"names":[],"mappings":"AAAA,yDAAyD;AAEzD,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AA6B7C,MAAM,CAAC,MAAM,6BAA6B,GAAG,CAAC,IAAsB,EAAE,EAAE;IACtE,OAAO,IAAI,YAAY,6DAErB,sBAAsB,IAAI,8BAA8B,CACzD,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,6CAA6C,GAAG,GAAG,EAAE;IAChE,OAAO,IAAI,YAAY,mFAErB,0EAA0E,CAC3E,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,sCAAsC,GAAG,CAAC,MAAmB,EAAE,EAAE;IAC5E,OAAO,IAAI,YAAY,0EAErB,cAAc,MAAM,+FAA+F,CACpH,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,0CAA0C,GAAG,CAAC,MAAmB,EAAE,EAAE;IAChF,OAAO,IAAI,YAAY,+EAErB,cAAc,MAAM,mGAAmG,CACxH,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,gCAAgC,GAAG,GAAG,EAAE;IACnD,OAAO,IAAI,YAAY,oEAErB,8FAA8F;QAC5F,kGAAkG,CACrG,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,iCAAiC,GAAG,GAAG,EAAE;IACpD,OAAO,IAAI,YAAY,oEAErB,0DAA0D,CAC3D,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,qCAAqC,GAAG,GAAG,EAAE;IACxD,OAAO,IAAI,YAAY,wEAErB,gHAAgH,CACjH,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,sCAAsC,GAAG,GAAG,EAAE;IACzD,OAAO,IAAI,YAAY,yEAErB,iHAAiH,CAClH,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,wBAAwB,GAAG,GAAG,EAAE;IAC3C,OAAO,IAAI,YAAY,yDAErB,4FAA4F,CAC7F,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,iCAAiC,GAAG,GAAG,EAAE;IACpD,OAAO,IAAI,YAAY,oEAErB,qGAAqG,CACtG,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,+BAA+B,GAAG,GAAG,EAAE;IAClD,OAAO,IAAI,YAAY,iEAErB,mGAAmG,CACpG,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,6BAA6B,GAAG,GAAG,EAAE;IAChD,OAAO,IAAI,YAAY,+DAErB,iGAAiG,CAClG,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,2CAA2C,GAAG,CAAC,WAAmB,EAAE,EAAE;IACjF,OAAO,IAAI,YAAY,8EAErB,uFAAuF,WAAW,IAAI,CACvG,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,0DAA0D,GAAG,GAAG,EAAE;IAC7E,OAAO,IAAI,YAAY,+FAErB,6FAA6F,CAC9F,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,2DAA2D,GAAG,GAAG,EAAE;IAC9E,OAAO,IAAI,YAAY,gGAErB,6FAA6F,CAC9F,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC,KAAa,EAAE,EAAE;IAC1D,OAAO,IAAI,YAAY,4DAErB,4CAA4C,KAAK,EAAE,CACpD,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,gCAAgC,GAAG,CAAC,SAAkB,EAAE,EAAE;IACrE,OAAO,IAAI,YAAY,mEAErB,4CAA4C,SAAS,EAAE,CACxD,CAAC;AACJ,CAAC,CAAC","sourcesContent":["/* eslint-disable @typescript-eslint/no-empty-function */\n\nimport { RuntimeError } from '@ethlete/core';\nimport { QueryMethod } from './query-creator';\nimport { QueryFeatureType } from './query-features';\n\nexport const enum RuntimeErrorCode {\n  // Query\n  QUERY_FEATURE_USED_MULTIPLE_TIMES = 0,\n\n  // Query features\n  WITH_ARGS_QUERY_FEATURE_MISSING_BUT_ROUTE_IS_FUNCTION = 100,\n  WITH_POLLING_USED_ON_UNSUPPORTED_HTTP_METHOD = 101,\n  WITH_AUTO_REFRESH_USED_ON_UNSUPPORTED_HTTP_METHOD = 102,\n  WITH_AUTO_REFRESH_USED_IN_MANUAL_QUERY = 103,\n\n  // Auth provider\n  COOKIE_LOGIN_TRIED_BUT_COOKIE_DISABLED = 200,\n  ENABLE_COOKIE_CALLED_WITHOUT_COOKIE_CONFIG = 201,\n  DISABLE_COOKIE_CALLED_WITHOUT_COOKIE_CONFIG = 202,\n  LOGIN_CALLED_WITHOUT_CONFIG = 203,\n  LOGIN_WITH_TOKEN_CALLED_WITHOUT_CONFIG = 204,\n  REFRESH_TOKEN_CALLED_WITHOUT_CONFIG = 205,\n  SELECT_ROLE_CALLED_WITHOUT_CONFIG = 206,\n  DEFAULT_RESPONSE_TRANSFORMER_RESPONSE_NOT_OBJECT = 207,\n  DEFAULT_RESPONSE_TRANSFORMER_RESPONSE_NOT_CONTAINING_ACCESS_TOKEN = 208,\n  DEFAULT_RESPONSE_TRANSFORMER_RESPONSE_NOT_CONTAINING_REFRESH_TOKEN = 209,\n  UNABLE_TO_DECRYPT_BEARER_TOKEN = 210,\n  BEARER_EXPIRES_IN_PROPERTY_NOT_NUMBER = 211,\n}\n\nexport const queryFeatureUsedMultipleTimes = (type: QueryFeatureType) => {\n  return new RuntimeError(\n    RuntimeErrorCode.QUERY_FEATURE_USED_MULTIPLE_TIMES,\n    `The query feature \"${type}()\" was used multiple times.`,\n  );\n};\n\nexport const withArgsQueryFeatureMissingButRouteIsFunction = () => {\n  return new RuntimeError(\n    RuntimeErrorCode.WITH_ARGS_QUERY_FEATURE_MISSING_BUT_ROUTE_IS_FUNCTION,\n    `This queries route is a function, but a \"withArgs()\" feature is missing.`,\n  );\n};\n\nexport const withPollingUsedOnUnsupportedHttpMethod = (method: QueryMethod) => {\n  return new RuntimeError(\n    RuntimeErrorCode.WITH_POLLING_USED_ON_UNSUPPORTED_HTTP_METHOD,\n    `This is a \"${method}\" request, \"withPolling()\" is only supported for GET, HEAD, OPTIONS requests and GQL queries.`,\n  );\n};\n\nexport const withAutoRefreshUsedOnUnsupportedHttpMethod = (method: QueryMethod) => {\n  return new RuntimeError(\n    RuntimeErrorCode.WITH_AUTO_REFRESH_USED_ON_UNSUPPORTED_HTTP_METHOD,\n    `This is a \"${method}\" request, \"withAutoRefresh()\" is only supported for GET, HEAD, OPTIONS requests and GQL queries.`,\n  );\n};\n\nexport const withAutoRefreshUsedInManualQuery = () => {\n  return new RuntimeError(\n    RuntimeErrorCode.WITH_AUTO_REFRESH_USED_IN_MANUAL_QUERY,\n    `\"withAutoRefresh()\" has been used inside a query that has \"onlyManualExecution\" set to true.` +\n      ` If this is intentional, set \"ignoreOnlyManualExecution\" to true inside the auto refresh config.`,\n  );\n};\n\nexport const cookieLoginTriedButCookieDisabled = () => {\n  return new RuntimeError(\n    RuntimeErrorCode.COOKIE_LOGIN_TRIED_BUT_COOKIE_DISABLED,\n    `Cookie login has been tried, but the cookie is disabled.`,\n  );\n};\n\nexport const enableCookieCalledWithoutCookieConfig = () => {\n  return new RuntimeError(\n    RuntimeErrorCode.ENABLE_COOKIE_CALLED_WITHOUT_COOKIE_CONFIG,\n    `enableCookie() has been called but there is no cookie config. Please set it during the auth provider creation.`,\n  );\n};\n\nexport const disableCookieCalledWithoutCookieConfig = () => {\n  return new RuntimeError(\n    RuntimeErrorCode.DISABLE_COOKIE_CALLED_WITHOUT_COOKIE_CONFIG,\n    `disableCookie() has been called but there is no cookie config. Please set it during the auth provider creation.`,\n  );\n};\n\nexport const loginCalledWithoutConfig = () => {\n  return new RuntimeError(\n    RuntimeErrorCode.LOGIN_CALLED_WITHOUT_CONFIG,\n    `login() has been called without a config. Please set it during the auth provider creation.`,\n  );\n};\n\nexport const loginWithTokenCalledWithoutConfig = () => {\n  return new RuntimeError(\n    RuntimeErrorCode.LOGIN_WITH_TOKEN_CALLED_WITHOUT_CONFIG,\n    `loginWithToken() has been called without a config. Please set it during the auth provider creation.`,\n  );\n};\n\nexport const refreshTokenCalledWithoutConfig = () => {\n  return new RuntimeError(\n    RuntimeErrorCode.REFRESH_TOKEN_CALLED_WITHOUT_CONFIG,\n    `refreshToken() has been called without a config. Please set it during the auth provider creation.`,\n  );\n};\n\nexport const selectRoleCalledWithoutConfig = () => {\n  return new RuntimeError(\n    RuntimeErrorCode.SELECT_ROLE_CALLED_WITHOUT_CONFIG,\n    `selectRole() has been called without a config. Please set it during the auth provider creation.`,\n  );\n};\n\nexport const defaultResponseTransformerResponseNotObject = (currentType: string) => {\n  return new RuntimeError(\n    RuntimeErrorCode.DEFAULT_RESPONSE_TRANSFORMER_RESPONSE_NOT_OBJECT,\n    `The default response transformer expects the response to be an object, but it is a \"${currentType}\".`,\n  );\n};\n\nexport const defaultResponseTransformerResponseNotContainingAccessToken = () => {\n  return new RuntimeError(\n    RuntimeErrorCode.DEFAULT_RESPONSE_TRANSFORMER_RESPONSE_NOT_CONTAINING_ACCESS_TOKEN,\n    `The default response transformer expects the response to contain an \"accessToken\" property.`,\n  );\n};\n\nexport const defaultResponseTransformerResponseNotContainingRefreshToken = () => {\n  return new RuntimeError(\n    RuntimeErrorCode.DEFAULT_RESPONSE_TRANSFORMER_RESPONSE_NOT_CONTAINING_REFRESH_TOKEN,\n    `The default response transformer expects the response to contain a \"refreshToken\" property.`,\n  );\n};\n\nexport const unableToDecryptBearerToken = (token: string) => {\n  return new RuntimeError(\n    RuntimeErrorCode.UNABLE_TO_DECRYPT_BEARER_TOKEN,\n    `The bearer token could not be decrypted: ${token}`,\n  );\n};\n\nexport const bearerExpiresInPropertyNotNumber = (expiresIn: unknown) => {\n  return new RuntimeError(\n    RuntimeErrorCode.BEARER_EXPIRES_IN_PROPERTY_NOT_NUMBER,\n    `The expires in property is not a number: ${expiresIn}`,\n  );\n};\n"]}

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

@@ -0,0 +1,57 @@
+import { runInInjectionContext } from '@angular/core';
+import { syncSignal } from '@ethlete/core';
+export const resetExecuteState = (options) => {
+    const { executeState, executeOptions: opts } = options;
+    const { deps, state } = opts;
+    const { effectRefs, previousKey } = executeState;
+    deps.client.repository.unbind(previousKey, deps.destroyRef);
+    effectRefs.forEach((ref) => ref.destroy());
+    effectRefs.length = 0;
+    state.args.set(null);
+    state.error.set(null);
+    state.latestHttpEvent.set(null);
+    state.loading.set(null);
+    state.response.set(null);
+    state.lastTimeExecutedAt.set(null);
+};
+export const setupQueryExecuteState = () => {
+    return {
+        effectRefs: [],
+        previousKey: false,
+    };
+};
+export const queryExecute = (options) => {
+    const { executeOptions, args, executeState } = options;
+    const { deps, state, creator, creatorInternals, queryConfig } = executeOptions;
+    const { key, request } = deps.client.repository.request({
+        method: creatorInternals.method,
+        route: creator.route,
+        reportProgress: creator.reportProgress,
+        withCredentials: creator.withCredentials,
+        transferCache: creator.transferCache,
+        responseType: creator.responseType || 'json',
+        pathParams: args?.pathParams,
+        queryParams: args?.queryParams,
+        body: args?.body,
+        destroyRef: deps.destroyRef,
+        key: queryConfig.key,
+        headers: args?.headers,
+    });
+    executeState.previousKey = key;
+    runInInjectionContext(deps.injector, () => {
+        const responseRef = syncSignal(request.response, state.response);
+        const loadingRef = syncSignal(request.loading, state.loading);
+        const errorRef = syncSignal(request.error, state.error);
+        const latestHttpEventRef = syncSignal(request.currentEvent, state.latestHttpEvent);
+        executeState.effectRefs.push(responseRef, loadingRef, errorRef, latestHttpEventRef);
+    });
+    state.lastTimeExecutedAt.set(Date.now());
+};
+export const cleanupPreviousExecute = (options) => {
+    const { executeOptions, executeState } = options;
+    const { deps } = executeOptions;
+    deps.client.repository.unbind(executeState.previousKey, deps.destroyRef);
+    executeState.effectRefs.forEach((ref) => ref.destroy());
+    executeState.effectRefs.length = 0;
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,12 @@
+import { cleanupPreviousExecute, queryExecute, resetExecuteState, setupQueryExecuteState } from './query-execute-utils';
+export const createExecuteFn = (options) => {
+    const executeState = setupQueryExecuteState();
+    const reset = () => resetExecuteState({ executeState, executeOptions: options });
+    const exec = (args = options.state.args()) => {
+        cleanupPreviousExecute({ executeOptions: options, executeState, args });
+        queryExecute({ executeOptions: options, executeState, args });
+    };
+    exec['reset'] = reset;
+    return exec;
+};
+//# sourceMappingURL=data:application/json;base64,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