@atlaskit/media-client 25.0.2 → 25.1.0

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

@@ -1,386 +1,2 @@
-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';
 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,
-  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);
-};
+export { MediaStore, getMediaEnvironment, getMediaRegion } from './MediaStore';

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

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

package/dist/es2019/test-helpers/MockedMediaApi/MockedMediaApi.js

@@ -0,0 +1,164 @@
+import { getMediaFile, normaliseInput } from './helpers';
+const getMediaApi = ({
+  getFileItem
+}) => ({
+  // --------------------------------------------------------
+  // UPLOAD ENDPOINTS - None is supported
+  // --------------------------------------------------------
+
+  touchFiles: async ({
+    descriptors
+  }) => {
+    throw new Error('500 - MockedMediaApi.touchFiles: method not implemented');
+  },
+  probeChunks: async (...args) => {
+    throw new Error('500 - MockedMediaApi.probeChunks: method not implemented');
+  },
+  uploadChunk: async (_etag, _blob, uploadId) => {
+    throw new Error('500 - MockedMediaApi.uploadChunk: method not implemented');
+  },
+  appendChunksToUpload: async () => {
+    throw new Error('500 - MockedMediaApi.appendChunksToUpload: method not implemented');
+  },
+  createFileFromUpload: async ({
+    uploadId
+  }, {
+    collection
+  }) => {
+    throw new Error('500 - MockedMediaApi.createFileFromUpload: method not implemented');
+  },
+  // Used by Media Picker as a fallback for conflicted file Ids
+  createUpload: async () => {
+    throw new Error('500 - MockedMediaApi.createUpload: method not implemented');
+  },
+  // For File size limits
+  getRejectedResponseFromDescriptor: () => {
+    throw new Error('500 - MockedMediaApi.getRejectedResponseFromDescriptor: method not implemented');
+  },
+  // --------------------------------------------------------
+  // METADATA ENDPOINTS
+  // --------------------------------------------------------
+
+  getFile: async fileId => {
+    const fileItem = getFileItem(fileId);
+    if (!fileItem) {
+      throw new Error('404 - MockedMediaApi.getFile: file not found');
+    }
+    return {
+      data: getMediaFile(fileItem)
+    };
+  },
+  getItems: async ids => {
+    const items = ids.map(id => getFileItem(id)).filter(fileState => !!fileState);
+    return {
+      data: {
+        items
+      }
+    };
+  },
+  // TODO
+  getImageMetadata: async () => {
+    throw new Error('500 - MockedMediaApi.getImageMetadata: method not implemented');
+  },
+  // --------------------------------------------------------
+  // URL ENDPOINTS
+  // --------------------------------------------------------
+
+  // TODO
+  getFileImageURL: async () => {
+    throw new Error('500 - MockedMediaApi.getFileImageURL: method not implemented');
+  },
+  // TODO
+  getFileImageURLSync: () => {
+    throw new Error('500 - MockedMediaApi.getFileImageURLSync: method not implemented');
+  },
+  getFileBinaryURL: async id => {
+    const fileItem = getFileItem(id);
+    if (!fileItem) {
+      throw new Error('404 - MockedMediaApi.getFileBinaryURL: file not found');
+    }
+    if (fileItem.details.size === 0) {
+      // TODO veryify if this is the correct answer for an uploading file
+      throw new Error('404 - MockedMediaApi.getFileBinaryURL: file is empty');
+    }
+    return `/file/${id}/binary`;
+  },
+  getArtifactURL: async (artifacts, artifactName) => {
+    var _artifacts$artifactNa;
+    const artifactUrl = (_artifacts$artifactNa = artifacts[artifactName]) === null || _artifacts$artifactNa === void 0 ? void 0 : _artifacts$artifactNa.url;
+    if (!artifactUrl) {
+      throw new Error(`404 - MockedMediaApi.getArtifactURL: artifact ${artifactName} not found`);
+    }
+    return artifactUrl;
+  },
+  // --------------------------------------------------------
+  // BINARY ENDPOINTS
+  // --------------------------------------------------------
+  getImage: async fileId => {
+    const fileItem = getFileItem(fileId);
+    if (!fileItem) {
+      throw new Error('404 - MockedMediaApi.getImage: file not found');
+    }
+    if (!fileItem.details.representations.image) {
+      throw new Error('404 - MockedMediaApi.getImage: image not found');
+    }
+
+    // Empty Blob. Might have to change for a real one if TLR loads the image
+    return new Blob();
+  },
+  // --------------------------------------------------------
+  // OTHER ENDPOINTS
+  // --------------------------------------------------------
+
+  // TODO
+  copyFileWithToken: async body => {
+    const fileId = body.sourceFile.id;
+    const fileItem = getFileItem(fileId);
+    if (!fileItem) {
+      throw new Error('404 - MockedMediaApi.copyFileWithToken: file not found');
+    }
+    return {
+      data: getMediaFile(fileItem)
+    };
+  },
+  // TODO
+  removeCollectionFile: async () => {},
+  // --------------------------------------------------------
+  // OTHER ENDPOINTS
+  // --------------------------------------------------------
+  request: async () => new Response(),
+  resolveAuth: async () => ({
+    asapIssuer: '',
+    token: '',
+    baseUrl: ''
+  }),
+  resolveInitialAuth: () => ({
+    asapIssuer: '',
+    token: '',
+    baseUrl: ''
+  })
+});
+
+/**
+ * Mocked Media API
+ */
+export const createMockedMediaApi = initialFileItems => {
+  const storedFileItems = new Map();
+  const getFileItem = fileId => storedFileItems.get(fileId);
+  const setFileItems = fileItems => {
+    const normalised = normaliseInput(fileItems);
+    normalised.forEach(fileItem => storedFileItems.set(fileItem.id, fileItem));
+  };
+  if (initialFileItems) {
+    setFileItems(initialFileItems);
+  }
+  const mediaApi = getMediaApi({
+    setFileItems,
+    getFileItem
+  });
+  return {
+    setFileItems,
+    getFileItem,
+    mediaApi
+  };
+};

package/dist/es2019/test-helpers/MockedMediaApi/helpers.js

@@ -0,0 +1,166 @@
+import uuid from 'uuid/v4';
+// --------------------------------------------------------
+// Factory Utils
+// --------------------------------------------------------
+export const normaliseInput = input => !input ? [] : input instanceof Array ? input : [input];
+
+// --------------------------------------------------------
+// Utils for the main class
+// --------------------------------------------------------
+
+export const getMediaFile = fileItem => ({
+  id: fileItem.id,
+  ...fileItem.details
+});
+
+// --------------------------------------------------------
+// Utils for creating file descriptors for tests
+// --------------------------------------------------------
+
+export const createEmptyFileItem = (id, collection) => {
+  const emptyFileItem = {
+    type: 'file',
+    id,
+    details: {
+      mediaType: 'unknown',
+      mimeType: 'binary/octet-stream',
+      name: '',
+      size: 0,
+      processingStatus: 'pending',
+      artifacts: {},
+      representations: {},
+      createdAt: 1699488941974
+    }
+  };
+  if (collection) {
+    emptyFileItem.collection = collection;
+  }
+  return emptyFileItem;
+};
+
+/**
+ * Simulates the processing of the file by updating the processing status of the artifacts by a percentage
+ * Percent must be between 0 and 1
+ */
+export const createProcessingFileItem = (fileItem, percent) => {
+  if (percent < 0 || percent > 1) {
+    throw new Error('Error createProcessingFileItem: percent must be between 0 and 1');
+  }
+
+  /**
+   * This behaviour has to be confirmed
+   * Artifacts show up immediately after processed or they have a
+   * "processing time"?
+   */
+
+  if (percent === 1) {
+    return fileItem;
+  }
+
+  // No artifacts for 0% processing
+  if (percent === 0) {
+    return {
+      ...fileItem,
+      details: {
+        ...fileItem.details,
+        processingStatus: 'pending',
+        artifacts: {},
+        // The preview will only be ready at 100% -> TODO verify against backend
+        representations: {}
+      }
+    };
+  }
+  const artifactsKeys = Object.keys(fileItem.details.artifacts);
+  const artifactsEntries = Object.entries({
+    ...fileItem.details.artifacts // Spreading to make TS happy
+  });
+
+  // Get a % of the total artifacts to be set as processed
+  const processedArtifactKeys = artifactsKeys.slice(0, Math.ceil(artifactsKeys.length * percent));
+  const processedArtifactEntries = artifactsEntries.map(([key, artifact]) => [key, {
+    ...artifact,
+    processingStatus: processedArtifactKeys.includes(key) ? 'succeeded' : 'pending'
+  }]);
+  const artifactsProcessingPercent = Object.fromEntries(processedArtifactEntries);
+  return {
+    ...fileItem,
+    details: {
+      ...fileItem.details,
+      processingStatus: 'pending',
+      artifacts: artifactsProcessingPercent,
+      // The preview will only be ready at 100% -> TODO verify against backend
+      representations: {}
+    }
+  };
+};
+
+/**
+ * Makes a copy of the provided file item with a random file id
+ * */
+export const copy = fileItem => JSON.parse(JSON.stringify(fileItem).replace(new RegExp(fileItem.id, 'g'), uuid()));
+/**
+ * Extracts the file identifier from the provided file item
+ */
+export const getIdentifier = fileItem => ({
+  mediaItemType: 'file',
+  id: fileItem.id,
+  collectionName: fileItem.collection
+});
+export const createFileState = ({
+  id,
+  details: {
+    name,
+    size,
+    mediaType,
+    mimeType,
+    createdAt,
+    processingStatus,
+    artifacts,
+    representations
+  }
+}) => ({
+  status: processingStatus === 'succeeded' ? 'processed' : 'processing',
+  id,
+  name,
+  size,
+  mediaType,
+  mimeType,
+  createdAt,
+  artifacts,
+  representations
+});
+export const createUploadingFileState = ({
+  id,
+  details: {
+    name,
+    size,
+    mediaType,
+    mimeType,
+    createdAt
+  }
+}, progress) => ({
+  status: 'uploading',
+  progress,
+  id,
+  name,
+  size,
+  mediaType,
+  mimeType,
+  createdAt,
+  preview: {
+    value: new Blob(['some-content'], {
+      type: mimeType
+    })
+  }
+});
+export const createErrorFileState = ({
+  id
+}) => ({
+  status: 'error',
+  id,
+  reason: 'a random error',
+  message: 'a random error message',
+  details: {
+    some: 'mocked error detail'
+  }
+});