@atlaskit/media-client 20.0.0 → 20.0.2

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

@@ -3,9 +3,9 @@ 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 setimmediate to temporary fix dataloader 2.0.0 bug
+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';
@@ -28,44 +28,40 @@ 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';
 export { isFileFetcherError, FileFetcherError } from './error';
 export class FileFetcherImpl {
-  constructor(mediaStore) {
+  constructor(mediaStore, featureFlags) {
     _defineProperty(this, "createDownloadFileStream", (id, collectionName, occurrenceKey) => {
       const subject = createMediaSubject();
-      const poll = new PollingFunction(); // 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);
-
       poll.execute(async () => {
         const response = await this.dataloader.load({
           id,
           collectionName
         });
-
         if (!response) {
           throw new FileFetcherError('emptyItems', id, {
             collectionName,
             occurrenceKey
           });
         }
-
         if (isEmptyFile(response)) {
           throw new FileFetcherError('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;
@@ -73,17 +69,53 @@ export class FileFetcherImpl {
       });
       return subject;
     });
-
+    _defineProperty(this, "getUploadingFileStateBase", (file, upfrontId) => {
+      // TODO: DO not modify the input parameter 'content' attribute
+      if (typeof file.content === 'string') {
+        file.content = convertBase64ToBlob(file.content);
+      }
+      const {
+        content,
+        name = '' // name property is not available in base64 image
+      } = file;
+      const {
+        id,
+        occurrenceKey
+      } = upfrontId;
+      let preview;
+      // TODO [MSW-796]: get file size for base64
+      let size = 0;
+      let mimeType = '';
+      if (content instanceof Blob) {
+        size = content.size;
+        mimeType = content.type;
+        if (isMimeTypeSupportedByBrowser(content.type)) {
+          preview = {
+            value: content,
+            origin: 'local'
+          };
+        }
+      }
+      const mediaType = getMediaTypeFromUploadableFile(file);
+      return {
+        id,
+        occurrenceKey,
+        name,
+        size,
+        mediaType,
+        mimeType,
+        preview
+      };
+    });
     this.mediaStore = mediaStore;
+    this.featureFlags = featureFlags;
     this.dataloader = createFileDataloader(mediaStore);
   }
-
   getFileState(id, options = {}) {
     const {
       collectionName,
       occurrenceKey
     } = options;
-
     if (!isValidId(id)) {
       const subject = createMediaSubject();
       subject.error(new FileFetcherError('invalidFileId', id, {
@@ -92,22 +124,19 @@ export class FileFetcherImpl {
       }));
       return fromObservable(subject);
     }
-
     return fromObservable(getFileStreamsCache().getOrInsert(id, () => this.createDownloadFileStream(id, collectionName)));
   }
-
   getCurrentState(id, options) {
     return toPromise(this.getFileState(id, options));
   }
-
   getArtifactURL(artifacts, artifactName, collectionName) {
     return this.mediaStore.getArtifactURL(artifacts, artifactName, collectionName);
   }
-
   getFileBinaryURL(id, collectionName) {
     return this.mediaStore.getFileBinaryURL(id, collectionName);
-  } // TODO: ----- ADD TICKET TO PASS TRACE ID to this.dataloader.load
+  }
 
+  // TODO: ----- ADD TICKET TO PASS TRACE ID to this.dataloader.load
 
   touchFiles(descriptors, collection, traceContext) {
     return this.mediaStore.touchFiles({
@@ -118,7 +147,6 @@ export class FileFetcherImpl {
       data
     }) => data);
   }
-
   generateUploadableFileUpfrontIds(collection, traceContext) {
     const id = uuid();
     const occurrenceKey = uuid();
@@ -134,7 +162,6 @@ export class FileFetcherImpl {
       deferredUploadId
     };
   }
-
   async uploadExternal(url, collection, traceContext) {
     const uploadableFileUpfrontIds = this.generateUploadableFileUpfrontIds(collection, traceContext);
     const {
@@ -145,18 +172,16 @@ export class FileFetcherImpl {
     const deferredBlob = fetch(url).then(response => response.blob()).catch(() => undefined);
     const preview = new Promise(async (resolve, reject) => {
       const blob = await deferredBlob;
-
       if (!blob) {
         reject('Could not fetch the blob');
       }
-
       resolve({
         value: blob,
         origin: 'remote'
       });
     });
-    const name = url.split('/').pop() || ''; // we create a initial fileState with the minimum info that we have at this point
-
+    const name = url.split('/').pop() || '';
+    // we create a initial fileState with the minimum info that we have at this point
     const fileState = {
       status: 'processing',
       name,
@@ -167,16 +192,14 @@ export class FileFetcherImpl {
       occurrenceKey,
       preview
     };
-    subject.next(fileState); // we save it into the cache as soon as possible, in case someone subscribes
-
+    subject.next(fileState);
+    // we save it into the cache as soon as possible, in case someone subscribes
     getFileStreamsCache().set(id, subject);
     return new Promise(async (resolve, reject) => {
       const blob = await deferredBlob;
-
       if (!blob) {
         return reject('Could not download remote file');
       }
-
       const {
         type,
         size
@@ -187,8 +210,9 @@ export class FileFetcherImpl {
         collection,
         name
       };
-      const mediaType = getMediaTypeFromMimeType(type); // we emit a richer state after the blob is fetched
+      const mediaType = getMediaTypeFromMimeType(type);
 
+      // we emit a richer state after the blob is fetched
       subject.next({
         status: 'processing',
         name,
@@ -198,8 +222,8 @@ export class FileFetcherImpl {
         id,
         occurrenceKey,
         preview
-      }); // we don't want to wait for the file to be upload
-
+      });
+      // we don't want to wait for the file to be upload
       this.upload(file, undefined, uploadableFileUpfrontIds, traceContext);
       const dimensions = await getDimensionsFromBlob(mediaType, blob);
       resolve({
@@ -208,37 +232,81 @@ export class FileFetcherImpl {
       });
     });
   }
+  // TODO: make this the public upload method when the FF is removed
+  uploadAwlaysPullFileStates(file, controller, uploadableFileUpfrontIds, traceContext) {
+    const {
+      collection
+    } = file;
+    const upfrontId = uploadableFileUpfrontIds || this.generateUploadableFileUpfrontIds(collection, traceContext);
+    const {
+      id,
+      occurrenceKey
+    } = upfrontId;
+    const stateBase = this.getUploadingFileStateBase(file, upfrontId);
+    const subject = createMediaSubject();
+    getFileStreamsCache().set(id, subject);
+    const onProgress = progress => {
+      subject.next({
+        status: 'uploading',
+        ...stateBase,
+        progress
+      });
+    };
+    let processingSubscription = new Subscription();
+    const onUploadFinish = error => {
+      if (error) {
+        return subject.error(error);
+      }
+      processingSubscription = this.createDownloadFileStream(id, collection, occurrenceKey).pipe(map(remoteFileState => ({
+        // merges base state with remote state
+        ...stateBase,
+        ...remoteFileState,
+        ...overrideMediaTypeIfUnknown(remoteFileState, stateBase.mediaType)
+      }))).subscribe(subject);
+    };
+    const {
+      cancel
+    } = uploadFile(file, this.mediaStore, upfrontId, {
+      onUploadFinish,
+      onProgress
+    }, traceContext);
+    controller === null || controller === void 0 ? void 0 : controller.setAbort(() => {
+      cancel();
+      // TODO: filestate should turn to "Aborted" or something.
+      // Consider canceling an upload that is already finished
+      processingSubscription.unsubscribe();
+    });
 
-  upload(file, controller, uploadableFileUpfrontIds, traceContext) {
+    // We should report progress asynchronously, since this is what consumer expects
+    // (otherwise in newUploadService file-converting event will be emitted before files-added)
+    setTimeout(onProgress, 0, 0);
+    return fromObservable(subject);
+  }
+  uploadConditionallyPullFileStates(file, controller, uploadableFileUpfrontIds, traceContext) {
     if (typeof file.content === 'string') {
       file.content = convertBase64ToBlob(file.content);
     }
-
     const {
       content,
       name = '',
       // name property is not available in base64 image
       collection
     } = file;
-
     if (!uploadableFileUpfrontIds) {
       uploadableFileUpfrontIds = this.generateUploadableFileUpfrontIds(collection, traceContext);
     }
-
     const id = uploadableFileUpfrontIds.id;
     const occurrenceKey = uploadableFileUpfrontIds.occurrenceKey;
     let mimeType = '';
     let size = 0;
-    let preview; // TODO [MSW-796]: get file size for base64
-
+    let preview;
+    // TODO [MSW-796]: get file size for base64
     const mediaType = getMediaTypeFromUploadableFile(file);
     const subject = createMediaSubject();
     const processingSubscription = new Subscription();
-
     if (content instanceof Blob) {
       size = content.size;
       mimeType = content.type;
-
       if (isMimeTypeSupportedByBrowser(content.type)) {
         preview = {
           value: content,
@@ -246,7 +314,6 @@ export class FileFetcherImpl {
         };
       }
     }
-
     const stateBase = {
       id,
       occurrenceKey,
@@ -256,7 +323,6 @@ export class FileFetcherImpl {
       mimeType,
       preview
     };
-
     const onProgress = progress => {
       subject.next({
         status: 'uploading',
@@ -264,21 +330,19 @@ export class FileFetcherImpl {
         progress
       });
     };
-
     const onUploadFinish = error => {
       if (error) {
         return subject.error(error);
       }
-
       processingSubscription.add(shouldFetchRemoteFileStatesObservable(mediaType, mimeType, preview).pipe(concatMap(shouldFetchRemoteFileStates => {
         if (shouldFetchRemoteFileStates) {
-          return this.createDownloadFileStream(id, collection, occurrenceKey).pipe(map(remoteFileState => ({ // merges base state with remote state
+          return this.createDownloadFileStream(id, collection, occurrenceKey).pipe(map(remoteFileState => ({
+            // merges base state with remote state
             ...stateBase,
             ...remoteFileState,
             ...overrideMediaTypeIfUnknown(remoteFileState, mediaType)
           })));
         }
-
         return of({
           status: 'processing',
           representations: {},
@@ -286,31 +350,36 @@ export class FileFetcherImpl {
         });
       })).subscribe(subject));
     };
-
     const {
       cancel
     } = uploadFile(file, this.mediaStore, uploadableFileUpfrontIds, {
       onUploadFinish,
       onProgress
     }, traceContext);
-    getFileStreamsCache().set(id, subject); // We should report progress asynchronously, since this is what consumer expects
-    // (otherwise in newUploadService file-converting event will be emitted before files-added)
+    getFileStreamsCache().set(id, subject);
 
+    // We should report progress asynchronously, since this is what consumer expects
+    // (otherwise in newUploadService file-converting event will be emitted before files-added)
     setTimeout(() => {
       onProgress(0);
     }, 0);
-
     if (controller) {
       controller.setAbort(() => {
         cancel();
         processingSubscription.unsubscribe();
       });
     }
-
     return fromObservable(subject);
-  } // TODO: ----- ADD TICKET
-
+  }
+  upload(file, controller, uploadableFileUpfrontIds, traceContext) {
+    const shouldAlwaysFetchFileState = getMediaFeatureFlag('fetchFileStateAfterUpload', this.featureFlags);
+    if (shouldAlwaysFetchFileState) {
+      return this.uploadAwlaysPullFileStates(file, controller, uploadableFileUpfrontIds, traceContext);
+    }
+    return this.uploadConditionallyPullFileStates(file, controller, uploadableFileUpfrontIds, traceContext);
+  }
 
+  // TODO: ----- ADD TICKET
   async downloadBinary(id, name = 'download', collectionName) {
     const url = await this.mediaStore.getFileBinaryURL(id, collectionName);
     downloadUrl(url, {
@@ -322,7 +391,6 @@ export class FileFetcherImpl {
       viewingLevel: 'download'
     });
   }
-
   async copyFile(source, destination, options = {}, traceContext) {
     const {
       authProvider,
@@ -359,13 +427,14 @@ export class FileFetcherImpl {
     };
     const cache = getFileStreamsCache();
     let processingSubscription;
-
     try {
       const {
         data: copiedFile
-      } = await mediaStore.copyFileWithToken(body, params, traceContext); // if we were passed a "mimeType", we propagate it into copiedFileWithMimeType
+      } = await mediaStore.copyFileWithToken(body, params, traceContext);
 
-      const copiedFileWithMimeType = { ...copiedFile,
+      // if we were passed a "mimeType", we propagate it into copiedFileWithMimeType
+      const copiedFileWithMimeType = {
+        ...copiedFile,
         ...(mimeType ? {
           mimeType
         } : undefined)
@@ -373,29 +442,33 @@ export class FileFetcherImpl {
       const {
         id: copiedId,
         mimeType: copiedMimeType
-      } = copiedFileWithMimeType; // backend may return an "unknown" mediaType just after the copy
-      // it's better to deduce it from "copiedMimeType" using getMediaTypeFromMimeType()
+      } = copiedFileWithMimeType;
 
+      // backend may return an "unknown" mediaType just after the copy
+      // it's better to deduce it from "copiedMimeType" using getMediaTypeFromMimeType()
       const mediaType = copiedMimeType ? getMediaTypeFromMimeType(copiedMimeType) : 'unknown';
       const copiedFileState = mapMediaFileToFileState({
         data: copiedFileWithMimeType
       });
       const fileCache = cache.get(copiedId);
-      const subject = fileCache || createMediaSubject(); // if we were passed a "preview", we propagate it into the copiedFileState
+      const subject = fileCache || createMediaSubject();
 
+      // if we were passed a "preview", we propagate it into the copiedFileState
       const previewOverride = !isErrorFileState(copiedFileState) && !!preview ? {
         preview
       } : {};
-
-      if (!isFinalFileState(copiedFileState) && // mimeType should always be returned by "copyFileWithToken"
+      if (!isFinalFileState(copiedFileState) &&
+      // mimeType should always be returned by "copyFileWithToken"
       // but in case it's not, we don't want to penalize "copyFile"
       copiedMimeType && (await shouldFetchRemoteFileStates(mediaType, copiedMimeType, preview))) {
-        subject.next({ ...copiedFileState,
+        subject.next({
+          ...copiedFileState,
           ...overrideMediaTypeIfUnknown(copiedFileState, mediaType),
           ...previewOverride
         });
         processingSubscription = this.createDownloadFileStream(copiedId, destinationCollectionName, occurrenceKey).subscribe({
-          next: remoteFileState => subject.next({ ...remoteFileState,
+          next: remoteFileState => subject.next({
+            ...remoteFileState,
             ...overrideMediaTypeIfUnknown(remoteFileState, mediaType),
             ...(!isErrorFileState(remoteFileState) && previewOverride)
           }),
@@ -403,24 +476,21 @@ export class FileFetcherImpl {
           complete: () => subject.complete()
         });
       } else if (!isProcessingFileState(copiedFileState)) {
-        subject.next({ ...copiedFileState,
+        subject.next({
+          ...copiedFileState,
           ...(!isErrorFileState(copiedFileState) && previewOverride)
         });
       }
-
       if (!cache.has(copiedId)) {
         getFileStreamsCache().set(copiedId, subject);
       }
-
       return copiedFile;
     } catch (error) {
       if (processingSubscription) {
         processingSubscription.unsubscribe();
       }
-
       if (replaceFileId) {
         const fileCache = cache.get(replaceFileId);
-
         if (fileCache) {
           fileCache.error(error);
         } else {
@@ -428,9 +498,7 @@ export class FileFetcherImpl {
           cache.set(id, createMediaSubject(error));
         }
       }
-
       throw error;
     }
   }
-
 }

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

@@ -5,7 +5,9 @@ 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;
     this.featureFlags = featureFlags;
@@ -15,49 +17,37 @@ export class MediaClient {
     }, featureFlags);
     this.config = mediaClientConfig;
     this.collection = new CollectionFetcher(this.mediaStore);
-    this.file = new FileFetcherImpl(this.mediaStore);
+    this.file = new FileFetcherImpl(this.mediaStore, featureFlags);
     this.eventEmitter = new EventEmitter2();
     this.stargate = new StargateClient(mediaClientConfig.stargateBaseUrl);
   }
-
   getImage(id, params, controller, fetchMaxRes, traceContext) {
     return this.mediaStore.getImage(id, params, controller, fetchMaxRes, traceContext);
   }
-
   getImageUrl(id, params) {
     return this.mediaStore.getFileImageURL(id, params);
   }
-
   getImageUrlSync(id, params) {
     return this.mediaStore.getFileImageURLSync(id, params);
   }
-
   async getImageMetadata(id, params) {
     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');
+    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);
   }
-
   off(event, listener) {
     this.eventEmitter.off(event, listener);
   }
-
   emit(event, payload) {
     return this.eventEmitter.emit(event, payload);
   }
-
 }

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

@@ -5,7 +5,6 @@ export class MediaStoreError extends BaseMediaClientError {
     this.reason = reason;
     this.innerError = innerError;
   }
-
   get attributes() {
     const {
       reason,
@@ -16,7 +15,6 @@ export class MediaStoreError extends BaseMediaClientError {
       innerError
     };
   }
-
 }
 export function isMediaStoreError(err) {
   return err instanceof MediaStoreError;