getta 0.4.6 → 1.0.0

package/lib/main/main.js

@@ -1,580 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.createRestClient = exports.Getta = void 0;
-
-require("core-js/modules/es.promise.js");
-
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
-var _merge2 = _interopRequireDefault(require("lodash/merge"));
-
-var _castArray2 = _interopRequireDefault(require("lodash/castArray"));
-
-var _md = _interopRequireDefault(require("md5"));
-
-var _constants = require("./constants");
-
-var _buildEndpoint = _interopRequireDefault(require("./helpers/build-endpoint"));
-
-var _defaultPathTemplateCallback = _interopRequireDefault(require("./helpers/default-path-template-callback"));
-
-var _delay = _interopRequireDefault(require("./helpers/delay"));
-
-var _getResponseGroup = _interopRequireDefault(require("./helpers/get-response-group"));
-
-var _isCacheabilityValid = _interopRequireDefault(require("./helpers/is-cacheability-valid"));
-
-class Getta {
-  constructor(options) {
-    (0, _defineProperty2.default)(this, "_basePath", void 0);
-    (0, _defineProperty2.default)(this, "_bodyParser", void 0);
-    (0, _defineProperty2.default)(this, "_cache", void 0);
-    (0, _defineProperty2.default)(this, "_conditionalRequestsEnabled", void 0);
-    (0, _defineProperty2.default)(this, "_fetchTimeout", void 0);
-    (0, _defineProperty2.default)(this, "_headers", void 0);
-    (0, _defineProperty2.default)(this, "_log", void 0);
-    (0, _defineProperty2.default)(this, "_maxRedirects", void 0);
-    (0, _defineProperty2.default)(this, "_maxRetries", void 0);
-    (0, _defineProperty2.default)(this, "_optionalPathTemplateRegExp", void 0);
-    (0, _defineProperty2.default)(this, "_pathTemplateCallback", void 0);
-    (0, _defineProperty2.default)(this, "_pathTemplateRegExp", void 0);
-    (0, _defineProperty2.default)(this, "_performance", void 0);
-    (0, _defineProperty2.default)(this, "_queryParams", void 0);
-    (0, _defineProperty2.default)(this, "_rateLimitCount", 0);
-    (0, _defineProperty2.default)(this, "_rateLimitedRequestQueue", []);
-    (0, _defineProperty2.default)(this, "_rateLimitPerSecond", void 0);
-    (0, _defineProperty2.default)(this, "_rateLimitTimer", null);
-    (0, _defineProperty2.default)(this, "_requestRetryWait", void 0);
-    (0, _defineProperty2.default)(this, "_requestTracker", {
-      active: [],
-      pending: new Map()
-    });
-    (0, _defineProperty2.default)(this, "_streamReader", void 0);
-    const {
-      basePath,
-      bodyParser = _constants.DEFAULT_BODY_PARSER,
-      cache,
-      enableConditionalRequests = true,
-      fetchTimeout = _constants.DEFAULT_FETCH_TIMEOUT,
-      headers,
-      log,
-      maxRedirects = _constants.DEFAULT_MAX_REDIRECTS,
-      maxRetries = _constants.DEFAULT_MAX_RETRIES,
-      optionalPathTemplateRegExp = _constants.OPTIONAL_PATH_TEMPLATE_REGEX,
-      pathTemplateCallback = _defaultPathTemplateCallback.default,
-      pathTemplateRegExp = _constants.DEFAULT_PATH_TEMPLATE_REGEX,
-      performance,
-      queryParams = {},
-      rateLimitPerSecond = _constants.DEFAULT_RATE_LIMIT,
-      requestRetryWait = _constants.DEFAULT_REQUEST_RETRY_WAIT,
-      streamReader = _constants.JSON_FORMAT
-    } = options;
-
-    if (!basePath) {
-      throw new Error(_constants.MISSING_BASE_PATH_ERROR);
-    }
-
-    this._basePath = basePath;
-    this._bodyParser = bodyParser;
-    this._cache = cache;
-    this._conditionalRequestsEnabled = enableConditionalRequests;
-    this._fetchTimeout = fetchTimeout;
-    this._headers = { ..._constants.DEFAULT_HEADERS,
-      ...(headers || {})
-    };
-    this._log = log;
-    this._maxRedirects = maxRedirects;
-    this._maxRetries = maxRetries;
-    this._optionalPathTemplateRegExp = optionalPathTemplateRegExp;
-    this._pathTemplateCallback = pathTemplateCallback;
-    this._pathTemplateRegExp = pathTemplateRegExp;
-    this._performance = performance;
-    this._queryParams = queryParams;
-    this._rateLimitPerSecond = rateLimitPerSecond;
-    this._requestRetryWait = requestRetryWait;
-    this._streamReader = streamReader;
-  }
-
-  get cache() {
-    return this._cache;
-  }
-
-  createShortcut(name, path, {
-    method,
-    ...otherOptions
-  }) {
-    if (!_constants.FETCH_METHODS.includes(method)) {
-      throw new Error(`${_constants.INVALID_FETCH_METHOD_ERROR} ${method}`);
-    }
-
-    this[name] = async ({
-      method: requestMethod,
-      ...otherOptionOverrides
-    } = {}, context) => this[requestMethod !== null && requestMethod !== void 0 ? requestMethod : method](path, (0, _merge2.default)({}, otherOptions, otherOptionOverrides), context);
-  }
-
-  async delete(path, options = {}, context) {
-    return this._delete(path, options, context);
-  }
-
-  async get(path, options = {}, context) {
-    return this._get(path, options, context);
-  }
-
-  async post(path, options, context) {
-    return this._request(path, { ...options,
-      method: _constants.POST_METHOD
-    }, context);
-  }
-
-  async put(path, options, context) {
-    return this._request(path, { ...options,
-      method: _constants.PUT_METHOD
-    }, context);
-  }
-
-  _addRequestToRateLimitedQueue(endpoint, options, context) {
-    return new Promise(resolve => {
-      this._rateLimitedRequestQueue.push([resolve, endpoint, options, context]);
-    });
-  }
-
-  async _cacheEntryDelete(requestHash) {
-    if (!this._cache) return false;
-
-    try {
-      return await this._cache.delete(requestHash);
-    } catch (errors) {
-      return Promise.reject(errors);
-    }
-  }
-
-  async _cacheEntryGet(requestHash) {
-    if (!this._cache) return undefined;
-
-    try {
-      return await this._cache.get(requestHash);
-    } catch (errors) {
-      return Promise.reject(errors);
-    }
-  }
-
-  async _cacheEntryHas(requestHash) {
-    if (!this._cache) return false;
-
-    try {
-      return await this._cache.has(requestHash);
-    } catch (error) {
-      return false;
-    }
-  }
-
-  async _cacheEntrySet(requestHash, data, cacheHeaders) {
-    if (!this._cache) return undefined;
-
-    try {
-      return await this._cache.set(requestHash, data, {
-        cacheHeaders
-      });
-    } catch (error) {
-      return Promise.reject(error);
-    }
-  }
-
-  async _delete(path, {
-    headers = {},
-    pathTemplateData,
-    queryParams = {},
-    ...rest
-  }, context) {
-    const endpoint = (0, _buildEndpoint.default)(this._basePath, path, {
-      optionalPathTemplateRegExp: this._optionalPathTemplateRegExp,
-      pathTemplateCallback: this._pathTemplateCallback,
-      pathTemplateData,
-      pathTemplateRegExp: this._pathTemplateRegExp,
-      queryParams: { ...this._queryParams,
-        ...queryParams
-      }
-    });
-    const requestHash = (0, _md.default)(endpoint);
-    const cacheability = await this._cacheEntryHas(requestHash);
-
-    if (cacheability) {
-      this._cacheEntryDelete(requestHash);
-    }
-
-    return this._fetch(endpoint, {
-      headers: { ...this._headers,
-        ...headers
-      },
-      method: _constants.DELETE_METHOD,
-      ...rest
-    }, context);
-  }
-
-  async _fetch(endpoint, options, context = {}) {
-    context.startTime = this._performance.now();
-
-    try {
-      const {
-        redirects,
-        retries,
-        ...rest
-      } = options;
-      return await new Promise(async (resolve, reject) => {
-        const fetchTimer = setTimeout(() => {
-          reject(new Error(`${_constants.FETCH_TIMEOUT_ERROR} ${this._fetchTimeout}ms.`));
-        }, this._fetchTimeout);
-
-        this._rateLimit();
-
-        if (!(this._rateLimitCount < this._rateLimitPerSecond)) {
-          clearTimeout(fetchTimer);
-          resolve(await this._addRequestToRateLimitedQueue(endpoint, options, context));
-          return;
-        }
-
-        if (!redirects && !retries) {
-          var _this$_log;
-
-          (_this$_log = this._log) === null || _this$_log === void 0 ? void 0 : _this$_log.call(this, _constants.REQUEST_SENT, {
-            context: {
-              redirects,
-              retries,
-              url: endpoint,
-              ...rest,
-              ...context
-            },
-            stats: {
-              startTime: context.startTime
-            }
-          });
-        }
-
-        const res = await fetch(endpoint, rest);
-        clearTimeout(fetchTimer);
-        const {
-          headers,
-          status
-        } = res;
-        const responseGroup = (0, _getResponseGroup.default)(status);
-
-        if (responseGroup === _constants.REDIRECTION_REPSONSE && headers.get(_constants.LOCATION_HEADER)) {
-          resolve(await this._fetchRedirectHandler(res, headers.get(_constants.LOCATION_HEADER), {
-            redirects,
-            status,
-            ...rest
-          }, context));
-          return;
-        }
-
-        if (responseGroup === _constants.SERVER_ERROR_REPSONSE) {
-          resolve(await this._fetchRetryHandler(res, endpoint, {
-            retries,
-            ...rest
-          }, context));
-          return;
-        }
-
-        const fetchRes = res;
-
-        try {
-          fetchRes.data = res.body ? this._bodyParser(await res[this._streamReader]()) : undefined;
-
-          this._logResponse(fetchRes, endpoint, options, context);
-
-          resolve(fetchRes);
-        } catch (e) {
-          reject([e, new Error(`Unable to ${rest.method} ${endpoint} due to previous error`)]);
-        }
-      });
-    } catch (error) {
-      const fetchRes = {
-        errors: (0, _castArray2.default)(error)
-      };
-
-      this._logResponse(fetchRes, endpoint, options, context);
-
-      return fetchRes;
-    }
-  }
-
-  async _fetchRedirectHandler(res, endpoint, options, context) {
-    const {
-      method,
-      redirects = 1,
-      status,
-      ...rest
-    } = options;
-
-    if (redirects === this._maxRedirects) {
-      const fetchRes = res;
-      fetchRes.errors = [new Error(`${_constants.MAX_REDIRECTS_EXCEEDED_ERROR} ${this._maxRedirects}.`)];
-
-      this._logResponse(fetchRes, endpoint, options, context);
-
-      return fetchRes;
-    }
-
-    const redirectMethod = status === 303 ? _constants.GET_METHOD : method;
-    return this._fetch(endpoint, {
-      method: redirectMethod,
-      redirects: redirects + 1,
-      ...rest
-    });
-  }
-
-  async _fetchRetryHandler(res, endpoint, options, context) {
-    const {
-      retries = 1,
-      ...rest
-    } = options;
-
-    if (retries === this._maxRetries) {
-      const fetchRes = res;
-      fetchRes.errors = [new Error(`${_constants.MAX_RETRIES_EXCEEDED_ERROR} ${this._maxRetries}.`)];
-
-      this._logResponse(fetchRes, endpoint, options, context);
-
-      return fetchRes;
-    }
-
-    await (0, _delay.default)(this._requestRetryWait);
-    return this._fetch(endpoint, {
-      retries: retries + 1,
-      ...rest
-    });
-  }
-
-  async _get(path, {
-    headers = {},
-    pathTemplateData,
-    queryParams = {}
-  }, context) {
-    const endpoint = (0, _buildEndpoint.default)(this._basePath, path, {
-      optionalPathTemplateRegExp: this._optionalPathTemplateRegExp,
-      pathTemplateCallback: this._pathTemplateCallback,
-      pathTemplateData,
-      pathTemplateRegExp: this._pathTemplateRegExp,
-      queryParams: { ...this._queryParams,
-        ...queryParams
-      }
-    });
-    const requestHash = (0, _md.default)(endpoint);
-    const cacheability = await this._cacheEntryHas(requestHash);
-
-    if (cacheability) {
-      if ((0, _isCacheabilityValid.default)(cacheability)) {
-        return {
-          data: await this._cacheEntryGet(requestHash),
-          headers: new Headers({
-            "cache-control": cacheability.printCacheControl()
-          })
-        };
-      }
-
-      if (this._conditionalRequestsEnabled) {
-        var _cacheability$metadat, _cacheability$metadat2;
-
-        const etag = (_cacheability$metadat = cacheability === null || cacheability === void 0 ? void 0 : (_cacheability$metadat2 = cacheability.metadata) === null || _cacheability$metadat2 === void 0 ? void 0 : _cacheability$metadat2.etag) !== null && _cacheability$metadat !== void 0 ? _cacheability$metadat : null;
-        if (etag) headers[_constants.IF_NONE_MATCH_HEADER] = etag;
-      }
-    }
-
-    const pendingRequest = this._trackRequest(requestHash);
-
-    if (pendingRequest) return pendingRequest;
-    return this._getResolve(requestHash, await this._fetch(endpoint, {
-      headers: { ...this._headers,
-        ...headers
-      },
-      method: _constants.GET_METHOD
-    }, context));
-  }
-
-  async _getResolve(requestHash, res) {
-    const {
-      data,
-      headers,
-      status
-    } = res;
-
-    if (status === _constants.NOT_FOUND_STATUS_CODE) {
-      this._cacheEntryDelete(requestHash);
-
-      if (!res.errors) {
-        res.errors = [];
-      }
-
-      res.errors.push(new Error(_constants.RESOURCE_NOT_FOUND_ERROR));
-    } else if (status === _constants.NOT_MODIFIED_STATUS_CODE && headers) {
-      const cachedData = await this._cacheEntryGet(requestHash);
-
-      if (cachedData) {
-        this._cacheEntrySet(requestHash, cachedData, {
-          cacheControl: headers.get(_constants.CACHE_CONTROL_HEADER) || undefined,
-          etag: headers.get(_constants.ETAG_HEADER) || undefined
-        });
-
-        res.data = cachedData;
-      }
-    } else if (data && headers) {
-      this._cacheEntrySet(requestHash, data, {
-        cacheControl: headers.get(_constants.CACHE_CONTROL_HEADER) || undefined,
-        etag: headers.get(_constants.ETAG_HEADER) || undefined
-      });
-    }
-
-    this._resolvePendingRequests(requestHash, res);
-
-    this._requestTracker.active = this._requestTracker.active.filter(value => value !== requestHash);
-    return res;
-  }
-
-  _logResponse(res, endpoint, options, context) {
-    var _this$_log2;
-
-    const {
-      data,
-      errors,
-      headers,
-      status
-    } = res;
-    const {
-      redirects,
-      retries
-    } = options;
-    const {
-      startTime,
-      ...otherContext
-    } = context;
-
-    const endTime = this._performance.now();
-
-    const duration = endTime - startTime;
-    (_this$_log2 = this._log) === null || _this$_log2 === void 0 ? void 0 : _this$_log2.call(this, _constants.RESPONSE_RECEIVED, {
-      context: {
-        body: data ? {
-          data
-        } : {
-          errors: errors !== null && errors !== void 0 ? errors : []
-        },
-        headers,
-        method: options.method,
-        redirects,
-        retries,
-        status,
-        url: endpoint,
-        ...otherContext
-      },
-      stats: {
-        duration,
-        endTime,
-        startTime
-      }
-    });
-  }
-
-  _rateLimit() {
-    if (!this._rateLimitTimer) {
-      this._rateLimitTimer = setTimeout(() => {
-        this._rateLimitTimer = null;
-        this._rateLimitCount = 0;
-
-        if (this._rateLimitedRequestQueue.length) {
-          this._releaseRateLimitedRequestQueue();
-        }
-      }, 1000);
-    }
-
-    this._rateLimitCount += 1;
-  }
-
-  _releaseRateLimitedRequestQueue() {
-    this._rateLimitedRequestQueue.forEach(async ([resolve, endpoint, options, context]) => {
-      resolve(await this._fetch(endpoint, options, context));
-    });
-
-    this._rateLimitedRequestQueue = [];
-  }
-
-  async _request(path, {
-    body,
-    headers,
-    method,
-    pathTemplateData,
-    queryParams,
-    ...rest
-  }, context) {
-    const endpoint = (0, _buildEndpoint.default)(this._basePath, path, {
-      optionalPathTemplateRegExp: this._optionalPathTemplateRegExp,
-      pathTemplateCallback: this._pathTemplateCallback,
-      pathTemplateData,
-      pathTemplateRegExp: this._pathTemplateRegExp,
-      queryParams: { ...this._queryParams,
-        ...queryParams
-      }
-    });
-    return this._fetch(endpoint, {
-      body,
-      headers: { ...this._headers,
-        ...headers
-      },
-      method,
-      ...rest
-    }, context);
-  }
-
-  _resolvePendingRequests(requestHash, responseData) {
-    const pendingRequests = this._requestTracker.pending.get(requestHash);
-
-    if (!pendingRequests) return;
-    pendingRequests.forEach(({
-      resolve
-    }) => {
-      resolve(responseData);
-    });
-
-    this._requestTracker.pending.delete(requestHash);
-  }
-
-  _setPendingRequest(requestHash, resolver) {
-    let pending = this._requestTracker.pending.get(requestHash);
-
-    if (!pending) pending = [];
-    pending.push(resolver);
-
-    this._requestTracker.pending.set(requestHash, pending);
-  }
-
-  _trackRequest(requestHash) {
-    if (this._requestTracker.active.includes(requestHash)) {
-      return new Promise(resolve => {
-        this._setPendingRequest(requestHash, {
-          resolve
-        });
-      });
-    }
-
-    this._requestTracker.active.push(requestHash);
-  }
-
-}
-
-exports.Getta = Getta;
-
-const createRestClient = (options, shortcuts) => {
-  const getta = new Getta(options);
-  if (!shortcuts) return getta;
-  Object.keys(shortcuts).forEach(key => {
-    getta.createShortcut(key, ...shortcuts[key]);
-  });
-  return getta;
-};
-
-exports.createRestClient = createRestClient;

package/lib/main/types.js

@@ -1 +0,0 @@
-"use strict";

package/lib/module/constants.js

@@ -1,49 +0,0 @@
-export const ARRAY_BUFFER_FORMAT = "arrayBuffer";
-export const BLOB_FORMAT = "blob";
-export const FORM_DATA_FORMAT = "formData";
-export const JSON_FORMAT = "json";
-export const TEXT_FORMAT = "text";
-export const STREAM_READERS = {
-  ARRAY_BUFFER_FORMAT,
-  BLOB_FORMAT,
-  FORM_DATA_FORMAT,
-  JSON_FORMAT,
-  TEXT_FORMAT
-};
-export const DEFAULT_BODY_PARSER = body => body;
-export const DEFAULT_FETCH_TIMEOUT = 5000;
-export const DEFAULT_HEADERS = {
-  "content-type": "application/json"
-};
-export const DEFAULT_MAX_REDIRECTS = 5;
-export const DEFAULT_MAX_RETRIES = 3;
-export const DEFAULT_PATH_TEMPLATE_REGEX = /({type})|({id})|({id,\+})|({brief\|standard})/g;
-export const OPTIONAL_PATH_TEMPLATE_REGEX = /({[a-zA-Z0-9_]+\?})/g;
-export const DEFAULT_RATE_LIMIT = 50;
-export const DEFAULT_REQUEST_RETRY_WAIT = 100;
-export const MISSING_BASE_PATH_ERROR = `Getta expected to receive 'basePath' in the constructor options,
-  but recevied undefined.`;
-export const MAX_REDIRECTS_EXCEEDED_ERROR = "The request exceeded the maximum number of redirects, which is";
-export const MAX_RETRIES_EXCEEDED_ERROR = "The request exceeded the maximum number of retries, which is";
-export const INVALID_FETCH_METHOD_ERROR = "Getta expected to receive 'get', 'post', 'put' or 'delete', but received";
-export const RESOURCE_NOT_FOUND_ERROR = "The requested resource could not been found.";
-export const FETCH_TIMEOUT_ERROR = "The request timed out. Getta did not get a response within";
-export const GET_METHOD = "get";
-export const POST_METHOD = "post";
-export const PUT_METHOD = "put";
-export const DELETE_METHOD = "delete";
-export const FETCH_METHODS = [GET_METHOD, POST_METHOD, PUT_METHOD, DELETE_METHOD];
-export const INFORMATION_REPSONSE = "information";
-export const SUCCESSFUL_REPSONSE = "successful";
-export const REDIRECTION_REPSONSE = "redirection";
-export const CLIENT_ERROR_REPSONSE = "clientError";
-export const SERVER_ERROR_REPSONSE = "serverError";
-export const NOT_MODIFIED_STATUS_CODE = 304;
-export const NOT_FOUND_STATUS_CODE = 404;
-export const COOKIE_HEADER = "Cookie";
-export const ETAG_HEADER = "ETag";
-export const LOCATION_HEADER = "Location";
-export const IF_NONE_MATCH_HEADER = "If-None-Match";
-export const CACHE_CONTROL_HEADER = "Cache-Control";
-export const REQUEST_SENT = "request_sent";
-export const RESPONSE_RECEIVED = "response_received";

package/lib/module/helpers/build-endpoint/index.js

@@ -1,28 +0,0 @@
-import queryString from "query-string";
-export default function buildEndpoint(basePath, path, {
-  optionalPathTemplateRegExp,
-  pathTemplateCallback,
-  pathTemplateData,
-  pathTemplateRegExp,
-  queryParams
-}) {
-  const pathJoiner = basePath.endsWith("/") || path.startsWith("/") ? "" : "/";
-  let endpoint = `${basePath}${pathJoiner}${path}`;
-
-  if (pathTemplateData) {
-    endpoint = pathTemplateCallback(endpoint, pathTemplateData, pathTemplateRegExp);
-  }
-
-  endpoint = endpoint.replace(optionalPathTemplateRegExp, "");
-
-  if (endpoint.endsWith("/")) {
-    endpoint = endpoint.substring(0, endpoint.length - 1);
-  }
-
-  if (queryParams && Object.keys(queryParams).length) {
-    const queryJoin = queryString.extract(endpoint) ? "&" : "?";
-    endpoint = `${endpoint}${queryJoin}${queryString.stringify(queryParams)}`;
-  }
-
-  return endpoint;
-}

package/lib/module/helpers/default-path-template-callback/index.js

@@ -1,9 +0,0 @@
-export default function defaultPathTemplateCallback(pathTemplate, data, pathTemplateRegExp) {
-  const dataKeys = Object.keys(data);
-  return pathTemplate.replace(pathTemplateRegExp, match => {
-    return dataKeys.reduce((value, key) => {
-      if (match.includes(key)) return data[key];
-      return value;
-    }, "");
-  });
-}

package/lib/module/helpers/delay/index.js

@@ -1,4 +0,0 @@
-import "core-js/modules/es.promise.js";
-export default function delay(ms) {
-  return new Promise(resolve => setTimeout(resolve, ms));
-}

package/lib/module/helpers/get-response-group/index.js

@@ -1,19 +0,0 @@
-import { CLIENT_ERROR_REPSONSE, INFORMATION_REPSONSE, REDIRECTION_REPSONSE, SERVER_ERROR_REPSONSE, SUCCESSFUL_REPSONSE } from "../../constants";
-export default function getResponseGroup(status) {
-  switch (true) {
-    case status < 200:
-      return INFORMATION_REPSONSE;
-
-    case status < 300:
-      return SUCCESSFUL_REPSONSE;
-
-    case status < 400:
-      return REDIRECTION_REPSONSE;
-
-    case status < 500:
-      return CLIENT_ERROR_REPSONSE;
-
-    default:
-      return SERVER_ERROR_REPSONSE;
-  }
-}

package/lib/module/helpers/is-cacheability-valid/index.js

@@ -1,6 +0,0 @@
-export default function isCacheabilityValid(cacheability) {
-  var _cacheability$metadat, _cacheability$metadat2, _cacheability$metadat3;
-
-  const noCache = (_cacheability$metadat = cacheability === null || cacheability === void 0 ? void 0 : (_cacheability$metadat2 = cacheability.metadata) === null || _cacheability$metadat2 === void 0 ? void 0 : (_cacheability$metadat3 = _cacheability$metadat2.cacheControl) === null || _cacheability$metadat3 === void 0 ? void 0 : _cacheability$metadat3.noCache) !== null && _cacheability$metadat !== void 0 ? _cacheability$metadat : false;
-  return !noCache && cacheability.checkTTL();
-}