@atlaskit/media-client 25.0.2 → 25.1.0

package/dist/cjs/test-helpers/index.js

@@ -64,6 +64,42 @@ Object.defineProperty(exports, "collectionNames", {
     return _collectionNames.collectionNames;
   }
 });
+Object.defineProperty(exports, "copy", {
+  enumerable: true,
+  get: function get() {
+    return _MockedMediaApi.copy;
+  }
+});
+Object.defineProperty(exports, "createEmptyFileItem", {
+  enumerable: true,
+  get: function get() {
+    return _MockedMediaApi.createEmptyFileItem;
+  }
+});
+Object.defineProperty(exports, "createErrorFileState", {
+  enumerable: true,
+  get: function get() {
+    return _MockedMediaApi.createErrorFileState;
+  }
+});
+Object.defineProperty(exports, "createFileState", {
+  enumerable: true,
+  get: function get() {
+    return _MockedMediaApi.createFileState;
+  }
+});
+Object.defineProperty(exports, "createMockedMediaApi", {
+  enumerable: true,
+  get: function get() {
+    return _MockedMediaApi.createMockedMediaApi;
+  }
+});
+Object.defineProperty(exports, "createProcessingFileItem", {
+  enumerable: true,
+  get: function get() {
+    return _MockedMediaApi.createProcessingFileItem;
+  }
+});
 Object.defineProperty(exports, "createStorybookMediaClient", {
   enumerable: true,
   get: function get() {
@@ -88,6 +124,12 @@ Object.defineProperty(exports, "createUploadMediaClientConfig", {
     return _mediaClientProvider.createUploadMediaClientConfig;
   }
 });
+Object.defineProperty(exports, "createUploadingFileState", {
+  enumerable: true,
+  get: function get() {
+    return _MockedMediaApi.createUploadingFileState;
+  }
+});
 Object.defineProperty(exports, "defaultBaseUrl", {
   enumerable: true,
   get: function get() {
@@ -202,6 +244,12 @@ Object.defineProperty(exports, "genericFileId", {
     return _exampleMediaItems.genericFileId;
   }
 });
+Object.defineProperty(exports, "getIdentifier", {
+  enumerable: true,
+  get: function get() {
+    return _MockedMediaApi.getIdentifier;
+  }
+});
 Object.defineProperty(exports, "gifFileId", {
   enumerable: true,
   get: function get() {
@@ -370,4 +418,5 @@ var _collectionNames = require("./collectionNames");
 var _exampleMediaItems = require("./exampleMediaItems");
 var _mediaPickerAuthProvider = require("./mediaPickerAuthProvider");
 var _fakeMediaClient = require("./fakeMediaClient");
+var _MockedMediaApi = require("./MockedMediaApi");
 var authProviderBaseURL = exports.authProviderBaseURL = 'https://media.dev.atl-paas.net';

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

@@ -0,0 +1,385 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { getRandomHex } from '@atlaskit/media-common';
+import { FILE_CACHE_MAX_AGE, MAX_RESOLUTION } from '../../constants';
+import { getArtifactUrl } from '../../models/artifacts';
+import { request } from '../../utils/request';
+import { createUrl, createMapResponseToJson, createMapResponseToBlob } from '../../utils/request/helpers';
+import { resolveAuth, resolveInitialAuth } from './resolveAuth';
+const MEDIA_API_REGION = 'media-api-region';
+const MEDIA_API_ENVIRONMENT = 'media-api-environment';
+const defaultImageOptions = {
+  'max-age': FILE_CACHE_MAX_AGE,
+  allowAnimated: true,
+  mode: 'crop'
+};
+const extendImageParams = (params, fetchMaxRes = false) => {
+  return {
+    ...defaultImageOptions,
+    ...params,
+    ...(fetchMaxRes ? {
+      width: MAX_RESOLUTION,
+      height: MAX_RESOLUTION
+    } : {})
+  };
+};
+const jsonHeaders = {
+  Accept: 'application/json',
+  'Content-Type': 'application/json'
+};
+export class MediaStore {
+  constructor(config) {
+    _defineProperty(this, "resolveAuth", authContext => resolveAuth(this.config.authProvider, authContext));
+    _defineProperty(this, "resolveInitialAuth", () => resolveInitialAuth(this.config.initialAuth));
+    this.config = config;
+  }
+  async removeCollectionFile(id, collectionName, occurrenceKey, traceContext) {
+    const metadata = {
+      method: 'PUT',
+      endpoint: '/collection/{collectionName}'
+    };
+    const body = {
+      actions: [{
+        action: 'remove',
+        item: {
+          type: 'file',
+          id,
+          occurrenceKey
+        }
+      }]
+    };
+    const options = {
+      ...metadata,
+      authContext: {
+        collectionName
+      },
+      headers: {
+        Accept: 'application/json',
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify(body),
+      traceContext
+    };
+    await this.request(`/collection/${collectionName}`, options);
+  }
+  createUpload(createUpTo = 1, collectionName, traceContext) {
+    const metadata = {
+      method: 'POST',
+      endpoint: '/upload'
+    };
+    const options = {
+      ...metadata,
+      authContext: {
+        collectionName
+      },
+      params: {
+        createUpTo
+      },
+      headers: {
+        Accept: 'application/json'
+      },
+      traceContext
+    };
+    return this.request(`/upload`, options).then(createMapResponseToJson(metadata));
+  }
+  async uploadChunk(etag, blob, uploadId, partNumber, collectionName, traceContext) {
+    const metadata = {
+      method: 'PUT',
+      endpoint: '/chunk/{etag}'
+    };
+    const options = {
+      ...metadata,
+      params: {
+        uploadId,
+        partNumber
+      },
+      authContext: {
+        collectionName
+      },
+      body: blob,
+      traceContext
+    };
+    await this.request(`/chunk/${etag}`, options);
+  }
+  probeChunks(chunks, uploadId, collectionName, traceContext) {
+    const metadata = {
+      method: 'POST',
+      endpoint: '/chunk/probe'
+    };
+    const options = {
+      ...metadata,
+      params: {
+        uploadId
+      },
+      authContext: {
+        collectionName
+      },
+      headers: jsonHeaders,
+      body: JSON.stringify({
+        chunks
+      }),
+      traceContext
+    };
+    return this.request(`/chunk/probe`, options).then(createMapResponseToJson(metadata));
+  }
+  createFileFromUpload(body, params = {}, traceContext) {
+    const metadata = {
+      method: 'POST',
+      endpoint: '/file/upload'
+    };
+    const options = {
+      ...metadata,
+      authContext: {
+        collectionName: params.collection
+      },
+      params,
+      headers: jsonHeaders,
+      body: JSON.stringify(body),
+      traceContext
+    };
+    return this.request('/file/upload', options).then(createMapResponseToJson(metadata));
+  }
+  getRejectedResponseFromDescriptor(descriptor, limit) {
+    return {
+      fileId: descriptor.fileId,
+      error: {
+        code: 'ExceedMaxFileSizeLimit',
+        title: 'The expected file size exceeded the maximum size limit.',
+        href: 'https://dt-api-filestore--app.ap-southeast-2.dev.atl-paas.net/api.html#BadRequest',
+        limit,
+        size: descriptor.size
+      }
+    };
+  }
+  async touchFiles(body, params = {}, traceContext) {
+    const metadata = {
+      method: 'POST',
+      endpoint: '/upload/createWithFiles'
+    };
+    const options = {
+      ...metadata,
+      authContext: {
+        collectionName: params.collection
+      },
+      headers: jsonHeaders,
+      body: JSON.stringify(body),
+      traceContext
+    };
+    return this.request('/upload/createWithFiles', options).then(createMapResponseToJson(metadata));
+  }
+  getFile(fileId, params = {}, traceContext) {
+    const metadata = {
+      method: 'GET',
+      endpoint: '/file/{fileId}'
+    };
+    const options = {
+      ...metadata,
+      authContext: {
+        collectionName: params.collection
+      },
+      params,
+      traceContext
+    };
+    return this.request(`/file/${fileId}`, options).then(createMapResponseToJson(metadata));
+  }
+  async getFileImageURL(id, params) {
+    const {
+      collection: collectionName
+    } = params || {};
+    const auth = await this.resolveAuth({
+      collectionName
+    });
+    return this.createFileImageURL(id, auth, params);
+  }
+
+  // TODO Create ticket in case Trace Id can be supported through query params
+  getFileImageURLSync(id, params) {
+    const auth = this.resolveInitialAuth();
+    return this.createFileImageURL(id, auth, params);
+  }
+  createFileImageURL(id, auth, params) {
+    const options = {
+      params: extendImageParams(params),
+      auth
+    };
+    return createUrl(`${auth.baseUrl}/file/${id}/image`, options);
+  }
+  async getFileBinaryURL(id, collectionName) {
+    const auth = await this.resolveAuth({
+      collectionName
+    });
+    const options = {
+      params: {
+        dl: true,
+        collection: collectionName,
+        'max-age': FILE_CACHE_MAX_AGE
+      },
+      auth
+    };
+    return createUrl(`${auth.baseUrl}/file/${id}/binary`, options);
+  }
+  async getArtifactURL(artifacts, artifactName, collectionName) {
+    const artifactUrl = getArtifactUrl(artifacts, artifactName);
+    if (!artifactUrl) {
+      throw new Error(`artifact ${artifactName} not found`);
+    }
+    const auth = await this.resolveAuth({
+      collectionName
+    });
+    const options = {
+      params: {
+        collection: collectionName,
+        'max-age': FILE_CACHE_MAX_AGE
+      },
+      auth
+    };
+    return createUrl(`${auth.baseUrl}${artifactUrl}`, options);
+  }
+  async getImage(id, params, controller, fetchMaxRes, traceContext) {
+    // TODO add checkWebpSupport() back https://product-fabric.atlassian.net/browse/MPT-584
+    const isWebpSupported = false;
+    const headers = {};
+    if (isWebpSupported) {
+      headers.accept = 'image/webp,image/*,*/*;q=0.8';
+    }
+    const metadata = {
+      method: 'GET',
+      endpoint: '/file/{fileId}/image'
+    };
+    const options = {
+      ...metadata,
+      authContext: {
+        collectionName: params && params.collection
+      },
+      params: extendImageParams(params, fetchMaxRes),
+      headers,
+      traceContext
+    };
+    return this.request(`/file/${id}/image`, options, controller).then(createMapResponseToBlob(metadata));
+  }
+  async getItems(ids, collectionName, traceContext) {
+    const descriptors = ids.map(id => ({
+      type: 'file',
+      id,
+      collection: collectionName
+    }));
+    const metadata = {
+      method: 'POST',
+      endpoint: '/items'
+    };
+    const options = {
+      ...metadata,
+      authContext: {
+        collectionName
+      },
+      headers: jsonHeaders,
+      body: JSON.stringify({
+        descriptors
+      }),
+      traceContext
+    };
+    return this.request('/items', options).then(createMapResponseToJson(metadata));
+  }
+  async getImageMetadata(id, params, traceContext) {
+    const metadata = {
+      method: 'GET',
+      endpoint: '/file/{fileId}/image/metadata'
+    };
+    const options = {
+      ...metadata,
+      authContext: {
+        collectionName: params && params.collection
+      },
+      params,
+      traceContext
+    };
+    return this.request(`/file/${id}/image/metadata`, options).then(createMapResponseToJson(metadata));
+  }
+  async appendChunksToUpload(uploadId, body, collectionName, traceContext) {
+    const metadata = {
+      method: 'PUT',
+      endpoint: '/upload/{uploadId}/chunks'
+    };
+    const options = {
+      ...metadata,
+      authContext: {
+        collectionName
+      },
+      headers: jsonHeaders,
+      body: JSON.stringify(body),
+      traceContext
+    };
+    await this.request(`/upload/${uploadId}/chunks`, options);
+  }
+  copyFileWithToken(body, params, traceContext) {
+    const metadata = {
+      method: 'POST',
+      endpoint: '/file/copy/withToken'
+    };
+    const options = {
+      ...metadata,
+      authContext: {
+        collectionName: params.collection
+      },
+      // Contains collection name to write to
+      params,
+      // Contains collection name to write to
+      headers: jsonHeaders,
+      body: JSON.stringify(body),
+      // Contains collection name to read from
+      traceContext
+    };
+    return this.request('/file/copy/withToken', options).then(createMapResponseToJson(metadata));
+  }
+  async request(path, options = {
+    method: 'GET',
+    endpoint: undefined,
+    authContext: {}
+  }, controller) {
+    const {
+      method,
+      endpoint,
+      authContext,
+      params,
+      headers,
+      body,
+      clientOptions,
+      traceContext
+    } = options;
+    const auth = await this.resolveAuth(authContext);
+    const extendedTraceContext = traceContext ? {
+      ...traceContext,
+      spanId: (traceContext === null || traceContext === void 0 ? void 0 : traceContext.spanId) || getRandomHex(8)
+    } : undefined;
+    const response = await request(`${auth.baseUrl}${path}`, {
+      method,
+      endpoint,
+      auth,
+      params,
+      headers,
+      body,
+      clientOptions,
+      traceContext: extendedTraceContext
+    }, controller);
+    setKeyValueInSessionStorage(MEDIA_API_REGION, response.headers.get('x-media-region'));
+    setKeyValueInSessionStorage(MEDIA_API_ENVIRONMENT, response.headers.get('x-media-env'));
+    return response;
+  }
+}
+const getValueFromSessionStorage = key => {
+  return window && window.sessionStorage && window.sessionStorage.getItem(key) || undefined;
+};
+const setKeyValueInSessionStorage = (key, value) => {
+  if (!value || !(window && window.sessionStorage)) {
+    return;
+  }
+  const currentValue = window.sessionStorage.getItem(key);
+  if (currentValue !== value) {
+    window.sessionStorage.setItem(key, value);
+  }
+};
+export const getMediaEnvironment = () => {
+  return getValueFromSessionStorage(MEDIA_API_ENVIRONMENT);
+};
+export const getMediaRegion = () => {
+  return getValueFromSessionStorage(MEDIA_API_REGION);
+};