@atlaskit/media-client 14.0.0 → 14.3.0

package/dist/cjs/utils/mobileUpload/stateMachine/index.js

@@ -0,0 +1,103 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createMobileUploadService = createMobileUploadService;
+exports.createMobileUploadStateMachine = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _map = require("rxjs/operators/map");
+
+var _xstate = require("xstate");
+
+var _fileState = require("../../../models/file-state");
+
+var _shouldFetchRemoteFileStates3 = require("../../shouldFetchRemoteFileStates");
+
+var _helpers = require("../helpers");
+
+var _uploading = require("./states/uploading");
+
+var _processing = require("./states/processing");
+
+var _processed = require("./states/processed");
+
+var _processingFailed = require("./states/processingFailed");
+
+var _error = require("./states/error");
+
+var createMobileUploadStateMachine = function createMobileUploadStateMachine(dataloader, initialState, collectionName) {
+  return (0, _xstate.createMachine)({
+    // Initial state
+    initial: initialState.status,
+    // Context
+    context: {
+      currentFileState: initialState
+    },
+    // State definitions
+    states: {
+      uploading: _uploading.machineUploadingState,
+      processing: _processing.machineProcessingState,
+      processed: _processed.machineProcessedState,
+      processingFailed: _processingFailed.machineProcessingFailedState,
+      error: _error.machineErrorState
+    }
+  }, {
+    services: {
+      shouldFetchRemoteFileStates: function () {
+        var _shouldFetchRemoteFileStates2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(ctx) {
+          var currentFileState, mediaType, mimeType, preview;
+          return _regenerator.default.wrap(function _callee$(_context) {
+            while (1) {
+              switch (_context.prev = _context.next) {
+                case 0:
+                  currentFileState = ctx.currentFileState;
+
+                  if (!(0, _fileState.isProcessingFileState)(currentFileState)) {
+                    _context.next = 4;
+                    break;
+                  }
+
+                  mediaType = currentFileState.mediaType, mimeType = currentFileState.mimeType, preview = currentFileState.preview;
+                  return _context.abrupt("return", (0, _shouldFetchRemoteFileStates3.shouldFetchRemoteFileStates)(mediaType, mimeType, preview));
+
+                case 4:
+                  return _context.abrupt("return", false);
+
+                case 5:
+                case "end":
+                  return _context.stop();
+              }
+            }
+          }, _callee);
+        }));
+
+        function shouldFetchRemoteFileStates(_x) {
+          return _shouldFetchRemoteFileStates2.apply(this, arguments);
+        }
+
+        return shouldFetchRemoteFileStates;
+      }(),
+      fetchRemoteFileStates: function fetchRemoteFileStates(ctx) {
+        return (0, _helpers.createMobileDownloadFileStream)(dataloader, ctx.currentFileState.id, collectionName, ctx.currentFileState.occurrenceKey).pipe((0, _map.map)(function (fileState) {
+          return {
+            type: 'REMOTE_FILESTATE_RESULT',
+            fileState: fileState
+          };
+        }));
+      }
+    }
+  });
+};
+
+exports.createMobileUploadStateMachine = createMobileUploadStateMachine;
+
+function createMobileUploadService(machine) {
+  return (0, _xstate.interpret)(machine);
+}

package/dist/cjs/utils/mobileUpload/stateMachine/states/error.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.machineErrorState = void 0;
+var machineErrorState = {
+  type: 'final'
+};
+exports.machineErrorState = machineErrorState;

package/dist/cjs/utils/mobileUpload/stateMachine/states/processed.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.machineProcessedState = void 0;
+var machineProcessedState = {
+  type: 'final'
+};
+exports.machineProcessedState = machineProcessedState;

package/dist/cjs/utils/mobileUpload/stateMachine/states/processing.js

@@ -0,0 +1,77 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.machineProcessingState = void 0;
+
+var _xstate = require("xstate");
+
+var machineProcessingState = {
+  // Events
+  on: {
+    REMOTE_FILESTATE_PROCESSED: 'processed',
+    REMOTE_FILESTATE_PROCESSING_FAILED: 'processingFailed',
+    REMOTE_FILESTATE_ERROR: 'error'
+  },
+  // Initial sub state
+  initial: 'loading',
+  // Sub states definitions
+  states: {
+    loading: {
+      invoke: {
+        src: 'shouldFetchRemoteFileStates',
+        onDone: {
+          actions: (0, _xstate.send)(function (_, event) {
+            return {
+              // shouldFetchRemoteFileStates resolves a boolean
+              type: event.data ? 'REMOTE_FILESTATE_FETCH' : 'REMOTE_FILESTATE_BYPASS'
+            };
+          })
+        },
+        onError: 'idle'
+      },
+      on: {
+        REMOTE_FILESTATE_FETCH: 'fetchingRemoteFileStates',
+        REMOTE_FILESTATE_BYPASS: 'idle'
+      }
+    },
+    fetchingRemoteFileStates: {
+      invoke: {
+        src: 'fetchRemoteFileStates',
+        onDone: {
+          actions: (0, _xstate.send)(function (ctx) {
+            return {
+              type: ctx.currentFileState.status === 'processed' ? 'REMOTE_FILESTATE_PROCESSED' : 'REMOTE_FILESTATE_PROCESSING_FAILED'
+            };
+          })
+        },
+        onError: {
+          actions: [(0, _xstate.assign)({
+            currentFileState: function currentFileState(ctx, event) {
+              return {
+                status: 'error',
+                id: ctx.currentFileState.id,
+                occurrenceKey: ctx.currentFileState.occurrenceKey,
+                message: event.data.message
+              };
+            }
+          }), (0, _xstate.send)({
+            type: 'REMOTE_FILESTATE_ERROR'
+          })]
+        }
+      },
+      on: {
+        REMOTE_FILESTATE_RESULT: {
+          actions: (0, _xstate.assign)({
+            currentFileState: function currentFileState(_, event) {
+              return event.fileState;
+            }
+          })
+        }
+      }
+    },
+    idle: {}
+  }
+};
+exports.machineProcessingState = machineProcessingState;

package/dist/cjs/utils/mobileUpload/stateMachine/states/processingFailed.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.machineProcessingFailedState = void 0;
+var machineProcessingFailedState = {
+  type: 'final'
+};
+exports.machineProcessingFailedState = machineProcessingFailedState;

package/dist/cjs/utils/mobileUpload/stateMachine/states/uploading.js

@@ -0,0 +1,70 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.machineUploadingState = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _xstate = require("xstate");
+
+var _fileState = require("../../../../models/file-state");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+var machineUploadingState = {
+  // Events
+  on: {
+    UPLOAD_PROGRESS: [{
+      target: 'uploading',
+      cond: function cond(ctx, event) {
+        return (0, _fileState.isUploadingFileState)(ctx.currentFileState) && event.progress > ctx.currentFileState.progress;
+      },
+      actions: (0, _xstate.assign)({
+        currentFileState: function currentFileState(ctx, event) {
+          return _objectSpread(_objectSpread({}, ctx.currentFileState), {}, {
+            progress: event.progress
+          });
+        }
+      })
+    }, {
+      target: 'error'
+    }],
+    UPLOAD_END: {
+      target: 'processing',
+      actions: (0, _xstate.assign)({
+        currentFileState: function currentFileState(ctx) {
+          return (0, _fileState.isUploadingFileState)(ctx.currentFileState) && {
+            status: 'processing',
+            id: ctx.currentFileState.id,
+            occurrenceKey: ctx.currentFileState.occurrenceKey,
+            name: ctx.currentFileState.name,
+            size: ctx.currentFileState.size,
+            mediaType: ctx.currentFileState.mediaType,
+            mimeType: ctx.currentFileState.mimeType,
+            preview: ctx.currentFileState.preview,
+            createdAt: ctx.currentFileState.createdAt
+          } || ctx.currentFileState;
+        }
+      })
+    },
+    UPLOAD_ERROR: {
+      target: 'error',
+      actions: (0, _xstate.assign)({
+        currentFileState: function currentFileState(ctx, event) {
+          return {
+            status: 'error',
+            id: ctx.currentFileState.id,
+            message: event.message
+          };
+        }
+      })
+    }
+  }
+};
+exports.machineUploadingState = machineUploadingState;

package/dist/cjs/utils/mobileUpload/stateMachine/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/dist/cjs/utils/polling/index.js

@@ -17,19 +17,18 @@ var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/creat
 
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
-var _mediaFeatureFlags = require("@atlaskit/media-common/mediaFeatureFlags");
-
 var _errors = require("./errors");
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
 
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 
+// default polling options without using feature flags
 var defaultPollingOptions = {
-  poll_intervalMs: (0, _mediaFeatureFlags.getMediaFeatureFlag)('poll_intervalMs'),
-  poll_maxAttempts: (0, _mediaFeatureFlags.getMediaFeatureFlag)('poll_maxAttempts'),
-  poll_backoffFactor: (0, _mediaFeatureFlags.getMediaFeatureFlag)('poll_backoffFactor'),
-  poll_maxIntervalMs: (0, _mediaFeatureFlags.getMediaFeatureFlag)('poll_maxIntervalMs')
+  poll_intervalMs: 3000,
+  poll_maxAttempts: 30,
+  poll_backoffFactor: 1.25,
+  poll_maxIntervalMs: 200000
 };
 /**
  * This class encapsulates polling functionality with the following features:

package/dist/cjs/utils/setTimeoutPromise.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.rejectTimeout = exports.resolveTimeout = void 0;
+
+var resolveTimeout = function resolveTimeout(timeout, resolveWith) {
+  return new Promise(function (resolve, _reject) {
+    setTimeout(resolve, timeout, resolveWith);
+  });
+};
+
+exports.resolveTimeout = resolveTimeout;
+
+var rejectTimeout = function rejectTimeout(timeout, rejectWith) {
+  return new Promise(function (_resolve, reject) {
+    setTimeout(reject, timeout, rejectWith);
+  });
+};
+
+exports.rejectTimeout = rejectTimeout;

package/dist/cjs/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/media-client",
-	"version": "14.0.0",
+	"version": "14.3.0",
 	"sideEffects": false
 }

package/dist/es2019/client/file-fetcher/index.js

@@ -3,7 +3,10 @@ import { Subscription } from 'rxjs/Subscription';
 import { of } from 'rxjs/observable/of';
 import { map } from 'rxjs/operators/map';
 import { concatMap } from 'rxjs/operators/concatMap';
-import uuid from 'uuid/v4';
+import uuid from 'uuid/v4'; // import setimmediate to temporary fix dataloader 2.0.0 bug
+// @see https://github.com/graphql/dataloader/issues/249
+
+import 'setimmediate';
 import { authToOwner } from '@atlaskit/media-core';
 import { downloadUrl } from '@atlaskit/media-common/downloadUrl';
 import { MediaStore } from '../media-store';
@@ -25,22 +28,12 @@ import { isMimeTypeSupportedByBrowser, getMediaTypeFromMimeType } from '@atlaski
 import { shouldFetchRemoteFileStates, shouldFetchRemoteFileStatesObservable } from '../../utils/shouldFetchRemoteFileStates';
 import { PollingFunction } from '../../utils/polling';
 import { isEmptyFile } from '../../utils/detectEmptyFile';
-import { getMediaFeatureFlag } from '@atlaskit/media-common/mediaFeatureFlags';
 export { isFileFetcherError, FileFetcherError } from './error';
 export class FileFetcherImpl {
   constructor(mediaStore) {
     _defineProperty(this, "createDownloadFileStream", (id, collectionName, occurrenceKey) => {
       const subject = createFileStateSubject();
-      const {
-        featureFlags
-      } = this.mediaStore;
-      const pollingOptions = {
-        poll_intervalMs: getMediaFeatureFlag('poll_intervalMs', featureFlags),
-        poll_maxAttempts: getMediaFeatureFlag('poll_maxAttempts', featureFlags),
-        poll_backoffFactor: getMediaFeatureFlag('poll_backoffFactor', featureFlags),
-        poll_maxIntervalMs: getMediaFeatureFlag('poll_maxIntervalMs', featureFlags)
-      };
-      const poll = new PollingFunction(pollingOptions); // ensure subject errors if polling exceeds max iterations or uncaught exception in executor
+      const poll = new PollingFunction(); // ensure subject errors if polling exceeds max iterations or uncaught exception in executor
 
       poll.onError = error => subject.error(error);
 

package/dist/es2019/client/media-client.js

@@ -4,6 +4,7 @@ import { CollectionFetcher } from './collection-fetcher';
 import { FileFetcherImpl } from './file-fetcher';
 import { StargateClient } from './stargate-client';
 export class MediaClient {
+  // mobile upload is lazily loaded
   // Deprecated value introduced for backward compatibility with Context
   constructor(mediaClientConfig, featureFlags) {
     this.mediaClientConfig = mediaClientConfig;
@@ -34,6 +35,18 @@ export class MediaClient {
     return (await this.mediaStore.getImageMetadata(id, params)).metadata;
   }
 
+  async mobileUploadPromise() {
+    if (this.mobileUpload) {
+      return this.mobileUpload;
+    }
+
+    const module = await import(
+    /* webpackChunkName: "@atlaskit-internal_media-client-mobile-upload" */
+    './mobile-upload');
+    this.mobileUpload = new module.MobileUploadImpl(this.mediaStore);
+    return this.mobileUpload;
+  }
+
   on(event, listener) {
     this.eventEmitter.on(event, listener);
   }

package/dist/es2019/client/media-store/resolveAuth.js

@@ -1,14 +1,22 @@
 import { MediaStoreError } from './error';
-export const TOKEN_MINIMUM_LIFETIME = 10000; // 10 sec
-
-export const resolveAuth = async (authProvider, authContext) => {
+import { rejectTimeout } from '../../utils/setTimeoutPromise';
+export const DEFAULT_AUTH_PROVIDER_TIMEOUT = 10000;
+export const resolveAuth = async (authProvider, authContext, authProviderTimeout = DEFAULT_AUTH_PROVIDER_TIMEOUT) => {
   let auth;
 
   try {
-    auth = await authProvider(authContext);
+    auth = await Promise.race([authProvider(authContext), rejectTimeout(authProviderTimeout, new MediaStoreError('authProviderTimedOut'))]);
   } catch (err) {
+    if (err instanceof MediaStoreError) {
+      throw err;
+    }
+
     throw new MediaStoreError('failedAuthProvider', err);
   }
+
+  if (!auth) {
+    throw new MediaStoreError('emptyAuth');
+  }
   /*
     We added a token expiration check here in the past, and then we had to revert due to edge cases in the client that we can't control.
     Token expiration check in the frontend is a bad idea. Don't do it!

package/dist/es2019/client/mobile-upload.js

@@ -0,0 +1,80 @@
+import { getMediaTypeFromMimeType } from '@atlaskit/media-common';
+import { getFileStreamsCache } from '../file-streams-cache';
+import { createFileDataloader } from '../utils/createFileDataLoader';
+import { createServicesCache, createMobileUploadStateMachine, createMobileUploadService, createMobileFileStateSubject } from '../utils/mobileUpload';
+export class MobileUploadImpl {
+  constructor(mediaStore) {
+    this.dataloader = createFileDataloader(mediaStore);
+    this.servicesCache = createServicesCache();
+  }
+
+  notifyUploadStart(event) {
+    const {
+      fileId,
+      collectionName,
+      occurrenceKey,
+      fileName,
+      fileSize,
+      fileMimetype,
+      preview,
+      createdAt
+    } = event;
+    const mediaType = getMediaTypeFromMimeType(fileMimetype);
+    const initialState = {
+      status: 'uploading',
+      id: fileId,
+      occurrenceKey,
+      name: fileName,
+      size: fileSize,
+      progress: 0,
+      mediaType,
+      mimeType: fileMimetype,
+      preview,
+      createdAt
+    };
+    const service = createMobileUploadService(createMobileUploadStateMachine(this.dataloader, initialState, collectionName));
+    const subject = createMobileFileStateSubject(service);
+    this.servicesCache.put(fileId, service);
+    getFileStreamsCache().set(fileId, subject);
+  }
+
+  notifyUploadProgress(event) {
+    const {
+      fileId,
+      progress
+    } = event;
+    const service = this.servicesCache.get(fileId);
+
+    if (service) {
+      service.send('UPLOAD_PROGRESS', {
+        progress
+      });
+    }
+  }
+
+  notifyUploadEnd(event) {
+    const {
+      fileId
+    } = event;
+    const service = this.servicesCache.get(fileId);
+
+    if (service) {
+      service.send('UPLOAD_END');
+    }
+  }
+
+  notifyUploadError(event) {
+    const {
+      fileId,
+      message
+    } = event;
+    const service = this.servicesCache.get(fileId);
+
+    if (service) {
+      service.send('UPLOAD_ERROR', {
+        message
+      });
+    }
+  }
+
+}

package/dist/es2019/index.js

@@ -10,6 +10,7 @@ export { request, RequestError, isRequestError, isRateLimitedError } from './uti
 export { isAbortedRequestError, mapResponseToJson, mapResponseToBlob, mapResponseToVoid, createUrl } from './utils/request/helpers';
 export { PollingFunction } from './utils/polling';
 export { isPollingError, PollingError } from './utils/polling/errors';
+export { imageResizeModeToFileImageMode } from './utils/imageResizeModeToFileImageMode';
 export { FileFetcherImpl, FileFetcherError, isFileFetcherError } from './client/file-fetcher';
 export { CollectionFetcher } from './client/collection-fetcher';
 export { MediaClient } from './client/media-client';

package/dist/es2019/models/mobile-upload.js

@@ -0,0 +1 @@
+export {};

package/dist/es2019/utils/createFileDataLoader.js

@@ -1,3 +1,6 @@
+// import setimmediate to temporary fix dataloader 2.0.0 bug
+// @see https://github.com/graphql/dataloader/issues/249
+import 'setimmediate';
 import Dataloader from 'dataloader';
 export const MAX_BATCH_SIZE = 100;
 

package/dist/es2019/utils/imageResizeModeToFileImageMode.js

@@ -0,0 +1 @@
+export const imageResizeModeToFileImageMode = resizeMode => resizeMode === 'stretchy-fit' ? 'full-fit' : resizeMode;

package/dist/es2019/utils/mobileUpload/error.js

@@ -0,0 +1,30 @@
+import { BaseMediaClientError } from '../../models/errors';
+export class MobileUploadError extends BaseMediaClientError {
+  constructor(reason, id, metadata) {
+    super(reason);
+    this.reason = reason;
+    this.id = id;
+    this.metadata = metadata;
+  }
+
+  get attributes() {
+    const {
+      reason,
+      id,
+      metadata: {
+        collectionName,
+        occurrenceKey
+      } = {}
+    } = this;
+    return {
+      reason,
+      id,
+      collectionName,
+      occurrenceKey
+    };
+  }
+
+}
+export function isMobileUploadError(err) {
+  return err instanceof MobileUploadError;
+}

package/dist/es2019/utils/mobileUpload/helpers.js

@@ -0,0 +1,55 @@
+import { ReplaySubject } from 'rxjs/ReplaySubject';
+import { from } from 'rxjs/observable/from';
+import { map } from 'rxjs/operators/map';
+import { mapMediaItemToFileState } from '../../models/file-state';
+import { createFileStateSubject } from '../createFileStateSubject';
+import { isEmptyFile } from '../detectEmptyFile';
+import { PollingFunction } from '../polling';
+import { MobileUploadError } from './error';
+export const createMobileFileStateSubject = service => {
+  const subject = new ReplaySubject(1);
+  from(service.start()).pipe(map(state => state.context.currentFileState)).subscribe(subject);
+  return subject;
+};
+export const createMobileDownloadFileStream = (dataloader, id, collectionName, occurrenceKey) => {
+  const subject = createFileStateSubject();
+  const poll = new PollingFunction(); // ensure subject errors if polling exceeds max iterations or uncaught exception in executor
+
+  poll.onError = error => subject.error(error);
+
+  poll.execute(async () => {
+    const response = await dataloader.load({
+      id,
+      collectionName
+    });
+
+    if (!response) {
+      throw new MobileUploadError('emptyItems', id, {
+        collectionName,
+        occurrenceKey
+      });
+    }
+
+    if (isEmptyFile(response)) {
+      throw new MobileUploadError('zeroVersionFile', id, {
+        collectionName,
+        occurrenceKey
+      });
+    }
+
+    const fileState = mapMediaItemToFileState(id, response);
+    subject.next(fileState);
+
+    switch (fileState.status) {
+      case 'processing':
+        // the only case for continuing polling, otherwise this function is run once only
+        poll.next();
+        break;
+
+      case 'processed':
+        subject.complete();
+        break;
+    }
+  });
+  return subject;
+};

package/dist/es2019/utils/mobileUpload/index.js

@@ -0,0 +1,4 @@
+export { isMobileUploadError, MobileUploadError } from './error';
+export { createServicesCache } from './servicesCache';
+export { createMobileUploadService, createMobileUploadStateMachine } from './stateMachine';
+export { createMobileFileStateSubject } from './helpers';

package/dist/es2019/utils/mobileUpload/servicesCache.js

@@ -0,0 +1,4 @@
+import { LRUCache } from 'lru-fast';
+export function createServicesCache() {
+  return new LRUCache(100);
+}