@ethlete/query 5.16.0 → 5.16.2

package/esm2022/lib/infinite-query/infinity-query.mjs

@@ -0,0 +1,171 @@
+import { BehaviorSubject, combineLatest, map, of, shareReplay, switchMap, tap } from 'rxjs';
+import { filterSuccess } from '../query';
+export class InfinityQuery {
+    get currentPage$() {
+        return this._currentPage$.asObservable();
+    }
+    get currentPage() {
+        return this._currentPage$.getValue();
+    }
+    get currentCalculatedPage$() {
+        return this._currentCalculatedPage$.asObservable();
+    }
+    get currentCalculatedPage() {
+        return this._currentCalculatedPage$.getValue();
+    }
+    get totalPages$() {
+        return this._totalPages$.asObservable();
+    }
+    get totalPages() {
+        return this._totalPages$.getValue();
+    }
+    get itemsPerPage$() {
+        return this._itemsPerPage$.asObservable();
+    }
+    get itemsPerPage() {
+        return this._itemsPerPage$.getValue();
+    }
+    get data$() {
+        return this._data$;
+    }
+    get currentQuery$() {
+        return this._lastQuery$;
+    }
+    constructor(_config, _destroy$) {
+        this._config = _config;
+        this._destroy$ = _destroy$;
+        this._queries$ = new BehaviorSubject([]);
+        this._currentPage$ = new BehaviorSubject(null);
+        this._currentCalculatedPage$ = new BehaviorSubject(null);
+        this._totalPages$ = new BehaviorSubject(null);
+        this._itemsPerPage$ = new BehaviorSubject(this._config.limitParam?.value ?? 10);
+        this._data$ = this._queries$.pipe(switchMap((queries) => {
+            if (!queries.length) {
+                return of([]);
+            }
+            return combineLatest(queries.map((query) => query.state$.pipe(filterSuccess(), map((state) => ({ state, query })))));
+        }), tap((stateMaps) => {
+            const lastState = stateMaps[stateMaps.length - 1]?.state;
+            const lastQuery = stateMaps[stateMaps.length - 1]?.query;
+            if (!lastState || !lastQuery) {
+                return;
+            }
+            const totalPages = this._config.response.totalPagesExtractor?.({
+                response: lastState.response,
+                itemsPerPage: this.itemsPerPage,
+                args: lastQuery._arguments,
+            }) ??
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                lastState.response?.totalPages ??
+                null;
+            this._totalPages$.next(totalPages);
+        }), map((stateMaps) => {
+            if (!stateMaps.length) {
+                return null;
+            }
+            const fullData = stateMaps.reduce((acc, stateMap) => {
+                const valExtractFn = this._config?.response?.valueExtractor;
+                let data = valExtractFn
+                    ? valExtractFn?.(stateMap.state.response)
+                    : stateMap.state.response;
+                if (this._config.response.reverse) {
+                    data = [...data].reverse();
+                }
+                if (this._config.response.appendItemsTo === 'start') {
+                    acc.unshift(...data);
+                }
+                else {
+                    acc.push(...data);
+                }
+                return acc;
+            }, 
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            []);
+            return fullData;
+        }), shareReplay({ bufferSize: 1, refCount: true }));
+        this._lastQuery$ = this._queries$.pipe(map((queries) => queries[queries.length - 1] ?? null), shareReplay({ bufferSize: 1, refCount: true }));
+    }
+    nextPage() {
+        const newPage = (this._currentPage$.value ?? 0) + 1;
+        const calculatedPage = this._config?.pageParam?.valueCalculator?.({
+            page: newPage,
+            totalPages: this.totalPages,
+            itemsPerPage: this.itemsPerPage,
+        }) ?? newPage;
+        if (this.totalPages !== null && newPage > this.totalPages) {
+            console.error('Cannot load more pages, already at the end. Make sure to not render the infinity query trigger using *ngIf canLoadMore');
+            return;
+        }
+        const args = this._prepareArgs(this._config, calculatedPage);
+        const query = this._config.queryCreator.prepare(args).execute();
+        if (this._config.pollingInterval) {
+            query.poll({ interval: this._config.pollingInterval, takeUntil: this._destroy$ });
+        }
+        this._queries$.next([...this._queries$.value, query]);
+        this._currentPage$.next(newPage);
+        this._currentCalculatedPage$.next(calculatedPage);
+    }
+    reset(newConfig) {
+        this._config = { ...this._config, ...(newConfig ?? {}) };
+        this._currentPage$.next(null);
+        this._currentCalculatedPage$.next(null);
+        this._totalPages$.next(null);
+        this._itemsPerPage$.next(this._config.limitParam?.value ?? 10);
+        this._queries$.next([]);
+        this.nextPage();
+    }
+    _prepareArgs(config, page) {
+        const pageParamLocation = this._getPageParamLocation(config?.pageParam?.location);
+        const pageArgs = {
+            [pageParamLocation]: {
+                [config?.pageParam?.key ?? 'page']: page,
+            },
+        };
+        const limitParamLocation = this._getPageParamLocation(config?.limitParam?.location);
+        const limitArgs = {
+            [limitParamLocation]: {
+                [config?.limitParam?.key ?? 'limit']: config?.limitParam?.value ?? 10,
+            },
+        };
+        const defaultConfig = config?.defaultArgs ?? {};
+        const mergedArgs = pageParamLocation === limitParamLocation
+            ? {
+                ...defaultConfig,
+                [pageParamLocation]: {
+                    ...(config?.defaultArgs?.[pageParamLocation] ?? {}),
+                    ...pageArgs[limitParamLocation],
+                    ...limitArgs[limitParamLocation],
+                },
+            }
+            : {
+                ...defaultConfig,
+                [pageParamLocation]: {
+                    ...(config?.defaultArgs?.[pageParamLocation] ?? {}),
+                    ...pageArgs[pageParamLocation],
+                },
+                [limitParamLocation]: {
+                    ...(config?.defaultArgs?.[limitParamLocation] ?? {}),
+                    ...limitArgs[limitParamLocation],
+                },
+            };
+        return mergedArgs;
+    }
+    _getPageParamLocation(location) {
+        const loc = location ?? 'query';
+        switch (loc) {
+            case 'path':
+                return 'pathParams';
+            case 'query':
+                return 'queryParams';
+            case 'body':
+                return 'body';
+            case 'header':
+                return 'headers';
+            case 'variable':
+                return 'variables';
+            default:
+                throw new Error(`Invalid pageParamLocation: ${loc}`);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"infinity-query.js","sourceRoot":"","sources":["../../../../../../libs/query/src/lib/infinite-query/infinity-query.ts"],"names":[],"mappings":"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","sourcesContent":["import { BehaviorSubject, Observable, combineLatest, map, of, shareReplay, switchMap, tap } from 'rxjs';\nimport { filterSuccess } from '../query';\nimport { AnyQueryCreator, ConstructQuery, QueryArgsOf, QueryDataOf } from '../query-creator';\nimport { InfinityQueryConfig, InfinityQueryParamLocation } from './infinity-query.types';\n\nexport class InfinityQuery<\n  QueryCreator extends AnyQueryCreator,\n  Query extends ConstructQuery<QueryCreator>,\n  Args extends QueryArgsOf<QueryCreator>,\n  QueryResponse extends QueryDataOf<QueryCreator>,\n  InfinityResponse extends unknown[],\n> {\n  private readonly _queries$ = new BehaviorSubject<Query[]>([]);\n  private readonly _currentPage$ = new BehaviorSubject<number | null>(null);\n  private readonly _currentCalculatedPage$ = new BehaviorSubject<number | null>(null);\n  private readonly _totalPages$ = new BehaviorSubject<number | null>(null);\n  private readonly _itemsPerPage$ = new BehaviorSubject<number>(this._config.limitParam?.value ?? 10);\n\n  private readonly _data$ = this._queries$.pipe(\n    switchMap((queries) => {\n      if (!queries.length) {\n        return of([]);\n      }\n\n      return combineLatest(\n        queries.map((query) =>\n          query.state$.pipe(\n            filterSuccess(),\n            map((state) => ({ state, query })),\n          ),\n        ),\n      );\n    }),\n    tap((stateMaps) => {\n      const lastState = stateMaps[stateMaps.length - 1]?.state;\n      const lastQuery = stateMaps[stateMaps.length - 1]?.query;\n\n      if (!lastState || !lastQuery) {\n        return;\n      }\n\n      const totalPages =\n        this._config.response.totalPagesExtractor?.({\n          response: lastState.response as QueryResponse,\n          itemsPerPage: this.itemsPerPage,\n          args: lastQuery._arguments,\n        }) ??\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        (lastState.response as any)?.totalPages ??\n        null;\n\n      this._totalPages$.next(totalPages);\n    }),\n    map((stateMaps) => {\n      if (!stateMaps.length) {\n        return null;\n      }\n\n      const fullData = stateMaps.reduce(\n        (acc, stateMap) => {\n          const valExtractFn = this._config?.response?.valueExtractor;\n          let data = valExtractFn\n            ? valExtractFn?.(stateMap.state.response as QueryResponse)\n            : (stateMap.state.response as InfinityResponse);\n\n          if (this._config.response.reverse) {\n            data = [...data].reverse() as InfinityResponse;\n          }\n\n          if (this._config.response.appendItemsTo === 'start') {\n            acc.unshift(...data);\n          } else {\n            acc.push(...data);\n          }\n          return acc;\n        },\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        [] as any as InfinityResponse,\n      );\n\n      return fullData;\n    }),\n    shareReplay({ bufferSize: 1, refCount: true }),\n  );\n\n  private readonly _lastQuery$ = this._queries$.pipe(\n    map((queries) => queries[queries.length - 1] ?? null),\n    shareReplay({ bufferSize: 1, refCount: true }),\n  );\n\n  get currentPage$() {\n    return this._currentPage$.asObservable();\n  }\n\n  get currentPage() {\n    return this._currentPage$.getValue();\n  }\n\n  get currentCalculatedPage$() {\n    return this._currentCalculatedPage$.asObservable();\n  }\n\n  get currentCalculatedPage() {\n    return this._currentCalculatedPage$.getValue();\n  }\n\n  get totalPages$() {\n    return this._totalPages$.asObservable();\n  }\n\n  get totalPages() {\n    return this._totalPages$.getValue();\n  }\n\n  get itemsPerPage$() {\n    return this._itemsPerPage$.asObservable();\n  }\n\n  get itemsPerPage() {\n    return this._itemsPerPage$.getValue();\n  }\n\n  get data$() {\n    return this._data$;\n  }\n\n  get currentQuery$() {\n    return this._lastQuery$;\n  }\n\n  constructor(\n    private _config: InfinityQueryConfig<QueryCreator, Args, QueryResponse, InfinityResponse>,\n    private _destroy$: Observable<boolean>,\n  ) {}\n\n  nextPage() {\n    const newPage = (this._currentPage$.value ?? 0) + 1;\n    const calculatedPage =\n      this._config?.pageParam?.valueCalculator?.({\n        page: newPage,\n        totalPages: this.totalPages,\n        itemsPerPage: this.itemsPerPage,\n      }) ?? newPage;\n\n    if (this.totalPages !== null && newPage > this.totalPages) {\n      console.error(\n        'Cannot load more pages, already at the end. Make sure to not render the infinity query trigger using *ngIf canLoadMore',\n      );\n      return;\n    }\n\n    const args = this._prepareArgs(this._config, calculatedPage);\n\n    const query = this._config.queryCreator.prepare(args).execute() as Query;\n\n    if (this._config.pollingInterval) {\n      query.poll({ interval: this._config.pollingInterval, takeUntil: this._destroy$ });\n    }\n\n    this._queries$.next([...this._queries$.value, query]);\n\n    this._currentPage$.next(newPage);\n    this._currentCalculatedPage$.next(calculatedPage);\n  }\n\n  reset(\n    newConfig?: Omit<\n      InfinityQueryConfig<QueryCreator, Args, QueryResponse, InfinityResponse>,\n      'queryCreator' | 'response'\n    >,\n  ) {\n    this._config = { ...this._config, ...(newConfig ?? {}) };\n\n    this._currentPage$.next(null);\n    this._currentCalculatedPage$.next(null);\n    this._totalPages$.next(null);\n    this._itemsPerPage$.next(this._config.limitParam?.value ?? 10);\n    this._queries$.next([]);\n\n    this.nextPage();\n  }\n\n  private _prepareArgs(config: InfinityQueryConfig<QueryCreator, Args, QueryResponse, InfinityResponse>, page: number) {\n    const pageParamLocation = this._getPageParamLocation(config?.pageParam?.location);\n\n    const pageArgs = {\n      [pageParamLocation]: {\n        [config?.pageParam?.key ?? 'page']: page,\n      },\n    };\n\n    const limitParamLocation = this._getPageParamLocation(config?.limitParam?.location);\n\n    const limitArgs = {\n      [limitParamLocation]: {\n        [config?.limitParam?.key ?? 'limit']: config?.limitParam?.value ?? 10,\n      },\n    };\n\n    const defaultConfig = config?.defaultArgs ?? {};\n\n    const mergedArgs =\n      pageParamLocation === limitParamLocation\n        ? {\n            ...defaultConfig,\n            [pageParamLocation]: {\n              ...(config?.defaultArgs?.[pageParamLocation] ?? {}),\n              ...pageArgs[limitParamLocation],\n              ...limitArgs[limitParamLocation],\n            },\n          }\n        : {\n            ...defaultConfig,\n            [pageParamLocation]: {\n              ...(config?.defaultArgs?.[pageParamLocation] ?? {}),\n              ...pageArgs[pageParamLocation],\n            },\n            [limitParamLocation]: {\n              ...(config?.defaultArgs?.[limitParamLocation] ?? {}),\n              ...limitArgs[limitParamLocation],\n            },\n          };\n\n    return mergedArgs;\n  }\n\n  private _getPageParamLocation(location: InfinityQueryParamLocation | undefined) {\n    const loc = location ?? 'query';\n\n    switch (loc) {\n      case 'path':\n        return 'pathParams';\n      case 'query':\n        return 'queryParams';\n      case 'body':\n        return 'body';\n      case 'header':\n        return 'headers';\n      case 'variable':\n        return 'variables';\n      default:\n        throw new Error(`Invalid pageParamLocation: ${loc}`);\n    }\n  }\n}\n"]}

package/esm2022/lib/infinite-query/infinity-query.types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/infinite-query/infinity-query.utils.mjs

@@ -0,0 +1,3 @@
+export const createInfinityQueryConfig = (config) => config;
+export const skipPaginationPageParamCalculator = ({ page, itemsPerPage }) => itemsPerPage * (page - 1);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5maW5pdHktcXVlcnkudXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL3F1ZXJ5L3NyYy9saWIvaW5maW5pdGUtcXVlcnkvaW5maW5pdHktcXVlcnkudXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBR0EsTUFBTSxDQUFDLE1BQU0seUJBQXlCLEdBQUcsQ0FNdkMsTUFBZ0YsRUFDaEYsRUFBRSxDQUFDLE1BQU0sQ0FBQztBQUVaLE1BQU0sQ0FBQyxNQUFNLGlDQUFpQyxHQUFHLENBQUMsRUFBRSxJQUFJLEVBQUUsWUFBWSxFQUE4QixFQUFFLEVBQUUsQ0FDdEcsWUFBWSxHQUFHLENBQUMsSUFBSSxHQUFHLENBQUMsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQW55UXVlcnlDcmVhdG9yLCBRdWVyeUFyZ3NPZiwgUXVlcnlEYXRhT2YgfSBmcm9tICcuLi9xdWVyeS1jcmVhdG9yJztcbmltcG9ydCB7IEluZmluaXR5UXVlcnlDb25maWcsIFBhZ2VQYXJhbUNhbGN1bGF0b3JPcHRpb25zIH0gZnJvbSAnLi9pbmZpbml0eS1xdWVyeS50eXBlcyc7XG5cbmV4cG9ydCBjb25zdCBjcmVhdGVJbmZpbml0eVF1ZXJ5Q29uZmlnID0gPFxuICBRdWVyeUNyZWF0b3IgZXh0ZW5kcyBBbnlRdWVyeUNyZWF0b3IsXG4gIEFyZ3MgZXh0ZW5kcyBRdWVyeUFyZ3NPZjxRdWVyeUNyZWF0b3I+LFxuICBRdWVyeVJlc3BvbnNlIGV4dGVuZHMgUXVlcnlEYXRhT2Y8UXVlcnlDcmVhdG9yPixcbiAgSW5maW5pdHlSZXNwb25zZSBleHRlbmRzIHVua25vd25bXSxcbj4oXG4gIGNvbmZpZzogSW5maW5pdHlRdWVyeUNvbmZpZzxRdWVyeUNyZWF0b3IsIEFyZ3MsIFF1ZXJ5UmVzcG9uc2UsIEluZmluaXR5UmVzcG9uc2U+LFxuKSA9PiBjb25maWc7XG5cbmV4cG9ydCBjb25zdCBza2lwUGFnaW5hdGlvblBhZ2VQYXJhbUNhbGN1bGF0b3IgPSAoeyBwYWdlLCBpdGVtc1BlclBhZ2UgfTogUGFnZVBhcmFtQ2FsY3VsYXRvck9wdGlvbnMpID0+XG4gIGl0ZW1zUGVyUGFnZSAqIChwYWdlIC0gMSk7XG4iXX0=

package/esm2022/lib/logger/index.mjs

@@ -0,0 +1,2 @@
+export * from './logger';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL3F1ZXJ5L3NyYy9saWIvbG9nZ2VyL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsVUFBVSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9sb2dnZXInO1xuIl19

package/esm2022/lib/logger/logger.mjs

@@ -0,0 +1,16 @@
+export const buildErrorMessage = (code, message) => `[@ethlete\\query:${code}] ${message}`;
+export class QueryError extends Error {
+    constructor(code, message, data) {
+        super(buildErrorMessage(code, message));
+        this.name = 'QueryError';
+        this.data = data;
+    }
+}
+export const invalidBaseRouteError = (data) => new QueryError('001', 'The baseRoute must not end with a slash', data);
+export const invalidRouteError = (data) => new QueryError('002', 'The route must start with a slash', data);
+export const pathParamsMissingInRouteFunctionError = (data) => new QueryError('003', 'The route is a function but pathParams are missing', data);
+export const queryStateAlreadyHasKeyError = (data) => new QueryError('004', 'The query state already contains the provided key', data);
+export const queryStateDoesNotContainKeyError = (data) => new QueryError('005', 'The query state does not contain the provided key', data);
+export const queryStateCannotTransformError = (data) => new QueryError('006', 'The query state cannot be transformed because it is not loading', data);
+export const invalidBodyError = (data) => new QueryError('007', 'The body is not valid or upsupported', data);
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/query/index.mjs

@@ -0,0 +1,4 @@
+export * from './query';
+export * from './query.types';
+export * from './query.utils';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL3F1ZXJ5L3NyYy9saWIvcXVlcnkvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxTQUFTLENBQUM7QUFDeEIsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyxlQUFlLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3F1ZXJ5JztcbmV4cG9ydCAqIGZyb20gJy4vcXVlcnkudHlwZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9xdWVyeS51dGlscyc7XG4iXX0=