@atlaskit/media-client 15.1.1 → 17.0.0

package/dist/cjs/utils/request/helpers.js

@@ -14,7 +14,7 @@ exports.createProcessFetchResponse = createProcessFetchResponse;
 exports.createRequestErrorFromResponse = createRequestErrorFromResponse;
 exports.createRequestErrorReason = createRequestErrorReason;
 exports.createUrl = createUrl;
-exports.extract = extract;
+exports.extractMediaHeaders = extractMediaHeaders;
 exports.fetchRetry = fetchRetry;
 exports.isAbortedRequestError = isAbortedRequestError;
 exports.isFetchNetworkError = isFetchNetworkError;
@@ -30,12 +30,14 @@ var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"))
 
 var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
 
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
 var _mediaCore = require("@atlaskit/media-core");
 
-var _queryString = require("query-string");
-
 var _authQueryParameters = require("../../models/auth-query-parameters");
 
 var _errors = require("./errors");
@@ -69,21 +71,6 @@ function isRateLimitedError(error) {
   return !!error && (0, _errors.isRequestError)(error) && error.attributes.statusCode === 429 || !!error && !!error.message && error.message.includes('429');
 }
 
-function extract(url) {
-  var index = url.indexOf('?');
-
-  if (index > 0) {
-    return {
-      baseUrl: url.substring(0, index),
-      queryParams: (0, _queryString.parse)(url.substring(index + 1, url.length))
-    };
-  } else {
-    return {
-      baseUrl: url
-    };
-  }
-}
-
 function mapAuthToRequestHeaders(auth) {
   if ((0, _mediaCore.isClientBasedAuth)(auth)) {
     return {
@@ -101,15 +88,24 @@ function mapAuthToRequestHeaders(auth) {
 function createUrl(url, _ref) {
   var params = _ref.params,
       auth = _ref.auth;
+  var parsedUrl = new URL(url);
+  var authParams = auth && (0, _authQueryParameters.mapAuthToQueryParameters)(auth) || {};
+
+  var paramsToAppend = _objectSpread(_objectSpread({}, params), authParams);
 
-  var _extract = extract(url),
-      baseUrl = _extract.baseUrl,
-      queryParams = _extract.queryParams;
+  Object.entries(paramsToAppend).filter(function (_ref2) {
+    var _ref3 = (0, _slicedToArray2.default)(_ref2, 2),
+        _ = _ref3[0],
+        value = _ref3[1];
 
-  var authParams = auth && (0, _authQueryParameters.mapAuthToQueryParameters)(auth);
-  var queryString = (0, _queryString.stringify)(_objectSpread(_objectSpread(_objectSpread({}, queryParams), params), authParams));
-  var shouldAppendQueryString = queryString.length > 0;
-  return "".concat(baseUrl).concat(shouldAppendQueryString ? "?".concat(queryString) : '');
+    return value != null;
+  }).forEach(function (pair) {
+    var _parsedUrl$searchPara;
+
+    (_parsedUrl$searchPara = parsedUrl.searchParams).append.apply(_parsedUrl$searchPara, (0, _toConsumableArray2.default)(pair));
+  });
+  parsedUrl.searchParams.sort();
+  return parsedUrl.toString();
 }
 
 function withAuth(auth) {
@@ -217,7 +213,7 @@ function mapResponseToVoid() {
 
 function createMapResponseToJson(metadata) {
   return /*#__PURE__*/function () {
-    var _ref2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(response) {
+    var _ref4 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(response) {
       return _regenerator.default.wrap(function _callee$(_context) {
         while (1) {
           switch (_context.prev = _context.next) {
@@ -232,7 +228,7 @@ function createMapResponseToJson(metadata) {
             case 6:
               _context.prev = 6;
               _context.t0 = _context["catch"](0);
-              throw new _errors.RequestError('serverInvalidBody', _objectSpread(_objectSpread({}, metadata), {}, {
+              throw new _errors.RequestError('serverInvalidBody', _objectSpread(_objectSpread(_objectSpread({}, metadata), extractMediaHeaders(response)), {}, {
                 statusCode: response.status
               }), _context.t0);
 
@@ -245,14 +241,14 @@ function createMapResponseToJson(metadata) {
     }));
 
     return function (_x3) {
-      return _ref2.apply(this, arguments);
+      return _ref4.apply(this, arguments);
     };
   }();
 }
 
 function createMapResponseToBlob(metadata) {
   return /*#__PURE__*/function () {
-    var _ref3 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(response) {
+    var _ref5 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(response) {
       return _regenerator.default.wrap(function _callee2$(_context2) {
         while (1) {
           switch (_context2.prev = _context2.next) {
@@ -267,7 +263,7 @@ function createMapResponseToBlob(metadata) {
             case 6:
               _context2.prev = 6;
               _context2.t0 = _context2["catch"](0);
-              throw new _errors.RequestError('serverInvalidBody', _objectSpread(_objectSpread({}, metadata), {}, {
+              throw new _errors.RequestError('serverInvalidBody', _objectSpread(_objectSpread(_objectSpread({}, metadata), extractMediaHeaders(response)), {}, {
                 statusCode: response.status
               }), _context2.t0);
 
@@ -280,7 +276,7 @@ function createMapResponseToBlob(metadata) {
     }));
 
     return function (_x4) {
-      return _ref3.apply(this, arguments);
+      return _ref5.apply(this, arguments);
     };
   }();
 }
@@ -329,7 +325,7 @@ function _fetchRetry() {
             timeoutInMs = startTimeoutInMs;
 
             waitAndBumpTimeout = /*#__PURE__*/function () {
-              var _ref4 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5() {
+              var _ref6 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5() {
                 return _regenerator.default.wrap(function _callee5$(_context5) {
                   while (1) {
                     switch (_context5.prev = _context5.next) {
@@ -350,7 +346,7 @@ function _fetchRetry() {
               }));
 
               return function waitAndBumpTimeout() {
-                return _ref4.apply(this, arguments);
+                return _ref6.apply(this, arguments);
               };
             }();
 
@@ -453,7 +449,7 @@ function createRequestErrorReason(statusCode) {
 function createRequestErrorFromResponse(metadata, response) {
   var statusCode = response.status;
   var reason = createRequestErrorReason(statusCode);
-  return new _errors.RequestError(reason, _objectSpread(_objectSpread({}, metadata), {}, {
+  return new _errors.RequestError(reason, _objectSpread(_objectSpread(_objectSpread({}, metadata), extractMediaHeaders(response)), {}, {
     statusCode: statusCode
   }));
 }
@@ -467,4 +463,14 @@ function createProcessFetchResponse(metadata) {
     var requestError = createRequestErrorFromResponse(metadata, response);
     throw requestError;
   };
+}
+
+function extractMediaHeaders(response) {
+  var headers = response.headers;
+  var mediaRegion = headers.get('x-media-region') || 'unknown';
+  var mediaEnv = headers.get('x-media-env') || 'unknown';
+  return {
+    mediaRegion: mediaRegion,
+    mediaEnv: mediaEnv
+  };
 }

package/dist/cjs/version.json

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

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

@@ -5,6 +5,8 @@ import { request } from '../../utils/request';
 import { createUrl, createMapResponseToJson, createMapResponseToBlob } from '../../utils/request/helpers';
 import { resolveAuth, resolveInitialAuth } from './resolveAuth';
 export { MediaStoreError, isMediaStoreError } from './error';
+const MEDIA_API_REGION = 'media-api-region';
+const MEDIA_API_ENVIRONMENT = 'media-api-environment';
 const defaultImageOptions = {
   'max-age': FILE_CACHE_MAX_AGE,
   allowAnimated: true,
@@ -120,12 +122,20 @@ export class MediaStore {
     return this.request(`/upload`, options).then(createMapResponseToJson(metadata));
   }
 
-  async uploadChunk(etag, blob, collectionName) {
+  async uploadChunk(etag, blob, {
+    collectionName,
+    uploadId,
+    partNumber
+  } = {}) {
     const metadata = {
       method: 'PUT',
       endpoint: '/chunk/{etag}'
     };
     const options = { ...metadata,
+      params: {
+        uploadId,
+        partNumber
+      },
       authContext: {
         collectionName
       },
@@ -134,12 +144,18 @@ export class MediaStore {
     await this.request(`/chunk/${etag}`, options);
   }
 
-  probeChunks(chunks, collectionName) {
+  probeChunks(chunks, {
+    collectionName,
+    uploadId
+  } = {}) {
     const metadata = {
       method: 'POST',
       endpoint: '/chunk/probe'
     };
     const options = { ...metadata,
+      params: {
+        uploadId
+      },
       authContext: {
         collectionName
       },
@@ -373,20 +389,32 @@ export class MediaStore {
       body,
       clientOptions
     }, controller);
-    updateMediaRegion(response.headers.get('x-media-region'));
+    setKeyValueInSessionStorage(MEDIA_API_REGION, response.headers.get('x-media-region'));
+    setKeyValueInSessionStorage(MEDIA_API_ENVIRONMENT, response.headers.get('x-media-env'));
     return response;
   }
 
 }
 
-function updateMediaRegion(region) {
-  if (!region || !(window && window.sessionStorage)) {
+const getValueFromSessionStorage = key => {
+  return window && window.sessionStorage && window.sessionStorage.getItem(key) || undefined;
+};
+
+const setKeyValueInSessionStorage = (key, value) => {
+  if (!value || !(window && window.sessionStorage)) {
     return;
   }
 
-  const currentRegion = window.sessionStorage.getItem('media-api-region');
+  const currentValue = window.sessionStorage.getItem(key);
 
-  if (currentRegion !== region) {
-    window.sessionStorage.setItem('media-api-region', region);
+  if (currentValue !== value) {
+    window.sessionStorage.setItem(key, value);
   }
-}
+};
+
+export const getMediaEnvironment = () => {
+  return getValueFromSessionStorage(MEDIA_API_ENVIRONMENT);
+};
+export const getMediaRegion = () => {
+  return getValueFromSessionStorage(MEDIA_API_REGION);
+};

package/dist/es2019/constants.js

@@ -1,4 +1,8 @@
+import { DATA_UNIT } from './models/media';
 export const RECENTS_COLLECTION = 'recents';
 export const FILE_CACHE_MAX_AGE = 60 * 60 * 24 * 30; // Retain for 30 days
 
-export const MAX_RESOLUTION = 4096;
+export const MAX_RESOLUTION = 4096;
+export const CHUNK_SIZE = 4 * DATA_UNIT.MB;
+export const PROCESSING_BATCH_SIZE = 1000;
+export const MAX_UPLOAD_FILE_SIZE = 2 * DATA_UNIT.TB;

package/dist/es2019/index.js

@@ -1,11 +1,11 @@
-export { MediaStore, MediaStoreError, isMediaStoreError } from './client/media-store';
+export { MediaStore, MediaStoreError, isMediaStoreError, getMediaEnvironment, getMediaRegion } from './client/media-store';
 export { UploadController } from './upload-controller';
 export { isPreviewableType, isMediaCollectionItemFullDetails } from './models/media';
 export { getArtifactUrl } from './models/artifacts';
 export { isMediaClientError, getMediaClientErrorReason } from './models/errors';
 export { isUploadingFileState, isProcessingFileState, isProcessedFileState, isErrorFileState, isPreviewableFileState, isFinalFileState, isImageRepresentationReady, mapMediaFileToFileState, mapMediaItemToFileState } from './models/file-state';
 // TODO: remove access to media file stream cache https://product-fabric.atlassian.net/browse/MEX-1417
-export { getFileStreamsCache, StreamsCache } from './file-streams-cache';
+export { StreamsCache } from './file-streams-cache';
 export { uploadFile } from './uploader';
 export { request, RequestError, isRequestError, isRateLimitedError } from './utils/request';
 export { isAbortedRequestError, mapResponseToJson, mapResponseToBlob, mapResponseToVoid, createUrl } from './utils/request/helpers';

package/dist/es2019/models/media.js

@@ -9,4 +9,11 @@ export const isPreviewableType = (type, featureFlags) => {
 
   return defaultPreviewableTypes.indexOf(type) > -1;
 };
-export const isMediaCollectionItemFullDetails = mediaCollectionItem => !!mediaCollectionItem['mediaType'] && !!mediaCollectionItem['mimeType'] && !!mediaCollectionItem['processingStatus'];
+export const isMediaCollectionItemFullDetails = mediaCollectionItem => !!mediaCollectionItem['mediaType'] && !!mediaCollectionItem['mimeType'] && !!mediaCollectionItem['processingStatus'];
+export let DATA_UNIT;
+
+(function (DATA_UNIT) {
+  DATA_UNIT[DATA_UNIT["MB"] = 1048576] = "MB";
+  DATA_UNIT[DATA_UNIT["GB"] = 1073741824] = "GB";
+  DATA_UNIT[DATA_UNIT["TB"] = 1099511627776] = "TB";
+})(DATA_UNIT || (DATA_UNIT = {}));

package/dist/es2019/uploader/calculateChunkSize.js

@@ -0,0 +1,32 @@
+import { DATA_UNIT } from '../models/media';
+import { MAX_UPLOAD_FILE_SIZE } from '../constants';
+export const fileSizeError = 'fileSizeExceedsLimit';
+/**
+ * This is a helper to dynamically calculate the chunk size for a given file size.
+ *
+ * @param fileSize The size of a file to calculate the chunk size for.
+ * @returns A number of bytes per chunk or Throws an Error if the file size exceeds 2TB
+ *
+ * @see {@link https://product-fabric.atlassian.net/wiki/spaces/FIL/pages/3221881143/Rule+of+thumb+for+chunk+sizes#Given-the-following-conditions}
+ *
+ */
+
+export const calculateChunkSize = fileSize => {
+  if (fileSize > MAX_UPLOAD_FILE_SIZE) {
+    throw new Error(fileSizeError);
+  }
+
+  if (fileSize <= 5 * DATA_UNIT.GB) {
+    return 5 * DATA_UNIT.MB;
+  }
+
+  if (fileSize > 5 * DATA_UNIT.GB && fileSize <= 50 * DATA_UNIT.GB) {
+    return 50 * DATA_UNIT.MB;
+  }
+
+  if (fileSize > 50 * DATA_UNIT.GB && fileSize <= 0.95 * DATA_UNIT.TB) {
+    return 100 * DATA_UNIT.MB;
+  }
+
+  return 210 * DATA_UNIT.MB;
+};

package/dist/es2019/uploader/error.js

@@ -0,0 +1,30 @@
+import { BaseMediaClientError } from '../models/errors';
+export class UploaderError 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 isUploaderError(err) {
+  return err instanceof UploaderError;
+}

package/dist/es2019/{uploader.js → uploader/index.js}

@@ -1,21 +1,29 @@
 import { chunkinator } from '@atlaskit/chunkinator';
 import { from } from 'rxjs/observable/from';
 import { concatMap } from 'rxjs/operators/concatMap';
-import { createHasher } from './utils/hashing/hasherCreator'; // TODO: Allow to pass multiple files
+import { createHasher } from '../utils/hashing/hasherCreator';
+import { UploaderError } from './error';
+import { CHUNK_SIZE, PROCESSING_BATCH_SIZE } from '../constants';
+import { calculateChunkSize, fileSizeError } from './calculateChunkSize';
+import { getMediaFeatureFlag } from '@atlaskit/media-common'; // TODO: Allow to pass multiple files
 
 const hashingFunction = async blob => {
   const hasher = await createHasher();
   return hasher.hash(blob);
 };
 
-const createProbingFunction = (store, collection) => async chunks => {
-  const response = await store.probeChunks(hashedChunks(chunks), collection);
+const createProbingFunction = (store, collectionName) => async chunks => {
+  const response = await store.probeChunks(hashedChunks(chunks), {
+    collectionName
+  });
   const results = response.data.results;
   return Object.values(results).map(result => result.exists);
 };
 
-const createUploadingFunction = (store, collection) => {
-  return chunk => store.uploadChunk(chunk.hash, chunk.blob, collection);
+const createUploadingFunction = (store, collectionName) => {
+  return chunk => store.uploadChunk(chunk.hash, chunk.blob, {
+    collectionName
+  });
 };
 
 const createProcessingFunction = (store, deferredUploadId, collection) => {
@@ -56,17 +64,40 @@ export const uploadFile = (file, store, uploadableFileUpfrontIds, callbacks) =>
     collection
   } = file;
   const {
-    deferredUploadId
+    deferredUploadId,
+    id,
+    occurrenceKey
   } = uploadableFileUpfrontIds;
+  let chunkSize = CHUNK_SIZE;
+
+  try {
+    if (content instanceof Blob && getMediaFeatureFlag('mediaUploadApiV2', store.featureFlags)) {
+      chunkSize = calculateChunkSize(content.size);
+    }
+  } catch (err) {
+    if (err instanceof Error && err.message === fileSizeError) {
+      callbacks === null || callbacks === void 0 ? void 0 : callbacks.onUploadFinish(new UploaderError(err.message, id, {
+        collectionName: collection,
+        occurrenceKey: occurrenceKey
+      }));
+    }
+
+    return {
+      cancel: () => {
+        callbacks === null || callbacks === void 0 ? void 0 : callbacks.onUploadFinish('canceled');
+      }
+    };
+  }
+
   const chunkinatorObservable = chunkinator(content, {
     hashingFunction,
     hashingConcurrency: 5,
     probingBatchSize: 100,
-    chunkSize: 4 * 1024 * 1024,
+    chunkSize,
     uploadingConcurrency: 3,
     uploadingFunction: createUploadingFunction(store, collection),
     probingFunction: createProbingFunction(store, collection),
-    processingBatchSize: 1000,
+    processingBatchSize: PROCESSING_BATCH_SIZE,
     processingFunction: createProcessingFunction(store, deferredUploadId, collection)
   }, {
     onProgress(progress) {

package/dist/es2019/utils/request/errors.js

@@ -13,6 +13,8 @@ export class RequestError extends BaseMediaClientError {
       metadata: {
         method,
         endpoint,
+        mediaRegion,
+        mediaEnv,
         attempts,
         clientExhaustedRetries,
         statusCode
@@ -23,6 +25,8 @@ export class RequestError extends BaseMediaClientError {
       reason,
       method,
       endpoint,
+      mediaRegion,
+      mediaEnv,
       attempts,
       clientExhaustedRetries,
       statusCode,

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

@@ -1,5 +1,4 @@
 import { isClientBasedAuth } from '@atlaskit/media-core';
-import { parse, stringify } from 'query-string';
 import { mapAuthToQueryParameters } from '../../models/auth-query-parameters';
 import { RequestError, isRequestError } from './errors';
 export function clientTimeoutPromise(timeout) {
@@ -20,20 +19,6 @@ export function isFetchNetworkError(err) {
 export function isRateLimitedError(error) {
   return !!error && isRequestError(error) && error.attributes.statusCode === 429 || !!error && !!error.message && error.message.includes('429');
 }
-export function extract(url) {
-  const index = url.indexOf('?');
-
-  if (index > 0) {
-    return {
-      baseUrl: url.substring(0, index),
-      queryParams: parse(url.substring(index + 1, url.length))
-    };
-  } else {
-    return {
-      baseUrl: url
-    };
-  }
-}
 export function mapAuthToRequestHeaders(auth) {
   if (isClientBasedAuth(auth)) {
     return {
@@ -51,17 +36,16 @@ export function createUrl(url, {
   params,
   auth
 }) {
-  const {
-    baseUrl,
-    queryParams
-  } = extract(url);
-  const authParams = auth && mapAuthToQueryParameters(auth);
-  const queryString = stringify({ ...queryParams,
-    ...params,
+  const parsedUrl = new URL(url);
+  const authParams = auth && mapAuthToQueryParameters(auth) || {};
+  const paramsToAppend = { ...params,
     ...authParams
+  };
+  Object.entries(paramsToAppend).filter(([_, value]) => value != null).forEach(pair => {
+    parsedUrl.searchParams.append(...pair);
   });
-  const shouldAppendQueryString = queryString.length > 0;
-  return `${baseUrl}${shouldAppendQueryString ? `?${queryString}` : ''}`;
+  parsedUrl.searchParams.sort();
+  return parsedUrl.toString();
 }
 export function withAuth(auth) {
   return headers => {
@@ -124,6 +108,7 @@ export function createMapResponseToJson(metadata) {
       return await response.json();
     } catch (err) {
       throw new RequestError('serverInvalidBody', { ...metadata,
+        ...extractMediaHeaders(response),
         statusCode: response.status
       }, err);
     }
@@ -135,6 +120,7 @@ export function createMapResponseToBlob(metadata) {
       return await response.blob();
     } catch (err) {
       throw new RequestError('serverInvalidBody', { ...metadata,
+        ...extractMediaHeaders(response),
         statusCode: response.status
       }, err);
     }
@@ -240,6 +226,7 @@ export function createRequestErrorFromResponse(metadata, response) {
   } = response;
   const reason = createRequestErrorReason(statusCode);
   return new RequestError(reason, { ...metadata,
+    ...extractMediaHeaders(response),
     statusCode
   });
 }
@@ -252,4 +239,15 @@ export function createProcessFetchResponse(metadata) {
     const requestError = createRequestErrorFromResponse(metadata, response);
     throw requestError;
   };
+}
+export function extractMediaHeaders(response) {
+  const {
+    headers
+  } = response;
+  const mediaRegion = headers.get('x-media-region') || 'unknown';
+  const mediaEnv = headers.get('x-media-env') || 'unknown';
+  return {
+    mediaRegion,
+    mediaEnv
+  };
 }

package/dist/es2019/version.json

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

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

@@ -285,7 +285,6 @@ export var FileFetcherImpl = /*#__PURE__*/function () {
                             };
                             mediaType = getMediaTypeFromMimeType(type); // we emit a richer state after the blob is fetched
 
-                            // we emit a richer state after the blob is fetched
                             subject.next({
                               status: 'processing',
                               name: name,
@@ -297,7 +296,6 @@ export var FileFetcherImpl = /*#__PURE__*/function () {
                               preview: 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
                             _this3.upload(file, undefined, uploadableFileUpfrontIds);
 
                             _context3.next = 12;