@c8y/ngx-components
Version:
Angular modules for Cumulocity IoT applications
130 lines • 20.1 kB
JavaScript
import { Injectable } from '@angular/core';
import { FetchClient } from '@c8y/client';
import { Subject, pipe } from 'rxjs';
import { distinctUntilChanged, filter, map, scan, shareReplay } from 'rxjs/operators';
import { HttpInterceptHandler, HttpRequestHandler } from './http-handler.model';
import * as i0 from "@angular/core";
import * as i1 from "@c8y/client";
export class ApiService {
constructor(client) {
this.client = client;
this.callsSubject = new Subject();
this.interceptors = new Map();
this.interceptorCounter = 0;
this.calls = this.callsSubject.asObservable();
this.hookIntoClientFetch();
this.isLoading$ = this.calls.pipe(filter(({ url }) => !/notification\/realtime/.test(url)), map(({ phase }) => (phase === 'start' ? 1 : -1)), scan((count, item) => count + item, 0), map(count => count > 0), distinctUntilChanged(), shareReplay(1));
}
/**
* Allows to hook into the responses received by the FetchClient.
* This is meant to be used to react on the responses, not for manipulation of the responses.
* @param hookFilter A filter function to filter for specific responses.
* @returns An Observable of the filtered responses.
*/
hookResponse(hookFilter) {
return this.callsSubject.pipe(filter(({ phase }) => phase === 'finish'), filter(hookFilter));
}
/**
* Allows to hook into the requests performed by the FetchClient.
* This is meant to be used to react on the requests, not for manipulation of the requests.
* @param hookFilter A filter function to filter for specific requests.
* @returns An Observable of the filtered requests.
*/
hookRequest(hookFilter) {
return this.callsSubject.pipe(filter(({ phase }) => phase === 'start'), filter(hookFilter));
}
onFinish(call) {
this.callsSubject.next({ phase: 'finish', ...call });
}
onStart(call) {
this.callsSubject.next({ phase: 'start', ...call });
}
/**
* Resolves data from an API call response.
* @returns A Promise containing an object with resolved data, method, and URL.
*/
resolveData(call) {
const { response, method, url } = call;
if ('data' in response) {
return Promise.resolve({ data: response.data, method, url });
}
else {
// No Content success status, for example DELETE request.
if (response?.status === 204) {
return Promise.resolve({ data: null, method, url });
}
const cb = data => ({ data, method, url });
return response.clone().json().then(cb, cb);
}
}
/**
* Can be added to a pipe to exclude any permission call. Permission calls are PUT
* request with only an id in it, to verify if the user has access to this managed object.
* @returns The operator to be added to a pipe.
*/
excludePermissionCall() {
return pipe(filter(({ method, options }) => {
if (method === 'PUT' && options.body && typeof options.body === 'string') {
const parsedBody = JSON.parse(options.body);
const bodyKeys = Object.keys(parsedBody);
return !(bodyKeys.length === 1 && bodyKeys[0] === 'id');
}
return true;
}));
}
/**
* Allows to intercept requests performed via the FetchClient requests.
* @param interceptor The interceptor to be added.
* @param id An optional unique identifier for the interceptor. The chain of interceptors is ordered by this id. And it can be used to remove the interceptor later on.
* @returns The id of the interceptor (same as provided id if one was provided, otherwise an id will be generated).
*/
addInterceptor(interceptor, id) {
if (!id) {
id = `${++this.interceptorCounter}`;
}
this.interceptors.set(id, interceptor);
return id;
}
/**
* Allows to remove a previously added interceptor by it's id.
* @param id The id of the interceptor that should be removed.
* @returns true if an interceptor existed and has been removed, or false if id does not exist.
*/
removeInterceptor(id) {
return this.interceptors.delete(id);
}
/**
* Checks if an interceptor with a given id exists.
* @param id The id of the interceptor.
* @returns - Returns true if an interceptor with the given id exists, otherwise false.
*/
hasInterceptor(id) {
return this.interceptors.has(id);
}
hookIntoClientFetch() {
const fetch = this.client.fetch.bind(this.client);
const requestHandler = new HttpRequestHandler(fetch, this);
this.client.fetch = async (url, options = { method: 'GET' }) => {
const { method } = options;
return this.createInterceptorChain({ url, options, method }, requestHandler).toPromise();
};
}
createInterceptorChain(call, requestHandler) {
let handler = requestHandler;
// Do some sorting to always apply the interceptors in the specific order
const sortedInterceptorIds = Array.from(this.interceptors.keys()).sort((a, b) => b.localeCompare(a));
for (const interceptorId of sortedInterceptorIds) {
handler = new HttpInterceptHandler(this.interceptors.get(interceptorId), handler);
}
return handler.handle(call);
}
static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiService, deps: [{ token: i1.FetchClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiService, providedIn: 'root' }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiService, decorators: [{
type: Injectable,
args: [{
providedIn: 'root'
}]
}], ctorParameters: () => [{ type: i1.FetchClient }] });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api.service.js","sourceRoot":"","sources":["../../../api/api.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { FetchClient, IFetchOptions, IFetchResponse } from '@c8y/client';\nimport { MonoTypeOperatorFunction, Observable, Subject, pipe } from 'rxjs';\nimport { distinctUntilChanged, filter, map, scan, shareReplay } from 'rxjs/operators';\nimport { ApiCall, ApiCallOptions } from './api.model';\nimport {\n  HttpInterceptHandler,\n  HttpRequestHandler,\n  RequestStartAndFinish\n} from './http-handler.model';\nimport { HttpHandler, HttpInterceptor } from './interceptor.model';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class ApiService implements RequestStartAndFinish {\n  calls: Observable<ApiCall>;\n  isLoading$: Observable<boolean>;\n  private callsSubject = new Subject<ApiCall>();\n  private interceptors = new Map<string, HttpInterceptor>();\n  private interceptorCounter = 0;\n\n  constructor(private client: FetchClient) {\n    this.calls = this.callsSubject.asObservable();\n    this.hookIntoClientFetch();\n\n    this.isLoading$ = this.calls.pipe(\n      filter(({ url }) => !/notification\\/realtime/.test(url)),\n      map(({ phase }) => (phase === 'start' ? 1 : -1)),\n      scan((count, item) => count + item, 0),\n      map(count => count > 0),\n      distinctUntilChanged(),\n      shareReplay(1)\n    );\n  }\n\n  /**\n   * Allows to hook into the responses received by the FetchClient.\n   * This is meant to be used to react on the responses, not for manipulation of the responses.\n   * @param hookFilter A filter function to filter for specific responses.\n   * @returns An Observable of the filtered responses.\n   */\n  hookResponse(hookFilter: (call: ApiCall) => boolean): Observable<ApiCall> {\n    return this.callsSubject.pipe(\n      filter(({ phase }) => phase === 'finish'),\n      filter(hookFilter)\n    );\n  }\n\n  /**\n   * Allows to hook into the requests performed by the FetchClient.\n   * This is meant to be used to react on the requests, not for manipulation of the requests.\n   * @param hookFilter A filter function to filter for specific requests.\n   * @returns An Observable of the filtered requests.\n   */\n  hookRequest(hookFilter: (call: ApiCall) => boolean): Observable<ApiCall> {\n    return this.callsSubject.pipe(\n      filter(({ phase }) => phase === 'start'),\n      filter(hookFilter)\n    );\n  }\n\n  onFinish(call: ApiCall): void {\n    this.callsSubject.next({ phase: 'finish', ...call });\n  }\n\n  onStart(call: ApiCall): void {\n    this.callsSubject.next({ phase: 'start', ...call });\n  }\n\n  /**\n   * Resolves data from an API call response.\n   * @returns A Promise containing an object with resolved data, method, and URL.\n   */\n  resolveData<T = unknown>(call: ApiCall): Promise<{ data: T; method: string; url: string }> {\n    const { response, method, url } = call;\n    if ('data' in response) {\n      return Promise.resolve({ data: response.data, method, url });\n    } else {\n      // No Content success status, for example DELETE request.\n      if ((response as Response)?.status === 204) {\n        return Promise.resolve({ data: null, method, url });\n      }\n      const cb = data => ({ data, method, url });\n      return (response as Response).clone().json().then(cb, cb);\n    }\n  }\n\n  /**\n   * Can be added to a pipe to exclude any permission call. Permission calls are PUT\n   * request with only an id in it, to verify if the user has access to this managed object.\n   * @returns The operator to be added to a pipe.\n   */\n  excludePermissionCall(): MonoTypeOperatorFunction<ApiCall> {\n    return pipe(\n      filter(({ method, options }) => {\n        if (method === 'PUT' && options.body && typeof options.body === 'string') {\n          const parsedBody = JSON.parse(options.body as string);\n          const bodyKeys = Object.keys(parsedBody);\n          return !(bodyKeys.length === 1 && bodyKeys[0] === 'id');\n        }\n        return true;\n      })\n    );\n  }\n\n  /**\n   * Allows to intercept requests performed via the FetchClient requests.\n   * @param interceptor The interceptor to be added.\n   * @param id An optional unique identifier for the interceptor. The chain of interceptors is ordered by this id. And it can be used to remove the interceptor later on.\n   * @returns The id of the interceptor (same as provided id if one was provided, otherwise an id will be generated).\n   */\n  addInterceptor(interceptor: HttpInterceptor, id?: string): string {\n    if (!id) {\n      id = `${++this.interceptorCounter}`;\n    }\n    this.interceptors.set(id, interceptor);\n    return id;\n  }\n\n  /**\n   * Allows to remove a previously added interceptor by it's id.\n   * @param id The id of the interceptor that should be removed.\n   * @returns true if an interceptor existed and has been removed, or false if id does not exist.\n   */\n  removeInterceptor(id: string): boolean {\n    return this.interceptors.delete(id);\n  }\n\n  /**\n   * Checks if an interceptor with a given id exists.\n   * @param id The id of the interceptor.\n   * @returns - Returns true if an interceptor with the given id exists, otherwise false.\n   */\n  hasInterceptor(id: string): boolean {\n    return this.interceptors.has(id);\n  }\n\n  private hookIntoClientFetch() {\n    const fetch: FetchClient['fetch'] = this.client.fetch.bind(this.client);\n    const requestHandler = new HttpRequestHandler(fetch, this);\n    this.client.fetch = async (\n      url,\n      options: ApiCallOptions & IFetchOptions = { method: 'GET' }\n    ) => {\n      const { method } = options;\n      return this.createInterceptorChain({ url, options, method }, requestHandler).toPromise();\n    };\n  }\n\n  private createInterceptorChain(\n    call: ApiCall,\n    requestHandler: HttpRequestHandler\n  ): Observable<IFetchResponse> {\n    let handler: HttpHandler = requestHandler;\n    // Do some sorting to always apply the interceptors in the specific order\n    const sortedInterceptorIds = Array.from(this.interceptors.keys()).sort((a, b) =>\n      b.localeCompare(a)\n    );\n    for (const interceptorId of sortedInterceptorIds) {\n      handler = new HttpInterceptHandler(this.interceptors.get(interceptorId), handler);\n    }\n    return handler.handle(call);\n  }\n}\n"]}