@atlaskit/media-client 32.0.2 → 33.1.0

package/dist/cjs/utils/hashing/hasherCreator.js

@@ -5,7 +5,7 @@ var _typeof = require("@babel/runtime/helpers/typeof");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.destroyHasher = exports.createHasher = void 0;
+exports.destroyHashers = exports.createHasher = void 0;
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
 var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
 var _mediaCore = require("@atlaskit/media-core");
@@ -13,18 +13,19 @@ function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 var hasher = null;
 var sha256Hasher = null;
-var destroyHasher = exports.destroyHasher = function destroyHasher() {
-  return hasher = null;
+var destroyHashers = exports.destroyHashers = function destroyHashers() {
+  hasher = null;
+  sha256Hasher = null;
 };
 var createHasher = exports.createHasher = /*#__PURE__*/function () {
   var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(algorithm) {
-    var numWorkers, _yield$import, SimpleHasher, _yield$import2, WorkerHasher, _yield$import3, _SimpleHasher;
+    var _yield$import, _SimpleHasher, _yield$import2, SimpleHasher;
     return _regenerator.default.wrap(function _callee$(_context) {
       while (1) switch (_context.prev = _context.next) {
         case 0:
-          numWorkers = 3;
+          _context.prev = 0;
           if (!(algorithm === _mediaCore.ChunkHashAlgorithm.Sha256)) {
-            _context.next = 11;
+            _context.next = 9;
             break;
           }
           if (sha256Hasher) {
@@ -37,44 +38,31 @@ var createHasher = exports.createHasher = /*#__PURE__*/function () {
           });
         case 5:
           _yield$import = _context.sent;
-          SimpleHasher = _yield$import.SimpleHasher;
-          sha256Hasher = new SimpleHasher();
+          _SimpleHasher = _yield$import.SimpleHasher;
+          sha256Hasher = new _SimpleHasher();
         case 8:
           return _context.abrupt("return", sha256Hasher);
+        case 9:
+          _context.next = 13;
+          break;
         case 11:
-          if (hasher) {
-            _context.next = 27;
-            break;
-          }
-          _context.prev = 12;
+          _context.prev = 11;
+          _context.t0 = _context["catch"](0);
+        case 13:
           _context.next = 15;
           return Promise.resolve().then(function () {
-            return _interopRequireWildcard(require('./workerHasher'));
+            return _interopRequireWildcard(require('./simpleHasher'));
           });
         case 15:
           _yield$import2 = _context.sent;
-          WorkerHasher = _yield$import2.WorkerHasher;
-          hasher = new WorkerHasher(numWorkers);
-          _context.next = 27;
-          break;
-        case 20:
-          _context.prev = 20;
-          _context.t0 = _context["catch"](12);
-          _context.next = 24;
-          return Promise.resolve().then(function () {
-            return _interopRequireWildcard(require('./simpleHasher'));
-          });
-        case 24:
-          _yield$import3 = _context.sent;
-          _SimpleHasher = _yield$import3.SimpleHasher;
-          hasher = new _SimpleHasher();
-        case 27:
+          SimpleHasher = _yield$import2.SimpleHasher;
+          hasher = new SimpleHasher();
           return _context.abrupt("return", hasher);
-        case 28:
+        case 19:
         case "end":
           return _context.stop();
       }
-    }, _callee, null, [[12, 20]]);
+    }, _callee, null, [[0, 11]]);
   }));
   return function createHasher(_x) {
     return _ref.apply(this, arguments);

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

@@ -97,7 +97,7 @@ function createUrl(url, _ref2) {
     return value != null;
   }).forEach(function (pair) {
     var _parsedUrl$searchPara;
-    (_parsedUrl$searchPara = parsedUrl.searchParams).append.apply(_parsedUrl$searchPara, (0, _toConsumableArray2.default)(pair));
+    (_parsedUrl$searchPara = parsedUrl.searchParams).set.apply(_parsedUrl$searchPara, (0, _toConsumableArray2.default)(pair));
   });
   parsedUrl.searchParams.sort();
   return parsedUrl.toString();

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

@@ -140,6 +140,21 @@ export class FileFetcherImpl {
         preview
       };
     });
+    _defineProperty(this, "uploadArtifact", async (id, file, params, collectionName, traceContext) => {
+      const {
+        data
+      } = await this.mediaApi.uploadArtifact(id, file, params, collectionName, traceContext);
+
+      /* TEMPORARYLY PULLING NEW METADATA till the endpoint is fixed */
+      const {
+        data: altData
+      } = await this.mediaApi.getItems([id], collectionName, traceContext);
+      const itemDetails = altData.items[0].details;
+      // ------------------------------------------------------------
+
+      this.setFileState(id, mapMediaItemToFileState(id, itemDetails));
+      return data;
+    });
     this.mediaApi = mediaApi;
     this.store = store;
     this.dataloader = createFileDataloader(mediaApi);

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

@@ -15,7 +15,7 @@ export class MediaClient {
     this.mediaStore = mediaApi !== null && mediaApi !== void 0 ? mediaApi : new MediaApi({
       authProvider: mediaClientConfig.authProvider,
       initialAuth: mediaClientConfig.initialAuth,
-      chunkHashAlgorithm: mediaClientConfig.useSha256ForUploads ? ChunkHashAlgorithm.Sha256 : ChunkHashAlgorithm.Sha1,
+      chunkHashAlgorithm: ChunkHashAlgorithm.Sha256,
       authProviderTimeout: mediaClientConfig.authProviderTimeoutMs
     });
     this.config = mediaClientConfig;

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

@@ -30,19 +30,66 @@ const jsonHeaders = {
 };
 const cdnFeatureFlag = endpoint => {
   let result = endpoint;
-  if (fg('platform_media_cdn_delivery')) {
-    if (isCommercial()) {
-      result += '/cdn';
-    }
+  if (isCommercial() && fg('platform_media_cdn_delivery')) {
+    result += '/cdn';
   }
   return result;
 };
 export class MediaStore {
   constructor(config) {
+    _defineProperty(this, "getArtifactBinary", async (artifacts, artifactName, {
+      collectionName,
+      abortController,
+      maxAge = FILE_CACHE_MAX_AGE,
+      traceContext
+    }) => {
+      const metadata = {
+        method: 'GET',
+        endpoint: `artifact-cdn-url`
+      };
+      const extendedTraceContext = extendTraceContext(traceContext);
+      const options = {
+        ...metadata,
+        traceContext: extendedTraceContext
+      };
+      const artifactUrl = await this.getArtifactURL(artifacts, artifactName, collectionName, maxAge);
+      return request(artifactUrl, options, abortController).then(createMapResponseToBlob(metadata));
+    });
+    _defineProperty(this, "uploadArtifact", async (id, file, params, collectionName, traceContext) => {
+      const metadata = {
+        method: 'POST',
+        endpoint: '/file/{fileId}/artifact/binary'
+      };
+      const headers = {
+        Accept: 'application/json',
+        'Content-Type': file.type
+      };
+      const extendedParams = {
+        ...params,
+        name: file.name
+      };
+      const authContext = {
+        collectionName,
+        access: [{
+          type: 'file',
+          id,
+          actions: ['update']
+        }]
+      };
+      const options = {
+        ...metadata,
+        authContext,
+        headers,
+        params: extendedParams,
+        body: file,
+        traceContext
+      };
+      return this.request(`/file/${id}/artifact/binary`, options).then(createMapResponseToJson(metadata));
+    });
     _defineProperty(this, "resolveAuth", authContext => resolveAuth(this.config.authProvider, authContext, this.config.authProviderTimeout));
     _defineProperty(this, "resolveInitialAuth", () => resolveInitialAuth(this.config.initialAuth));
     this.config = config;
-    this._chunkHashAlgorithm = config.chunkHashAlgorithm || ChunkHashAlgorithm.Sha1;
+    this._chunkHashAlgorithm = config.chunkHashAlgorithm || ChunkHashAlgorithm.Sha256;
   }
   async removeCollectionFile(id, collectionName, occurrenceKey, traceContext) {
     const metadata = {
@@ -234,7 +281,16 @@ export class MediaStore {
     const binaryEndpoint = cdnFeatureFlag('binary');
     return mapToMediaCdnUrl(createUrl(`${auth.baseUrl}/file/${id}/${binaryEndpoint}`, options), auth.token);
   }
-  async getArtifactURL(artifacts, artifactName, collectionName) {
+  async getArtifactURL(artifacts, artifactName, collectionName, maxAge = FILE_CACHE_MAX_AGE) {
+    // getArtifactURL returns a constructed url PATH, not the full Media/CDN Url.
+    // We use the provided cdnUrl from metadata first.
+    if (isCommercial() && fg('platform_media_cdn_delivery')) {
+      var _artifacts$artifactNa;
+      const cdnUrl = (_artifacts$artifactNa = artifacts[artifactName]) === null || _artifacts$artifactNa === void 0 ? void 0 : _artifacts$artifactNa.cdnUrl;
+      if (cdnUrl) {
+        return cdnUrl;
+      }
+    }
     const artifactUrl = getArtifactUrl(artifacts, artifactName);
     if (!artifactUrl) {
       throw new Error(`artifact ${artifactName} not found`);
@@ -245,7 +301,7 @@ export class MediaStore {
     const options = {
       params: {
         collection: collectionName,
-        'max-age': FILE_CACHE_MAX_AGE
+        'max-age': maxAge
       },
       auth
     };

package/dist/es2019/utils/hashing/hasherCreator.js

@@ -1,30 +1,26 @@
 import { ChunkHashAlgorithm } from '@atlaskit/media-core';
 let hasher = null;
 let sha256Hasher = null;
-export const destroyHasher = () => hasher = null;
+export const destroyHashers = () => {
+  hasher = null;
+  sha256Hasher = null;
+};
 export const createHasher = async algorithm => {
-  const numWorkers = 3;
-  if (algorithm === ChunkHashAlgorithm.Sha256) {
-    if (!sha256Hasher) {
-      // TODO this needs to support worker sha256 hasher as well
-      const {
-        SimpleHasher
-      } = await import('./sha256SimpleHasher');
-      sha256Hasher = new SimpleHasher();
+  try {
+    if (algorithm === ChunkHashAlgorithm.Sha256) {
+      if (!sha256Hasher) {
+        // TODO this needs to support worker sha256 hasher as well
+        const {
+          SimpleHasher
+        } = await import('./sha256SimpleHasher');
+        sha256Hasher = new SimpleHasher();
+      }
+      return sha256Hasher;
     }
-    return sha256Hasher;
-  } else if (!hasher) {
-    try {
-      const {
-        WorkerHasher
-      } = await import('./workerHasher');
-      hasher = new WorkerHasher(numWorkers);
-    } catch (error) {
-      const {
-        SimpleHasher
-      } = await import('./simpleHasher');
-      hasher = new SimpleHasher();
-    }
-  }
+  } catch (error) {}
+  const {
+    SimpleHasher
+  } = await import('./simpleHasher');
+  hasher = new SimpleHasher();
   return hasher;
 };

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

@@ -64,7 +64,7 @@ export function createUrl(url, {
     ...authParams
   };
   Object.entries(paramsToAppend).filter(([_, value]) => value != null).forEach(pair => {
-    parsedUrl.searchParams.append(...pair);
+    parsedUrl.searchParams.set(...pair);
   });
   parsedUrl.searchParams.sort();
   return parsedUrl.toString();