@idea-ionic/uncommon 8.2.1

package/esm2022/src/AWSAPI.service.mjs

@@ -0,0 +1,430 @@
+import { Injectable, inject } from '@angular/core';
+import { HttpClient, HttpHeaders, HttpParams } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { Platform } from '@ionic/angular';
+import { IDEAEnvironment, IDEAStorageService } from '@idea-ionic/common';
+import { IDEAErrorReportingService } from './errorReporting.service';
+import { IDEATinCanService } from './tinCan.service';
+import { IDEAOfflineService } from './offline/offline.service';
+import * as i0 from "@angular/core";
+/**
+ * To communicate with an AWS's API Gateway istance.
+ *
+ * Includes a rundimental cache on GET requests, until Android doesn't support SWs on local files.
+ *
+ * Note: requires an `AWSAPIAuthToken` variable to be set by IDEATinCanService service.
+ */
+export class IDEAAWSAPIService {
+    constructor() {
+        this._env = inject(IDEAEnvironment);
+        this._http = inject(HttpClient);
+        this._platform = inject(Platform);
+        this._tc = inject(IDEATinCanService);
+        this._storage = inject(IDEAStorageService);
+        this._errorReporting = inject(IDEAErrorReportingService);
+        this._offline = inject(IDEAOfflineService);
+        this.apiStage = this._env.idea.api?.stage || this._env.idea.api?.version;
+        this.apiUrlProject = 'https://'.concat([this._env.idea.api?.url, this.apiStage].filter(x => x).join('/'));
+        this.ideaApiStage = this._env.idea.ideaApi?.stage || this._env.idea.ideaApi?.version;
+        this.apiUrlIDEA = 'https://'.concat([this._env.idea.ideaApi?.url, this.ideaApiStage].filter(x => x).join('/'));
+    }
+    /**
+     * Execute an online API request.
+     * @param resource resource name (e.g. `users`)
+     * @param method enum HTTP methods
+     * @param options the request options
+     */
+    request(resource, method, options) {
+        return new Promise((resolve, reject) => {
+            const opt = options || {};
+            // prepare the url
+            const url = this.prepareURL(resource, opt);
+            // prepare the headers and set the Authorization token
+            const headers = this.prepareHeaders(opt.headers);
+            // prepare the query params and add some info about the client
+            const params = this.prepareQueryParams(opt.params, true);
+            // execute the request
+            let req;
+            switch (method) {
+                case 'HEAD':
+                    req = this._http.head(url, { headers, params });
+                    break;
+                case 'POST':
+                    req = this._http.post(url, opt.body, { headers, params });
+                    break;
+                case 'PUT':
+                    req = this._http.put(url, opt.body, { headers, params });
+                    break;
+                case 'PATCH':
+                    req = this._http.patch(url, opt.body, { headers, params });
+                    break;
+                case 'DELETE':
+                    req = this._http.delete(url, { headers, params });
+                    break;
+                case 'GET':
+                default:
+                    req = this._http.get(url, { headers, params });
+            }
+            // handle the request response
+            req.subscribe((res) => resolve(res), async (err) => {
+                // check if the request failed for network reasons (to trigger offline mode if needed)
+                await this._offline.check();
+                // (async) send a report, if wanted
+                if (opt.reportError)
+                    this._errorReporting.sendReport(err);
+                // fix and return the error
+                this.fixErrMessageBeforeReject(err, reject);
+            });
+        });
+    }
+    /**
+     * Prepare the URL to which execute the request.
+     */
+    prepareURL(resource, opt) {
+        // decide whether to use IDEA's API or the project's API (or an alternative API)
+        let url = opt.idea ? this.apiUrlIDEA : opt.alternativeAPI || this.apiUrlProject;
+        // prepare a single-resource request (by id) or a normal one
+        url = `${url}/${resource}`;
+        if (opt.resourceId)
+            url = `${url}/${encodeURIComponent(opt.resourceId)}`;
+        return url;
+    }
+    /**
+     * Prepare the headers object to send with a request.
+     * Note: it always adds the Authorization token (`AWSAPIAuthToken`) and the API key (`AWSAPIKey`), if set.
+     */
+    prepareHeaders(h) {
+        // preare the headers; note: HttpHeaders is immutable!
+        let headers = new HttpHeaders(h || null);
+        // set the Authorization token
+        if (!headers.get('Authorization') && this._tc.get('AWSAPIAuthToken'))
+            headers = headers.set('Authorization', this._tc.get('AWSAPIAuthToken'));
+        // set the API key
+        if (!headers.get('X-API-Key') && this._tc.get('AWSAPIKey'))
+            headers = headers.set('X-API-Key', this._tc.get('AWSAPIKey'));
+        return headers;
+    }
+    /**
+     * Prepare the queryParams object to send with a request; if requested, add some info about the client.
+     */
+    prepareQueryParams(qp, addClientInfo) {
+        // prepare the query params; note: HttpParams is immutable!
+        let searchParams = new HttpParams();
+        if (qp && qp instanceof HttpParams)
+            searchParams = qp;
+        else if (qp)
+            for (const prop in qp)
+                if (qp[prop])
+                    searchParams = searchParams.set(prop, qp[prop]);
+        // if requested, add app version and client platform to the info we send to the back-end
+        if (addClientInfo) {
+            searchParams = searchParams.set('_v', this._env.idea.app.version);
+            searchParams = searchParams.set('_p', this._platform.platforms().join(' '));
+        }
+        return searchParams;
+    }
+    /**
+     * Converts the error message to be readable.
+     */
+    fixErrMessageBeforeReject(err, reject) {
+        let e;
+        try {
+            if (!err || !err.error)
+                e = {};
+            else if (typeof err.error === 'string')
+                e = JSON.parse(err.error);
+            else
+                e = err.error;
+        }
+        catch (_) {
+            e = {};
+        }
+        reject(new Error(e.message || 'Unknown error!'));
+    }
+    /**
+     * Use the HttpClient to execute a raw request.
+     */
+    rawRequest() {
+        return this._http;
+    }
+    /**
+     * HEAD request.
+     * @param resource resource name (e.g. `users`)
+     * @param options the request options
+     */
+    headResource(resource, options) {
+        return this.request(resource, 'HEAD', options);
+    }
+    /**
+     * GET request. Include options to cache the requests (`options.useCache`), to work also offline.
+     * @param resource resource name (e.g. `users`)
+     * @param options the request options
+     */
+    getResource(resource, options) {
+        return new Promise((resolve, reject) => {
+            const opt = options || {};
+            // if offline and with a cache mode set, force the request to the cache
+            if (!navigator.onLine && opt.useCache)
+                opt.useCache = CacheModes.CACHE_ONLY;
+            // execute the GET request online or through the cache, depending on the chosen mode
+            switch (opt.useCache) {
+                case CacheModes.CACHE_ONLY:
+                    // return the result from the cache, without retrying online if a result wasn't found
+                    this.getFromCache(resource, opt).then((res) => {
+                        if (res)
+                            resolve(res);
+                        else
+                            reject();
+                    });
+                    break;
+                case CacheModes.CACHE_FIRST:
+                    // return the result from the cache
+                    this.getFromCache(resource, opt).then((localRes) => {
+                        // check whether the local resource is present (element or list)
+                        if (localRes && (opt.resourceId || localRes.length)) {
+                            resolve(localRes);
+                            // asynchrounously execute the request online, to update the cache with latest data
+                            this.request(resource, 'GET', opt)
+                                .then((cloudRes) => {
+                                // update the cache (if it fails, it's ok)
+                                this.putInCache(resource, cloudRes, opt).catch(() => { });
+                            })
+                                .catch(() => { }); // we already returned the result, an error is acceptable
+                        }
+                        else {
+                            // if the result isn't found in the cache, return the result of the online request
+                            this.request(resource, 'GET', opt)
+                                .then((res) => {
+                                resolve(res);
+                                // update the cache (if it fails, it's ok)
+                                this.putInCache(resource, res, opt).catch(() => { });
+                            })
+                                .catch((err) => reject(err)); // element not found
+                        }
+                    });
+                    break;
+                case CacheModes.NETWORK_FIRST:
+                    // return the result from an online request
+                    this.request(resource, 'GET', opt)
+                        .then((cloudRes) => {
+                        resolve(cloudRes);
+                        // asynchrounously get the same element from cache and decide whether to update or not
+                        this.getFromCache(resource, opt).then(() => {
+                            // update the cache (if it fails, it's ok)
+                            this.putInCache(resource, cloudRes, opt).catch(() => { });
+                        });
+                    })
+                        .catch(() => {
+                        // if a request to the network fails, check in cache
+                        this.getFromCache(resource, opt).then((res) => {
+                            if (res)
+                                resolve(res);
+                            else
+                                reject();
+                        });
+                    });
+                    break;
+                default:
+                    /* CacheModes.NO_CACHE */
+                    // return the result from an online request, with no cache involved
+                    this.request(resource, 'GET', opt)
+                        .then((res) => resolve(res))
+                        .catch((err) => reject(err));
+            }
+        });
+    }
+    /**
+     * Observe a GET request. Include options to cache the requests (`options.useCache`), to work also offline.
+     * @param resource resource name (e.g. `users`)
+     * @param options the request options
+     */
+    getResourceObserver(resource, options) {
+        return new Observable(observer => {
+            const opt = options || {};
+            // if offline and with a cache mode set, force the request to the cache
+            if (!navigator.onLine && opt.useCache)
+                opt.useCache = CacheModes.CACHE_ONLY;
+            // execute the GET request online or through the cache, depending on the chosen mode
+            switch (opt.useCache) {
+                case CacheModes.CACHE_ONLY:
+                    // return the result from the cache, without retrying online if a result wasn't found
+                    this.getFromCache(resource, opt).then((res) => {
+                        if (res)
+                            observer.next(res);
+                        else
+                            observer.error();
+                    });
+                    break;
+                case CacheModes.CACHE_FIRST:
+                    // return the result from the cache
+                    this.getFromCache(resource, opt).then((localRes) => {
+                        if (localRes) {
+                            observer.next(localRes);
+                            // asynchrounously execute the request online, to update the cache with latest data
+                            this.request(resource, 'GET', opt)
+                                .then((cloudRes) => {
+                                observer.next(cloudRes);
+                                // update the cache (if it fails, it's ok)
+                                this.putInCache(resource, cloudRes, opt).catch(() => { });
+                            })
+                                .catch(() => { }); // we already returned the result, an error is acceptable
+                        }
+                        else {
+                            // if the result isn't found in the cache, return the result of the online request
+                            this.request(resource, 'GET', opt)
+                                .then((res) => {
+                                observer.next(res);
+                                // update the cache (if it fails, it's ok)
+                                this.putInCache(resource, res, opt).catch(() => { });
+                            })
+                                .catch((err) => observer.error(err)); // element not found
+                        }
+                    });
+                    break;
+                case CacheModes.NETWORK_FIRST:
+                    // return the result from an online request
+                    this.request(resource, 'GET', opt)
+                        .then((cloudRes) => {
+                        observer.next(cloudRes);
+                        // update the cache (if it fails, it's ok)
+                        this.putInCache(resource, cloudRes, opt).catch(() => { });
+                    })
+                        .catch(() => {
+                        // if a request to the network fails, check in cache
+                        this.getFromCache(resource, opt).then((res) => {
+                            if (res)
+                                observer.next(res);
+                            else
+                                observer.error();
+                        });
+                    });
+                    break;
+                default:
+                    /* CacheModes.NO_CACHE */
+                    // return the result from an online request, with no cache involved
+                    this.request(resource, 'GET', opt)
+                        .then((res) => observer.next(res))
+                        .catch((err) => observer.error(err));
+            }
+        });
+    }
+    /**
+     * Execute a GET request from the local storage.
+     * @param resource resource name (e.g. `users`)
+     * @param options the request options
+     */
+    getFromCache(resource, options) {
+        return new Promise(resolve => {
+            const opt = options || {};
+            // prepare the url and the query params
+            const url = this.prepareURL(resource, opt);
+            const queryParams = this.prepareQueryParams(opt.params);
+            // get from storage, by the complete url
+            this._storage
+                .get(url.concat(queryParams.toString()))
+                .then((res) => (res ? resolve(res) : opt.resourceId ? resolve(null) : resolve([])));
+        });
+    }
+    /**
+     * Execute a PUT request in the local storage.
+     * @param resource resource name (e.g. `users`)
+     * @param data resource data
+     * @param options the request options
+     */
+    putInCache(resource, data, options) {
+        return new Promise((resolve, reject) => {
+            const opt = options || {};
+            // prepare the url and the query params
+            const url = this.prepareURL(resource, opt);
+            const queryParams = this.prepareQueryParams(opt.params);
+            // put in the storage, by the complete url
+            this._storage
+                .set(url.concat(queryParams.toString()), data)
+                .then(() => resolve())
+                .catch((err) => reject(err));
+        });
+    }
+    /**
+     * Execute a DELETE request in the local storage.
+     * @param resource resource name (e.g. `users`)
+     * @param options the request options
+     */
+    deleteFromCache(resource, options) {
+        return new Promise((resolve, reject) => {
+            const opt = options || {};
+            // prepare the url and the query params
+            const url = this.prepareURL(resource, opt);
+            const queryParams = this.prepareQueryParams(opt.params);
+            // delete from storage, by the complete url
+            this._storage
+                .remove(url.concat(queryParams.toString()))
+                .then(() => resolve())
+                .catch((err) => reject(err));
+        });
+    }
+    /**
+     * POST request.
+     * @param resource resource name (e.g. `users`)
+     * @param options the request options
+     */
+    postResource(resource, options) {
+        return this.request(resource, 'POST', options);
+    }
+    /**
+     * PUT request.
+     * @param resource resource name (e.g. `users`)
+     * @param options the request options
+     */
+    putResource(resource, options) {
+        return this.request(resource, 'PUT', options);
+    }
+    /**
+     * PATCH request.
+     * @param resource resource name (e.g. `users`)
+     * @param options the request options
+     */
+    patchResource(resource, options) {
+        return this.request(resource, 'PATCH', options);
+    }
+    /**
+     * DELETE request.
+     * @param resource resource name (e.g. `users`)
+     * @param options the request options
+     */
+    deleteResource(resource, options) {
+        return this.request(resource, 'DELETE', options);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IDEAAWSAPIService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IDEAAWSAPIService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IDEAAWSAPIService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+/**
+ * The options of an API request.
+ */
+export class APIRequestOption {
+}
+/**
+ * Set of usable cache modes.
+ */
+export var CacheModes;
+(function (CacheModes) {
+    /**
+     * Return the result from an online request, with no cache involved.
+     */
+    CacheModes[CacheModes["NO_CACHE"] = 0] = "NO_CACHE";
+    /**
+     * Return the result from an online request, storing the result in the cache, to update it with the latest data.
+     */
+    CacheModes[CacheModes["NETWORK_FIRST"] = 1] = "NETWORK_FIRST";
+    /**
+     * Return the result from the cache, but also execute the request online, to update the cache with the latest data.
+     */
+    CacheModes[CacheModes["CACHE_FIRST"] = 2] = "CACHE_FIRST";
+    /**
+     * Return the result from the cache, without retrying online if a result wasn't found.
+     */
+    CacheModes[CacheModes["CACHE_ONLY"] = 3] = "CACHE_ONLY";
+})(CacheModes || (CacheModes = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"AWSAPI.service.js","sourceRoot":"","sources":["../../../../modules/uncommon/src/AWSAPI.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject } from '@angular/core';\nimport { HttpClient, HttpHeaders, HttpParams, HttpErrorResponse } from '@angular/common/http';\nimport { Observable } from 'rxjs';\nimport { Platform } from '@ionic/angular';\nimport { IDEAEnvironment, IDEAStorageService } from '@idea-ionic/common';\n\nimport { IDEAErrorReportingService } from './errorReporting.service';\nimport { IDEATinCanService } from './tinCan.service';\nimport { IDEAOfflineService } from './offline/offline.service';\n\n/**\n * To communicate with an AWS's API Gateway istance.\n *\n * Includes a rundimental cache on GET requests, until Android doesn't support SWs on local files.\n *\n * Note: requires an `AWSAPIAuthToken` variable to be set by IDEATinCanService service.\n */\n@Injectable()\nexport class IDEAAWSAPIService {\n  protected _env = inject(IDEAEnvironment);\n  protected _http = inject(HttpClient);\n  protected _platform = inject(Platform);\n  protected _tc = inject(IDEATinCanService);\n  protected _storage = inject(IDEAStorageService);\n  protected _errorReporting = inject(IDEAErrorReportingService);\n  protected _offline = inject(IDEAOfflineService);\n\n  apiStage: string;\n  apiUrlProject: string;\n  ideaApiStage: string;\n  apiUrlIDEA: string;\n\n  constructor() {\n    this.apiStage = this._env.idea.api?.stage || (this._env.idea.api as any)?.version;\n    this.apiUrlProject = 'https://'.concat([this._env.idea.api?.url, this.apiStage].filter(x => x).join('/'));\n    this.ideaApiStage = this._env.idea.ideaApi?.stage || (this._env.idea.ideaApi as any)?.version;\n    this.apiUrlIDEA = 'https://'.concat([this._env.idea.ideaApi?.url, this.ideaApiStage].filter(x => x).join('/'));\n  }\n\n  /**\n   * Execute an online API request.\n   * @param resource resource name (e.g. `users`)\n   * @param method enum HTTP methods\n   * @param options the request options\n   */\n  protected request(resource: string, method: string, options?: APIRequestOption): Promise<any> {\n    return new Promise((resolve, reject) => {\n      const opt = options || {};\n      // prepare the url\n      const url = this.prepareURL(resource, opt);\n      // prepare the headers and set the Authorization token\n      const headers = this.prepareHeaders(opt.headers);\n      // prepare the query params and add some info about the client\n      const params = this.prepareQueryParams(opt.params, true);\n      // execute the request\n      let req: any;\n      switch (method) {\n        case 'HEAD':\n          req = this._http.head(url, { headers, params });\n          break;\n        case 'POST':\n          req = this._http.post(url, opt.body, { headers, params });\n          break;\n        case 'PUT':\n          req = this._http.put(url, opt.body, { headers, params });\n          break;\n        case 'PATCH':\n          req = this._http.patch(url, opt.body, { headers, params });\n          break;\n        case 'DELETE':\n          req = this._http.delete(url, { headers, params });\n          break;\n        case 'GET':\n        default:\n          req = this._http.get(url, { headers, params });\n      }\n      // handle the request response\n      req.subscribe(\n        (res: any) => resolve(res),\n        async (err: HttpErrorResponse) => {\n          // check if the request failed for network reasons (to trigger offline mode if needed)\n          await this._offline.check();\n          // (async) send a report, if wanted\n          if (opt.reportError) this._errorReporting.sendReport(err);\n          // fix and return the error\n          this.fixErrMessageBeforeReject(err, reject);\n        }\n      );\n    });\n  }\n  /**\n   * Prepare the URL to which execute the request.\n   */\n  protected prepareURL(resource: string, opt: APIRequestOption): string {\n    // decide whether to use IDEA's API or the project's API (or an alternative API)\n    let url = opt.idea ? this.apiUrlIDEA : opt.alternativeAPI || this.apiUrlProject;\n    // prepare a single-resource request (by id) or a normal one\n    url = `${url}/${resource}`;\n    if (opt.resourceId) url = `${url}/${encodeURIComponent(opt.resourceId)}`;\n    return url;\n  }\n  /**\n   * Prepare the headers object to send with a request.\n   * Note: it always adds the Authorization token (`AWSAPIAuthToken`) and the API key (`AWSAPIKey`), if set.\n   */\n  protected prepareHeaders(h: HttpHeaders | any): HttpHeaders {\n    // preare the headers; note: HttpHeaders is immutable!\n    let headers = new HttpHeaders(h || null);\n    // set the Authorization token\n    if (!headers.get('Authorization') && this._tc.get('AWSAPIAuthToken'))\n      headers = headers.set('Authorization', this._tc.get('AWSAPIAuthToken'));\n    // set the API key\n    if (!headers.get('X-API-Key') && this._tc.get('AWSAPIKey'))\n      headers = headers.set('X-API-Key', this._tc.get('AWSAPIKey'));\n    return headers;\n  }\n  /**\n   * Prepare the queryParams object to send with a request; if requested, add some info about the client.\n   */\n  protected prepareQueryParams(qp: HttpParams | any, addClientInfo?: boolean): HttpParams {\n    // prepare the query params; note: HttpParams is immutable!\n    let searchParams = new HttpParams();\n    if (qp && qp instanceof HttpParams) searchParams = qp;\n    else if (qp) for (const prop in qp) if (qp[prop]) searchParams = searchParams.set(prop, qp[prop]);\n    // if requested, add app version and client platform to the info we send to the back-end\n    if (addClientInfo) {\n      searchParams = searchParams.set('_v', this._env.idea.app.version);\n      searchParams = searchParams.set('_p', this._platform.platforms().join(' '));\n    }\n    return searchParams;\n  }\n  /**\n   * Converts the error message to be readable.\n   */\n  protected fixErrMessageBeforeReject(err: HttpErrorResponse, reject: any) {\n    let e;\n    try {\n      if (!err || !err.error) e = {};\n      else if (typeof err.error === 'string') e = JSON.parse(err.error);\n      else e = err.error;\n    } catch (_) {\n      e = {};\n    }\n    reject(new Error(e.message || 'Unknown error!'));\n  }\n\n  /**\n   * Use the HttpClient to execute a raw request.\n   */\n  rawRequest(): HttpClient {\n    return this._http;\n  }\n\n  /**\n   * HEAD request.\n   * @param resource resource name (e.g. `users`)\n   * @param options the request options\n   */\n  headResource(resource: string, options?: APIRequestOption): Promise<any> {\n    return this.request(resource, 'HEAD', options);\n  }\n\n  /**\n   * GET request. Include options to cache the requests (`options.useCache`), to work also offline.\n   * @param resource resource name (e.g. `users`)\n   * @param options the request options\n   */\n  getResource(resource: string, options?: APIRequestOption): Promise<any> {\n    return new Promise((resolve, reject) => {\n      const opt = options || {};\n      // if offline and with a cache mode set, force the request to the cache\n      if (!navigator.onLine && opt.useCache) opt.useCache = CacheModes.CACHE_ONLY;\n      // execute the GET request online or through the cache, depending on the chosen mode\n      switch (opt.useCache) {\n        case CacheModes.CACHE_ONLY:\n          // return the result from the cache, without retrying online if a result wasn't found\n          this.getFromCache(resource, opt).then((res: any) => {\n            if (res) resolve(res);\n            else reject();\n          });\n          break;\n        case CacheModes.CACHE_FIRST:\n          // return the result from the cache\n          this.getFromCache(resource, opt).then((localRes: any) => {\n            // check whether the local resource is present (element or list)\n            if (localRes && (opt.resourceId || localRes.length)) {\n              resolve(localRes);\n              // asynchrounously execute the request online, to update the cache with latest data\n              this.request(resource, 'GET', opt)\n                .then((cloudRes: any) => {\n                  // update the cache (if it fails, it's ok)\n                  this.putInCache(resource, cloudRes, opt).catch(() => {});\n                })\n                .catch(() => {}); // we already returned the result, an error is acceptable\n            } else {\n              // if the result isn't found in the cache, return the result of the online request\n              this.request(resource, 'GET', opt)\n                .then((res: any) => {\n                  resolve(res);\n                  // update the cache (if it fails, it's ok)\n                  this.putInCache(resource, res, opt).catch(() => {});\n                })\n                .catch((err: Error) => reject(err)); // element not found\n            }\n          });\n          break;\n        case CacheModes.NETWORK_FIRST:\n          // return the result from an online request\n          this.request(resource, 'GET', opt)\n            .then((cloudRes: any) => {\n              resolve(cloudRes);\n              // asynchrounously get the same element from cache and decide whether to update or not\n              this.getFromCache(resource, opt).then(() => {\n                // update the cache (if it fails, it's ok)\n                this.putInCache(resource, cloudRes, opt).catch(() => {});\n              });\n            })\n            .catch(() => {\n              // if a request to the network fails, check in cache\n              this.getFromCache(resource, opt).then((res: any) => {\n                if (res) resolve(res);\n                else reject();\n              });\n            });\n          break;\n        default:\n          /* CacheModes.NO_CACHE */\n          // return the result from an online request, with no cache involved\n          this.request(resource, 'GET', opt)\n            .then((res: any) => resolve(res))\n            .catch((err: Error) => reject(err));\n      }\n    });\n  }\n\n  /**\n   * Observe a GET request. Include options to cache the requests (`options.useCache`), to work also offline.\n   * @param resource resource name (e.g. `users`)\n   * @param options the request options\n   */\n  getResourceObserver(resource: string, options?: APIRequestOption): Observable<any> {\n    return new Observable(observer => {\n      const opt = options || {};\n      // if offline and with a cache mode set, force the request to the cache\n      if (!navigator.onLine && opt.useCache) opt.useCache = CacheModes.CACHE_ONLY;\n      // execute the GET request online or through the cache, depending on the chosen mode\n      switch (opt.useCache) {\n        case CacheModes.CACHE_ONLY:\n          // return the result from the cache, without retrying online if a result wasn't found\n          this.getFromCache(resource, opt).then((res: any) => {\n            if (res) observer.next(res);\n            else observer.error();\n          });\n          break;\n        case CacheModes.CACHE_FIRST:\n          // return the result from the cache\n          this.getFromCache(resource, opt).then((localRes: any) => {\n            if (localRes) {\n              observer.next(localRes);\n              // asynchrounously execute the request online, to update the cache with latest data\n              this.request(resource, 'GET', opt)\n                .then((cloudRes: any) => {\n                  observer.next(cloudRes);\n                  // update the cache (if it fails, it's ok)\n                  this.putInCache(resource, cloudRes, opt).catch(() => {});\n                })\n                .catch(() => {}); // we already returned the result, an error is acceptable\n            } else {\n              // if the result isn't found in the cache, return the result of the online request\n              this.request(resource, 'GET', opt)\n                .then((res: any) => {\n                  observer.next(res);\n                  // update the cache (if it fails, it's ok)\n                  this.putInCache(resource, res, opt).catch(() => {});\n                })\n                .catch((err: Error) => observer.error(err)); // element not found\n            }\n          });\n          break;\n        case CacheModes.NETWORK_FIRST:\n          // return the result from an online request\n          this.request(resource, 'GET', opt)\n            .then((cloudRes: any) => {\n              observer.next(cloudRes);\n              // update the cache (if it fails, it's ok)\n              this.putInCache(resource, cloudRes, opt).catch(() => {});\n            })\n            .catch(() => {\n              // if a request to the network fails, check in cache\n              this.getFromCache(resource, opt).then((res: any) => {\n                if (res) observer.next(res);\n                else observer.error();\n              });\n            });\n          break;\n        default:\n          /* CacheModes.NO_CACHE */\n          // return the result from an online request, with no cache involved\n          this.request(resource, 'GET', opt)\n            .then((res: any) => observer.next(res))\n            .catch((err: Error) => observer.error(err));\n      }\n    });\n  }\n\n  /**\n   * Execute a GET request from the local storage.\n   * @param resource resource name (e.g. `users`)\n   * @param options the request options\n   */\n  getFromCache(resource: string, options?: APIRequestOption): Promise<any> {\n    return new Promise(resolve => {\n      const opt = options || {};\n      // prepare the url and the query params\n      const url = this.prepareURL(resource, opt);\n      const queryParams = this.prepareQueryParams(opt.params);\n      // get from storage, by the complete url\n      this._storage\n        .get(url.concat(queryParams.toString()))\n        .then((res: any) => (res ? resolve(res) : opt.resourceId ? resolve(null) : resolve([])));\n    });\n  }\n  /**\n   * Execute a PUT request in the local storage.\n   * @param resource resource name (e.g. `users`)\n   * @param data resource data\n   * @param options the request options\n   */\n  putInCache(resource: string, data: any, options?: APIRequestOption): Promise<void> {\n    return new Promise((resolve, reject) => {\n      const opt = options || {};\n      // prepare the url and the query params\n      const url = this.prepareURL(resource, opt);\n      const queryParams = this.prepareQueryParams(opt.params);\n      // put in the storage, by the complete url\n      this._storage\n        .set(url.concat(queryParams.toString()), data)\n        .then(() => resolve())\n        .catch((err: Error) => reject(err));\n    });\n  }\n  /**\n   * Execute a DELETE request in the local storage.\n   * @param resource resource name (e.g. `users`)\n   * @param options the request options\n   */\n  deleteFromCache(resource: string, options?: APIRequestOption): Promise<void> {\n    return new Promise((resolve, reject) => {\n      const opt = options || {};\n      // prepare the url and the query params\n      const url = this.prepareURL(resource, opt);\n      const queryParams = this.prepareQueryParams(opt.params);\n      // delete from storage, by the complete url\n      this._storage\n        .remove(url.concat(queryParams.toString()))\n        .then(() => resolve())\n        .catch((err: Error) => reject(err));\n    });\n  }\n\n  /**\n   * POST request.\n   * @param resource resource name (e.g. `users`)\n   * @param options the request options\n   */\n  postResource(resource: string, options?: APIRequestOption): Promise<any> {\n    return this.request(resource, 'POST', options);\n  }\n\n  /**\n   * PUT request.\n   * @param resource resource name (e.g. `users`)\n   * @param options the request options\n   */\n  putResource(resource: string, options?: APIRequestOption): Promise<any> {\n    return this.request(resource, 'PUT', options);\n  }\n\n  /**\n   * PATCH request.\n   * @param resource resource name (e.g. `users`)\n   * @param options the request options\n   */\n  patchResource(resource: string, options?: APIRequestOption): Promise<any> {\n    return this.request(resource, 'PATCH', options);\n  }\n\n  /**\n   * DELETE request.\n   * @param resource resource name (e.g. `users`)\n   * @param options the request options\n   */\n  deleteResource(resource: string, options?: APIRequestOption): Promise<any> {\n    return this.request(resource, 'DELETE', options);\n  }\n}\n\n/**\n * The options of an API request.\n */\nexport class APIRequestOption {\n  /**\n   * To identify a specific resource by id.\n   */\n  resourceId?: string;\n  /**\n   * The query parameters of the request.\n   */\n  params?: any;\n  /**\n   * The body of the request.\n   */\n  body?: any;\n  /**\n   * The additional headers of the request; `Authorization` is included by default.\n   */\n  headers?: any;\n  /**\n   * Which mode to use to take advance of the requests caching mechanism.\n   */\n  useCache?: CacheModes;\n  /**\n   * If true, report the errors that occurs during the request.\n   */\n  reportError?: boolean;\n  /**\n   * If true, use IDEA's API instead of the project's API).\n   */\n  idea?: boolean;\n  /**\n   * If `idea` is not set, set this to use an alternative API URL for the request.\n   */\n  alternativeAPI?: string;\n}\n\n/**\n * Set of usable cache modes.\n */\nexport enum CacheModes {\n  /**\n   * Return the result from an online request, with no cache involved.\n   */\n  NO_CACHE = 0,\n  /**\n   * Return the result from an online request, storing the result in the cache, to update it with the latest data.\n   */\n  NETWORK_FIRST,\n  /**\n   * Return the result from the cache, but also execute the request online, to update the cache with the latest data.\n   */\n  CACHE_FIRST,\n  /**\n   * Return the result from the cache, without retrying online if a result wasn't found.\n   */\n  CACHE_ONLY\n}\n"]}