@amityco/ts-sdk 0.0.1-e26de88.0 → 0.0.1-e556efe.0

package/src/comment/observers/index.ts

@@ -1,2 +1,3 @@
 export * from './observeComments';
 export * from './observeComment';
+export * from './liveComments';

package/src/comment/observers/liveComments.ts

@@ -0,0 +1,172 @@
+/* eslint-disable no-use-before-define */
+import { getResolver } from '~/core/model';
+import { getActiveClient } from '~/client/api';
+import { pushToCache, pullFromCache } from '~/cache/api';
+import {
+  createQuery,
+  runQuery,
+  queryOptions,
+  filterByPropEquality,
+  sortByFirstCreated,
+  sortByLastCreated,
+} from '~/core/query';
+
+import {
+  COLLECTION_DEFAULT_CACHING_POLICY,
+  COLLECTION_DEFAULT_PAGINATION_LIMIT,
+} from '~/utils/constants';
+
+import {
+  onCommentCreated,
+  onCommentUpdated,
+  onCommentDeleted,
+  onCommentFlagged,
+  onCommentUnflagged,
+  onCommentReactionAdded,
+  onCommentReactionRemoved,
+} from '../events';
+import { queryComments } from '../api';
+
+/**
+ * ```js
+ * import { liveComments } from '@amityco/ts-sdk'
+ *
+ * let comments = []
+ * const unsub = liveComments({
+ *   referenceType: Amity.Comment['referenceType'];
+ *   referenceId: Amity.Comment['referenceId'];
+ * }, response => merge(comments, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Comment} for a given target object
+ *
+ * @param referenceType the type of the target
+ * @param referenceId the ID of the target
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the messages
+ *
+ * @category Comments Live Collection
+ */
+export const liveComments = (
+  params: Amity.CommentLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.Comment>,
+  config?: Amity.LiveCollectionConfig,
+): Amity.Unsubscriber => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log('For using Live Collection feature you need to enable Cache!');
+  }
+
+  const timestamp = Date.now();
+  log(`liveComments(tmpid: ${timestamp}) > listen`);
+
+  const { limit: queryLimit, ...queryParams } = params;
+
+  const limit = queryLimit ?? COLLECTION_DEFAULT_PAGINATION_LIMIT;
+  const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config ?? {};
+
+  const disposers: Amity.Unsubscriber[] = [];
+  const cacheKey = [
+    'comment',
+    'collection',
+    { referenceId: params.referenceType, referenceType: params.referenceId },
+  ];
+
+  const responder = (data: Amity.CommentLiveCollectionCache) => {
+    let comments: Amity.Comment[] =
+      data.data
+        .map(commentId => pullFromCache<Amity.Comment>(['comment', 'get', commentId])!)
+        .filter(Boolean)
+        .map(({ data }) => data) ?? [];
+
+    comments = filterByPropEquality(comments, 'isDeleted', params.isDeleted);
+
+    const sortBy = params.sortBy ? params.sortBy : 'lastCreated';
+
+    comments = comments.sort(sortBy === 'lastCreated' ? sortByLastCreated : sortByFirstCreated);
+
+    callback({
+      onNextPage: onFetch,
+      data: comments,
+      hasNextPage: !!data.params?.page,
+      loading: data.loading,
+      error: data.error,
+    });
+  };
+
+  const realtimeRouter = (comment: Amity.Comment, action: Amity.CommentActionType) => {
+    const collection = pullFromCache<Amity.CommentLiveCollectionCache>(cacheKey)?.data;
+
+    if (
+      params.referenceId !== comment.referenceId ||
+      params.referenceType !== comment.referenceType ||
+      !collection
+    )
+      return;
+
+    if (action === 'onCreate') {
+      collection.data = [...new Set([comment.commentId, ...collection.data])];
+    } else if (action === 'onDelete') {
+      collection.data = collection.data.filter(p => p !== comment.commentId);
+    }
+
+    pushToCache(cacheKey, collection);
+
+    responder(collection);
+  };
+
+  const onFetch = () => {
+    const collection = pullFromCache<Amity.CommentLiveCollectionCache>(cacheKey)?.data;
+
+    const comments = collection?.data ?? [];
+
+    if (comments.length > 0 && !collection?.params?.page) return;
+
+    const query = createQuery(queryComments, {
+      ...queryParams,
+      page: collection?.params?.page ?? { limit },
+    });
+
+    runQuery(
+      query,
+      ({ data: result, error, loading, prevPage, nextPage }) => {
+        // depend on sortBy value we have two different pagination type
+        const page = queryParams.sortBy ? nextPage : prevPage;
+
+        const data = {
+          loading,
+          error,
+          params: { page },
+          data: comments,
+        };
+
+        if (result) {
+          data.data = [...new Set([...comments, ...result.map(getResolver('comment'))])];
+        }
+
+        pushToCache(cacheKey, data);
+
+        responder(data);
+      },
+      queryOptions(policy),
+    );
+  };
+
+  disposers.push(
+    onCommentCreated(comment => realtimeRouter(comment, 'onCreate')),
+    onCommentUpdated(comment => realtimeRouter(comment, 'onUpdate')),
+    onCommentDeleted(comment => realtimeRouter(comment, 'onDelete')),
+    onCommentFlagged(comment => realtimeRouter(comment, 'onFlagged')),
+    onCommentUnflagged(comment => realtimeRouter(comment, 'onUnflagged')),
+    onCommentReactionAdded(comment => realtimeRouter(comment, 'onReactionAdded')),
+    onCommentReactionRemoved(comment => realtimeRouter(comment, 'onReactionRemoved')),
+  );
+
+  onFetch();
+
+  return () => {
+    log(`liveComments(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/comment/observers/observeComments.ts

@@ -48,17 +48,7 @@ export const observeComments = (
 
   const disposers: Amity.Unsubscriber[] = [];
 
-  const router = (
-    comment: Amity.Comment,
-    action:
-      | 'onCreate'
-      | 'onUpdate'
-      | 'onDelete'
-      | 'onFlagged'
-      | 'onUnflagged'
-      | 'onReactionAdded'
-      | 'onReactionRemoved',
-  ) => {
+  const router = (comment: Amity.Comment, action: Exclude<Amity.CommentActionType, 'onFetch'>) => {
     if (comment.referenceId !== postId) return;
 
     if (callback instanceof Function) return callback(comment);

package/src/community/api/{addCommunityMembersRole.ts → addCommunityMembersRoles.ts}

@@ -4,31 +4,31 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 
 /**
  * ```js
- * import { addCommunityMembersRole } from '@amityco/ts-sdk'
- * const updated = await addCommunityMembersRole(communityId, 'foo', ['bar'])
+ * import { addCommunityMembersRoles } from '@amityco/ts-sdk'
+ * const updated = await addCommunityMembersRoles(communityId, ['foo'], ['bar'])
  * ```
  *
- * Adds an {@link Amity.Role} to a list of {@link Amity.User} on a {@link Amity.Community}
+ * Adds a list of {@link Amity.Role} to a list of {@link Amity.User} on a {@link Amity.Community}
  *
  * @param communityId The ID of the {@link Amity.Community} to perform
- * @param roleId The ID of the {@link Amity.Role} to apply
+ * @param roleIds Array of IDs of the {@link Amity.Role} to apply
  * @param userId Array of IDs of the {@link Amity.User} to perform
  * @returns A success boolean if the {@link Amity.Role} were added to list of {@link Amity.User} in the {@link Amity.Community}
  *
  * @category Community API
  * @async
  */
-export const addCommunityMembersRole = async (
+export const addCommunityMembersRoles = async (
   communityId: Amity.Community['communityId'],
-  roleId: Amity.Role['roleId'],
+  roleIds: Amity.Role['roleId'][],
   userIds: Amity.User['userId'][],
 ): Promise<boolean> => {
   const client = getActiveClient();
-  client.log('community/addCommunityMembersRole', communityId, roleId, userIds);
+  client.log('community/addCommunityMembersRoles', communityId, roleIds, userIds);
 
   const { data } = await client.http.post<Amity.CommunityMembershipPayload>(
-    `/api/v3/communities/${communityId}/users/roles`,
-    { communityId, role: roleId, userIds },
+    `/api/v4/communities/${communityId}/users/roles`,
+    { communityId, roles: roleIds, userIds },
   );
 
   if (client.cache) ingestInCache(data);
@@ -36,6 +36,7 @@ export const addCommunityMembersRole = async (
   const { communityUsers } = data;
   return !!communityUsers.find(
     communityUser =>
-      communityUser.communityId === communityId && communityUser.roles.includes(roleId),
+      communityUser.communityId === communityId &&
+      roleIds.some(role => communityUser.roles.includes(role)),
   );
 };

package/src/community/api/index.ts

@@ -12,9 +12,8 @@ export * from './leaveCommunity';
 export * from './queryCommunityMembers';
 export * from './addCommunityMembers';
 export * from './removeCommunityMembers';
-
-export * from './addCommunityMembersRole';
-export * from './removeCommunityMembersRole';
+export * from './addCommunityMembersRoles';
+export * from './removeCommunityMembersRoles';
 
 export * from './getTopTrendingCommunities';
 export * from './getRecommendedCommunities';

package/src/community/api/{removeCommunityMembersRole.ts → removeCommunityMembersRoles.ts}

@@ -4,31 +4,31 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 
 /**
  * ```js
- * import { removeCommunityMembersRole } from '@amityco/ts-sdk'
- * const updated = await removeCommunityMembersRole(communityId,  'foo', ['bar'])
+ * import { removeCommunityMembersRoles } from '@amityco/ts-sdk'
+ * const updated = await removeCommunityMembersRoles(communityId,  ['foo'], ['bar'])
  * ```
  *
- * Removes an {@link Amity.Role} from a list of {@link Amity.User} on a {@link Amity.Community}
+ * Removes a list of {@link Amity.Role} from a list of {@link Amity.User} on a {@link Amity.Community}
  *
  * @param communityId The ID of the {@link Amity.Community} to perform
- * @param role The ID of the {@link Amity.Role} to apply
+ * @param roleIds Array of IDs of the {@link Amity.Role} to apply
  * @param userId Array of IDs of the {@link Amity.User} to perform
  * @returns A success boolean if the {@link Amity.Role} were removed from list of {@link Amity.User} in the {@link Amity.Community}
  *
  * @category Community API
  * @async
  */
-export const removeCommunityMembersRole = async (
+export const removeCommunityMembersRoles = async (
   communityId: Amity.Community['communityId'],
-  roleId: Amity.Role['roleId'],
+  roleIds: Amity.Role['roleId'][],
   userIds: Amity.User['userId'][],
 ): Promise<boolean> => {
   const client = getActiveClient();
-  client.log('community/removeCommunityMembersRole', communityId, roleId, userIds);
+  client.log('community/removeCommunityMembersRoles', communityId, roleIds, userIds);
 
   const { data } = await client.http.delete<Amity.CommunityMembershipPayload>(
-    `/api/v3/communities/${communityId}/users/roles`,
-    { data: { communityId, role: roleId, userIds } },
+    `/api/v4/communities/${communityId}/users/roles`,
+    { data: { communityId, roles: roleIds, userIds } },
   );
 
   if (client.cache) ingestInCache(data);
@@ -36,6 +36,7 @@ export const removeCommunityMembersRole = async (
   const { communityUsers } = data;
   return !!communityUsers.find(
     communityUser =>
-      communityUser.communityId === communityId && !communityUser.roles.includes(roleId),
+      communityUser.communityId === communityId &&
+      !roleIds.some(role => communityUser.roles.includes(role)),
   );
 };

package/src/core/model/idResolvers.ts

@@ -19,9 +19,12 @@ const idResolvers: Resolvers = {
   message: ({ messageId }) => messageId,
 
   community: ({ communityId }) => communityId,
+  category: ({ categoryId }) => categoryId,
   communityUsers: ({ communityId, userId }) => `${communityId}#${userId}`,
   post: ({ postId }) => postId,
   comment: ({ commentId }) => commentId,
+  poll: ({ pollId }) => pollId,
+  reaction: ({ reactionId }) => reactionId,
 
   stream: ({ streamId }) => streamId,
 

package/src/core/model/identifyModel.ts

@@ -27,9 +27,12 @@ const CRITERIAS: Criterias = {
   channelUsers: ['channelId', 'userId', 'membership'],
   message: ['messageId'],
   community: ['communityId', 'onlyAdminCanPost'],
+  category: ['categoryId'],
   communityUsers: ['userId', 'communityId', 'communityMembership'],
   post: ['postId', 'feedId'],
   comment: ['commentId', 'referenceId'],
+  poll: ['pollId'],
+  reaction: ['reactionId'],
   stream: ['streamId'],
   follow: ['from', 'to'],
   followCount: ['userId', 'followerCount'],
@@ -54,3 +57,21 @@ export const identifyModel = (model: Record<string, unknown>) => {
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   return criterias.find(([_, keys]) => hasKeys(model, keys))?.[0];
 };
+
+/*
+ * Identify the modal key for a model
+ * Used to get args for optimistic updates
+ * Example: createMessage: get messageId on optimistic message creation
+ *
+ * @param model to be recognized
+ * @returns model key array if one if found or undefined
+ */
+export const identifyModelKey = (model: Record<string, unknown>): string | undefined => {
+  const modalKey = identifyModel(model);
+
+  if (!modalKey) {
+    return undefined;
+  }
+
+  return CRITERIAS[modalKey]?.[0];
+};

package/src/core/model/index.ts

@@ -15,10 +15,13 @@ export const PAYLOAD2MODEL: Record<string, Amity.Domain> = {
   messages: 'message',
 
   communities: 'community',
+  categories: 'category',
   communityUsers: 'communityUsers',
   posts: 'post',
   postChildren: 'post',
   comments: 'comment',
+  polls: 'poll',
+  reactions: 'reaction',
   videoStreamings: 'stream',
 
   follows: 'follow',

package/src/core/query/paging.ts

@@ -80,17 +80,17 @@ export const toToken = (
       "before" or "after" value. if that would change,
       we'd need to move toward a more simple: `!paging.before`
     */
-    if (!Number.isNaN(paging?.before!)) {
+    if (!Number.isNaN(Number(paging?.before!))) {
       payload = {
         before: paging.before,
         last: paging.limit,
       };
-    } else if (!Number.isNaN(paging?.after!)) {
+    } else if (!Number.isNaN(Number(paging?.after!))) {
       payload = {
         after: paging.after,
         first: paging.limit,
       };
-    } else if (!Number.isNaN(paging?.limit!)) {
+    } else if (!Number.isNaN(Number(paging?.limit!))) {
       payload = {
         last: paging.limit,
       };

package/src/core/query/query.ts

@@ -1,5 +1,6 @@
 /* eslint-disable no-use-before-define */
 import { isPaged } from './paging';
+import { identifyModelKey } from '~/core/model';
 
 /**
  * Type guard to check and cast that a given async function is has the ".locally" property
@@ -201,7 +202,37 @@ export const runQuery = <Args extends any[], Returned extends any>(
     );
   }
 
-  func(...args)
+  let optimisticArgs = args;
+  /* get args for optimistic method calls
+   *
+   * On optimistic updates, the modal key for the update needs to be passed to
+   * the server so as to avoid duplicate modal creation
+   *
+   * ex: on creating a new message pass the modalKey is messageId, pass this
+   * id onto the server so that a duplicate with seperate messageId is not
+   * created.
+   */
+  if (isMutator(func)) {
+    // @ts-ignore
+    const modelKey = local && local.data && identifyModelKey(local.data);
+    if (modelKey) {
+      /*
+       * modal key is only required for create as update and delete queries pass
+       * the modal key in the param itself
+       * For update & delete the first argument is always an id which is of type
+       * string, whereas for create the first and only argument is the param object
+       * 
+       * When creating an AmityObject optimistically we need to pass the modal key 
+       * on to the server. ex: for create message modal key will be 'messageId`
+       */
+      if (typeof args[0] !== 'string') {
+        // @ts-ignore
+        optimisticArgs = [{ ...args[0], [modelKey]: local.data[modelKey] }];
+      }
+    }
+  }
+
+  func(...optimisticArgs)
     .then(fresh => {
       // @ts-ignore i know.
       // isLocal(local) && syncInCache(local, fresh)

package/src/core/subscription.ts

@@ -1,4 +1,4 @@
-import { getActiveClient } from '~/client/api';
+import { getActiveClient } from '~/client/api/activeClient';
 import { ASCError } from '~/core/errors';
 import { proxyMqttEvents } from '~/core/events';
 import { getActiveUser } from '~/client/api/activeUser';
@@ -12,7 +12,7 @@ export enum SubscriptionLevels {
 }
 
 const getCommunityUserTopic = (
-  { path }: Amity.Subscribable,
+  path: Amity.Subscribable['path'],
   level?: SubscriptionLevels,
 ): string => {
   switch (level) {
@@ -30,12 +30,16 @@ const getCommunityUserTopic = (
 export const getCommunityTopic = (
   { path }: Amity.Subscribable,
   level: Exclude<SubscriptionLevels, SubscriptionLevels.USER> = SubscriptionLevels.COMMUNITY,
-): string => getCommunityUserTopic({ path }, level);
+): string => getCommunityUserTopic(path, level);
 
 export const getUserTopic = (
   { path }: Amity.Subscribable,
   level: Exclude<SubscriptionLevels, SubscriptionLevels.COMMUNITY> = SubscriptionLevels.USER,
-): string => getCommunityUserTopic({ path }, level);
+): string =>
+  getCommunityUserTopic(
+    level === SubscriptionLevels.USER ? path : path.replace(/^(\w*)/, '$1/social'),
+    level,
+  );
 
 export const getPostTopic = (
   { path }: Amity.Subscribable,
@@ -69,6 +73,15 @@ export const getMyFollowingsTopic = (): string => {
   return `${networkId}/membership/+/${user._id}/+`;
 };
 
+/** @hidden */
+export const getNetworkTopic = (): string => {
+  const user = getActiveUser();
+
+  const [networkId] = user.path.split('/user/');
+
+  return networkId;
+};
+
 let mqttAccessToken: string;
 let mqttUserId: string;
 

package/src/core/tests/query/filtering.test.ts

@@ -0,0 +1,11 @@
+import { filterByPropEquality } from '~/core/query';
+
+describe('Core/Query/Filtering', () => {
+  test('check filterByPropEquality', () => {
+    const prop = 'prop';
+    const collection = [{ [prop]: 'value' }];
+
+    expect(filterByPropEquality(collection, prop, 'value')).toStrictEqual(collection);
+    expect(filterByPropEquality(collection, prop, 'otherValue')).toStrictEqual([]);
+  });
+});

package/src/core/tests/query/query.test.ts

@@ -0,0 +1,19 @@
+import { isFetcher } from '~/core/query';
+
+type isFetcherMockType = jest.Mock<any, any> & {
+  locally?: jest.Mock<any, any>;
+};
+
+describe('Core/Query/Query', () => {
+  const isFetcherMock: isFetcherMockType = jest.fn();
+
+  test('isFetcher without locally', () => {
+    expect(isFetcher(isFetcherMock)).toBe(false);
+  });
+
+  test('isFetcher with locally', () => {
+    isFetcherMock.locally = jest.fn();
+
+    expect(isFetcher(isFetcherMock)).toBe(true);
+  });
+});

package/src/external/api/createUserToken.ts

@@ -0,0 +1,43 @@
+import { createHttpTransport } from '~/core/transports';
+import { getDeviceInfo, getDeviceId } from '~/core/device';
+import { API_REGIONS, computeUrl } from '~/client/utils/endpoints';
+
+/**
+ * Retrieves accessToken info to use in Beta services
+ *
+ * @param apiKey for the Http Client instance
+ * @param apiRegion endpoint to connect to
+ * @param params The token parameters
+ * @param params.userId The userId to use to issue a token
+ * @param params.displayName The user's displayName
+ * @param params.authToken The authentication token - necessary when network option is set to secure
+ * @return An accessToken info object for the given userId
+ *
+ * @category External API
+ * @hidden
+ */
+export const createUserToken = async (
+  apiKey: string,
+  apiRegion: typeof API_REGIONS[keyof typeof API_REGIONS],
+  params: {
+    userId: Amity.User['userId'];
+    displayName?: Amity.User['displayName'];
+    authToken?: string;
+  },
+) => {
+  const deviceId = getDeviceId();
+  const deviceInfo = await getDeviceInfo();
+  const http = createHttpTransport(computeUrl('http', apiRegion));
+
+  const { data } = await http.post<Amity.Tokens>(
+    '/api/v3/sessions',
+    {
+      ...params,
+      deviceId,
+      deviceInfo: { ...deviceInfo, model: 'token management API on TS-SDK' },
+    },
+    { headers: { 'X-API-Key': apiKey } },
+  );
+
+  return { accessToken: data.accessToken };
+};

package/src/external/api/index.ts

@@ -0,0 +1 @@
+export * from './createUserToken';

package/src/file/api/createFile.ts

@@ -11,6 +11,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  * Creates an {@link Amity.File}
  *
  * @param formData The data necessary to create a new {@link Amity.File}
+ * @param onProgress The callback to track the upload progress
  * @returns The newly created {@link Amity.File}
  *
  * @category File API
@@ -19,19 +20,19 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 export const createFile = async <T extends Amity.FileType = any>(
   formData: FormData,
   onProgress?: (percent: number) => void,
-): Promise<Amity.Cached<Amity.File>> => {
+): Promise<Amity.Cached<Amity.File[]>> => {
   const client = getActiveClient();
   client.log('file/createFile', formData);
 
-  if (!formData.getAll('file').length)
-    throw new Error('The formData object must have a `file` key.');
+  if (!formData.getAll('files').length)
+    throw new Error('The formData object must have a `files` key.');
 
   const headers =
     'getHeaders' in formData
       ? (formData as any).getHeaders()
       : { 'content-type': 'multipart/form-data' };
 
-  const { data } = await client.http.post<Amity.CreateFilePayload<T>>('/api/v3/files', formData, {
+  const { data } = await client.http.post<Amity.CreateFilePayload<T>>('/api/v4/files', formData, {
     headers,
     onUploadProgress({ loaded, total }) {
       onProgress && onProgress(Math.round((loaded * 100) / total));
@@ -45,7 +46,7 @@ export const createFile = async <T extends Amity.FileType = any>(
   if (client.cache) ingestInCache({ files: data }, { cachedAt });
 
   return {
-    data: data[0],
+    data,
     cachedAt,
   };
 };

package/src/file/api/createImage.ts

@@ -0,0 +1,58 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { createImage } from '@amityco/ts-sdk'
+ * const created = await createImage(formData)
+ * ```
+ *
+ * Creates an {@link Amity.File<'image'>}
+ *
+ * @param formData The data necessary to create a new {@link Amity.File<'image'>}
+ * @param onProgress The callback to track the upload progress
+ * @returns The newly created {@link Amity.File<'image'>}
+ *
+ * @category File API
+ * @async
+ */
+export const createImage = async (
+  formData: FormData,
+  onProgress?: (percent: number) => void,
+): Promise<Amity.Cached<Amity.File<'image'>[]>> => {
+  const client = getActiveClient();
+  client.log('file/createImage', formData);
+
+  if (!formData.getAll('files').length)
+    throw new Error('The formData object must have a `files` key.');
+
+  const headers =
+    'getHeaders' in formData
+      ? (formData as any).getHeaders()
+      : { 'content-type': 'multipart/form-data' };
+
+  const { data } = await client.http.post<Amity.CreateFilePayload<'image'>>(
+    '/api/v4/images',
+    formData,
+    {
+      headers,
+      onUploadProgress({ loaded, total }) {
+        onProgress && onProgress(Math.round((loaded * 100) / total));
+      },
+    },
+  );
+
+  // API-FIX: payload should be serialized properly
+  // const { files } = data
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache({ files: data }, { cachedAt });
+
+  return {
+    data,
+    cachedAt,
+  };
+};
+
+// TODO: consider doing local creation with URL.createObjectURL()