@amityco/ts-sdk-react-native 6.12.1 → 6.13.0

package/src/analytic/api/queryReachUser.ts

@@ -0,0 +1,31 @@
+import { getActiveClient } from '~/client';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+export const queryReachUser = async ({
+  postId,
+  limit,
+  token,
+}: {
+  postId: Amity.InternalPost['postId'];
+  limit: number;
+  token?: string;
+}) => {
+  const client = getActiveClient();
+
+  const params: { token?: string; limit?: number } = {};
+  if (token) {
+    // If it's not a first query, we can use token to get next user list from previous query.
+    params.token = token;
+  } else {
+    // First query.
+    params.limit = limit;
+  }
+
+  const response = await client.http.get(`/api/v1/analytics/views/posts/${postId}/users`, {
+    params,
+  });
+
+  ingestInCache(response.data);
+
+  return response.data;
+};

package/src/analytic/api/syncEvent.ts

@@ -0,0 +1,12 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+export const syncEvent = async (events: Amity.AnalyticEventModel[]) => {
+  const client = getActiveClient();
+  const params: Record<string, any> = {
+    activities: events,
+  };
+
+  await client.http.post<Amity.ChannelPayload>('/api/v1/analytics/activities', {
+    activities: events,
+  });
+};

package/src/analytic/constant.ts

@@ -0,0 +1 @@
+export const ANALYTIC_CACHE_KEY = ['analytic', 'post'];

package/src/analytic/service/analytic/AnalyticsEngine.ts

@@ -0,0 +1,54 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { dropFromCache } from '~/cache/api';
+import { AnalyticsEventSyncer } from './AnalyticsEventSyncer';
+import { AnalyticsEventCapturer } from './AnalyticsEventCapturer';
+import { ANALYTIC_CACHE_KEY } from '../../constant';
+
+class AnalyticsEngine {
+  private _client: Amity.Client;
+
+  private _eventCapturer;
+
+  private _eventSyncer;
+
+  constructor() {
+    this._client = getActiveClient();
+    this._eventCapturer = new AnalyticsEventCapturer();
+    this._eventSyncer = new AnalyticsEventSyncer();
+  }
+
+  markPostAsViewed(postId: Amity.InternalPost['postId']) {
+    if (
+      this._client.sessionState === Amity.SessionStates.ESTABLISHED ||
+      this._client.sessionState === Amity.SessionStates.TOKEN_EXPIRED // For case token_expired, we assume token is expired and gonna re-connect soon
+    ) {
+      this._eventCapturer.markPostAsViewed(postId);
+    }
+  }
+
+  established() {
+    this._eventSyncer.start();
+  }
+
+  handleTokenExpired() {
+    this._eventSyncer.stop();
+  }
+
+  destroy() {
+    this._eventSyncer.stop();
+
+    // query and destroy all objects.
+    dropFromCache(ANALYTIC_CACHE_KEY);
+  }
+}
+
+let instance: AnalyticsEngine;
+
+export default {
+  getInstance: () => {
+    if (!instance) {
+      instance = new AnalyticsEngine();
+    }
+    return instance;
+  },
+};

package/src/analytic/service/analytic/AnalyticsEventCapturer.ts

@@ -0,0 +1,48 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { upsertInCache } from '~/cache/api/upsertInCache';
+import { pullFromCache } from '~/cache/api/pullFromCache';
+import { MINUTE } from '~/utils/constants';
+import { ANALYTIC_CACHE_KEY } from '../../constant';
+
+export class AnalyticsEventCapturer {
+  _expireTime = 5 * MINUTE;
+
+  _poolLimit = 1000;
+
+  _recentViewed: { [key: Amity.InternalPost['postId']]: Date } = {};
+
+  markPostAsViewed(postId: Amity.InternalPost['postId']) {
+    const now = new Date();
+    const client = getActiveClient();
+
+    const recentViewedPostDate = this._recentViewed[postId] ?? new Date(-86400000);
+    const timeDiff = now.getTime() - recentViewedPostDate.getTime();
+    if (timeDiff < this._expireTime) {
+      // just recently view this post, ignore the event.
+      return;
+    }
+
+    const currentData: { event: Amity.AnalyticEventModel[] } = { event: [] };
+    const cache = pullFromCache<{ event: Amity.AnalyticEventModel[] }>(ANALYTIC_CACHE_KEY);
+
+    if (cache?.data) {
+      currentData.event = cache.data.event;
+    }
+
+    // If the pool is full (Max 1000 items), remove the oldest data
+    if (currentData.event.length >= this._poolLimit) {
+      // Remove oldest data
+      currentData.event.shift();
+    }
+
+    currentData.event.push({
+      contentId: postId,
+      contentType: 'post',
+      activityType: 'view',
+      timestamp: now.toISOString(),
+    });
+
+    upsertInCache(ANALYTIC_CACHE_KEY, currentData);
+    this._recentViewed[postId] = now;
+  }
+}

package/src/analytic/service/analytic/AnalyticsEventSyncer.ts

@@ -0,0 +1,45 @@
+import { pullFromCache } from '~/cache/api/pullFromCache';
+import { dropFromCache } from '~/cache/api/dropFromCache';
+import { MINUTE } from '~/utils/constants';
+import { ANALYTIC_CACHE_KEY } from '../../constant';
+import { syncEvent } from '../../api/syncEvent';
+
+export class AnalyticsEventSyncer {
+  _timer: NodeJS.Timeout | undefined = undefined;
+
+  start() {
+    this.syncCapturedEvent();
+
+    this._timer = setInterval(() => {
+      this.syncCapturedEvent();
+    }, 1 * MINUTE);
+  }
+
+  stop() {
+    if (!this._timer) return;
+    clearInterval(this._timer);
+    this._timer = undefined;
+  }
+
+  async syncCapturedEvent() {
+    try {
+      // Must query only objects that has same userId with current logged-in user.
+      // Query captured event with maximum of 1000
+      // Order by latest first
+      // e.g. If there is 2000 events we will query 1000-2000 first
+      const cache = pullFromCache<{ event: Amity.AnalyticEventModel[] }>(ANALYTIC_CACHE_KEY);
+      if (!cache?.data) return;
+      if (cache.data.event.length === 0) return;
+
+      const capturedEvents = cache.data.event;
+
+      await syncEvent(capturedEvents);
+
+      dropFromCache(ANALYTIC_CACHE_KEY);
+    } catch (error) {
+      // stop and destroy all events
+      this.stop();
+      dropFromCache(ANALYTIC_CACHE_KEY);
+    }
+  }
+}

package/src/analytic/service/analytic/AnalyticsService.ts

@@ -0,0 +1,23 @@
+import AnalyticsEngine from './AnalyticsEngine';
+
+class AnalyticsService {
+  private analyticEngine;
+
+  constructor() {
+    this.analyticEngine = AnalyticsEngine.getInstance();
+  }
+
+  markPostAsViewed(postId: string): void {
+    this.analyticEngine.markPostAsViewed(postId);
+  }
+}
+
+let instance: AnalyticsService;
+export default {
+  getInstance: () => {
+    if (!instance) {
+      instance = new AnalyticsService();
+    }
+    return instance;
+  },
+};

package/src/analytic/utils/analyticsEngineOnLoginHandler.ts

@@ -0,0 +1,19 @@
+import { onSessionStateChange } from '~/client/events/onSessionStateChange';
+import AnalyticsEngine from '../service/analytic/AnalyticsEngine';
+
+export default () => {
+  const analyticsEngine = AnalyticsEngine.getInstance();
+  analyticsEngine.established();
+
+  onSessionStateChange(state => {
+    if (state === Amity.SessionStates.ESTABLISHED) {
+      analyticsEngine.established();
+    } else {
+      analyticsEngine.handleTokenExpired();
+    }
+  });
+
+  return () => {
+    analyticsEngine.destroy();
+  };
+};

package/src/cache/api/pushToCache.ts

@@ -5,7 +5,7 @@ import { encodeKey } from '../utils';
 /**
  * ```js
  * import { pushToCache } from '@amityco/ts-sdk-react-native'
- * pushToCache<Amity.User>(["user", "foobar"], user)
+ * pushToCache<Amity.InternalUser>(["user", "foobar"], user)
  * ```
  *
  * Saves any provided value as {@link Amity.CacheEntry} for the matching {@link Amity.CacheKey}

package/src/cache/api/upsertInCache.ts

@@ -7,7 +7,7 @@ import { mergeInCache } from './mergeInCache';
 /**
  * ```js
  * import { upsertInCache } from '@amityco/ts-sdk-react-native'
- * upsertInCache<Amity.User>(["user", "foobar"], user)
+ * upsertInCache<Amity.InternalUser>(["user", "foobar"], user)
  * ```
  *
  * Insert or update any provided value as {@link Amity.CacheEntry} for

package/src/categoryRepository/api/getCategory.ts

@@ -1,7 +1,8 @@
 import { getActiveClient } from '~/client/api/activeClient';
 
-import { pullFromCache, dropFromCache } from '~/cache/api';
+import { pullFromCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
+import { categoryLinkedObject } from '~/utils/linkedObject/categoryLinkedObject';
 
 /* begin_public_function
   id: community.category.get
@@ -36,7 +37,7 @@ export const getCategory = async (
   const { categories } = data;
 
   return {
-    data: categories.find(category => category.categoryId === categoryId)!,
+    data: categoryLinkedObject(categories.find(category => category.categoryId === categoryId)!),
     cachedAt,
   };
 };

package/src/categoryRepository/api/queryCategories.ts

@@ -7,6 +7,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 import { getResolver } from '~/core/model';
 
 import { inferIsDeleted } from '~/utils/inferIsDeleted';
+import { LinkedObject } from '~/utils/linkedObject';
 
 /**
  * ```js
@@ -62,7 +63,12 @@ export const queryCategories = async (
   const nextPage = toPage(paging.next);
   const prevPage = toPage(paging.previous);
 
-  return { data: categories, cachedAt, prevPage, nextPage };
+  return {
+    data: categories.map(category => LinkedObject.category(category)),
+    cachedAt,
+    prevPage,
+    nextPage,
+  };
 };
 
 /**

package/src/categoryRepository/observers/getCategories.ts

@@ -17,6 +17,7 @@ import {
   ENABLE_CACHE_MESSAGE,
 } from '~/utils/constants';
 import { queryCategories } from '../api/queryCategories';
+import { LinkedObject } from '~/utils/linkedObject';
 
 /* begin_public_function
   id: community.category.query
@@ -62,9 +63,9 @@ export const getCategories = (
   const responder = (data: Amity.CategoryLiveCollectionCache) => {
     let categories: Amity.Category[] =
       data.data
-        .map(categoryId => pullFromCache<Amity.Category>(['category', 'get', categoryId])!)
+        .map(categoryId => pullFromCache<Amity.InternalCategory>(['category', 'get', categoryId])!)
         .filter(Boolean)
-        .map(({ data }) => data) ?? [];
+        .map(({ data }) => LinkedObject.category(data)) ?? [];
 
     if (!params.includeDeleted) {
       categories = filterByPropEquality(categories, 'isDeleted', false);

package/src/categoryRepository/observers/tests/getCategories.test.ts

@@ -12,6 +12,7 @@ import {
 import { sortByName } from '~/core/query';
 
 import { getCategories } from '../getCategories';
+import { LinkedObject } from '~/utils/linkedObject';
 
 const getSnapshot = (params?: Record<string, any>) => {
   return {
@@ -48,7 +49,7 @@ describe('getCategories', () => {
       2,
       expect.objectContaining(
         getSnapshot({
-          data: payload.categories,
+          data: payload.categories.map(category => LinkedObject.category(category)),
           loading: false,
         }),
       ),

package/src/channelRepsitory/api/createChannel.ts

@@ -22,7 +22,7 @@ import { prepareChannelPayload } from '../utils';
  * @async
  */
 export const createChannel = async <T extends Amity.ChannelType>(
-  bundle: { type: T; userIds?: Amity.User['userId'][] } & Pick<
+  bundle: { type: T; userIds?: Amity.InternalUser['userId'][] } & Pick<
     Amity.Channel<T>,
     'displayName' | 'avatarFileId' | 'tags' | 'metadata'
   >,

package/src/channelRepsitory/channelMembership/api/addMembers.ts

@@ -14,18 +14,18 @@ import { prepareChannelPayload } from '../../utils';
  * const updated = await addMembers(channelId, ['foo', 'bar'])
  * ```
  *
- * Adds a list of {@link Amity.User} to a {@link Amity.Channel}
+ * Adds a list of {@link Amity.InternalUser} to a {@link Amity.Channel}
  *
  * @param channelId The ID of the {@link Amity.Channel} to perform
- * @param userIds The list of IDs {@link Amity.User} to add
- * @returns A success boolean if the {@link Amity.User} were added to the {@link Amity.Channel}
+ * @param userIds The list of IDs {@link Amity.InternalUser} to add
+ * @returns A success boolean if the {@link Amity.InternalUser} were added to the {@link Amity.Channel}
  *
  * @category Channel API
  * @async
  */
 export const addMembers = async (
   channelId: Amity.Channel['channelId'],
-  userIds: Amity.User['userId'][],
+  userIds: Amity.InternalUser['userId'][],
 ): Promise<boolean> => {
   const client = getActiveClient();
   client.log('channel/addMembers', channelId, userIds);

package/src/channelRepsitory/channelMembership/api/queryChannelMembers.ts

@@ -80,7 +80,7 @@ export const queryChannelMembers = async (
  * const channelMembers = await queryChannelMembers(query)
  * ```
  *
- * Queries a paginable list of {@link Amity.Post} objects from cache
+ * Queries a paginable list of {@link Amity.InternalPost} objects from cache
  *
  * @param query The query parameters
  * @returns posts

package/src/channelRepsitory/channelMembership/api/removeMembers.ts

@@ -14,18 +14,18 @@ import { prepareChannelPayload } from '../../utils';
  * const updated = await removeMembers(channelId, ['foo', 'bar'])
  * ```
  *
- * Removes a list of {@link Amity.User} from a {@link Amity.Channel}
+ * Removes a list of {@link Amity.InternalUser} from a {@link Amity.Channel}
  *
  * @param channelId The ID of the {@link Amity.Channel} to perform
- * @param userIds The list of IDs {@link Amity.User} to remove
- * @returns A success boolean if the list of {@link Amity.User} were removed from the {@link Amity.Channel}
+ * @param userIds The list of IDs {@link Amity.InternalUser} to remove
+ * @returns A success boolean if the list of {@link Amity.InternalUser} were removed from the {@link Amity.Channel}
  *
  * @category Channel API
  * @async
  */
 export const removeMembers = async (
   channelId: Amity.Channel['channelId'],
-  userIds: Amity.User['userId'][],
+  userIds: Amity.InternalUser['userId'][],
 ): Promise<boolean> => {
   const client = getActiveClient();
   client.log('channel/removeMembers', channelId, userIds);

package/src/channelRepsitory/channelMembership/observers/tests/getMembers.test.ts

@@ -63,7 +63,7 @@ describe('getMembers', () => {
     string,
     keyof Amity.Events,
     Amity.RawMembership<'channel'>,
-    Amity.User,
+    Amity.InternalUser,
     Amity.Membership<'channel'>[],
   ][] = [
     [

package/src/channelRepsitory/channelMembership/observers/tests/searchMembers.test.ts

@@ -8,14 +8,12 @@ import {
   channelUserModel,
   channelUserQueryResponse,
   channelUserQueryResponsePage2,
-  channelUserQueryResponsePage3,
   channelUserWithRole,
   client,
   connectClient,
   convertRawChannelPayload,
   disconnectClient,
   emptyChannelUserQueryResponse,
-  mutedChannelUser,
   pause,
   rawBannedChannelUser,
   rawChannelUser,
@@ -94,7 +92,7 @@ describe('searchMembers', () => {
     string,
     keyof Amity.Events,
     Amity.RawMembership<'channel'>,
-    Amity.User,
+    Amity.InternalUser,
     Amity.Membership<'channel'>[],
   ][] = [
     [

package/src/channelRepsitory/channelModeration/api/addRole.ts

@@ -14,12 +14,12 @@ import { fireEvent } from '~/core/events';
  * const updated = await addRole(channelId, 'foo', ['bar'])
  * ```
  *
- * Adds an {@link Amity.Role} to a list of {@link Amity.User} on a {@link Amity.Channel}
+ * Adds an {@link Amity.Role} to a list of {@link Amity.InternalUser} on a {@link Amity.Channel}
  *
  * @param channelId The ID of the {@link Amity.Channel} to perform
  * @param roleId The ID 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.Channel}
+ * @param userId Array of IDs of the {@link Amity.InternalUser} to perform
+ * @returns A success boolean if the {@link Amity.Role} were added to list of {@link Amity.InternalUser} in the {@link Amity.Channel}
  *
  * @category Channel API
  * @async
@@ -27,7 +27,7 @@ import { fireEvent } from '~/core/events';
 export const addRole = async (
   channelId: Amity.Channel['channelId'],
   roleId: Amity.Role['roleId'],
-  userIds: Amity.User['userId'][],
+  userIds: Amity.InternalUser['userId'][],
 ): Promise<boolean> => {
   const client = getActiveClient();
   client.log('channel/addRole', channelId, roleId, userIds);

package/src/channelRepsitory/channelModeration/api/banMembers.ts

@@ -15,7 +15,7 @@ import { prepareChannelPayload } from '../../utils';
  * ```
  *
  * @param channelId of {@link Amity.Channel} from which the users should be banned
- * @param userIds of the {@link Amity.User}'s to be banned
+ * @param userIds of the {@link Amity.InternalUser}'s to be banned
  * @returns the updated {@link Amity.Membership}'s object
  *
  * @category Channel API
@@ -23,7 +23,7 @@ import { prepareChannelPayload } from '../../utils';
  * */
 export const banMembers = async (
   channelId: Amity.Channel['channelId'],
-  userIds: Amity.User['userId'][],
+  userIds: Amity.InternalUser['userId'][],
 ): Promise<Amity.Cached<Amity.Membership<'channel'>[]>> => {
   const client = getActiveClient();
   client.log('channel/banMembers', { userIds, channelId });

package/src/channelRepsitory/channelModeration/api/removeRole.ts

@@ -14,12 +14,12 @@ import { fireEvent } from '~/core/events';
  * const updated = await removeRole(channelId, 'foo', ['bar'])
  * ```
  *
- * Removes an {@link Amity.Role} from a list of {@link Amity.User} on a {@link Amity.Channel}
+ * Removes an {@link Amity.Role} from a list of {@link Amity.InternalUser} on a {@link Amity.Channel}
  *
  * @param channelId The ID of the {@link Amity.Channel} to perform
  * @param roleId The ID of the {@link Amity.Role} to apply
- * @param userIds 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.Channel}
+ * @param userIds Array of IDs of the {@link Amity.InternalUser} to perform
+ * @returns A success boolean if the {@link Amity.Role} were removed from list of {@link Amity.InternalUser} in the {@link Amity.Channel}
  *
  * @category Channel API
  * @async
@@ -27,7 +27,7 @@ import { fireEvent } from '~/core/events';
 export const removeRole = async (
   channelId: Amity.Channel['channelId'],
   roleId: Amity.Role['roleId'],
-  userIds: Amity.User['userId'][],
+  userIds: Amity.InternalUser['userId'][],
 ): Promise<boolean> => {
   const client = getActiveClient();
   client.log('channel/removeRole', channelId, roleId, userIds);

package/src/channelRepsitory/channelModeration/api/unbanMembers.ts

@@ -15,7 +15,7 @@ import { prepareChannelPayload } from '../../utils';
  * ```
  *
  * @param channelId of {@link Amity.Channel} where the users should be unbanned
- * @param userIds of the {@link Amity.User}'s to be unbanned
+ * @param userIds of the {@link Amity.InternalUser}'s to be unbanned
  * @returns the updated {@link Amity.Membership}'s object
  *
  * @category Channel API
@@ -23,7 +23,7 @@ import { prepareChannelPayload } from '../../utils';
  * */
 export const unbanMembers = async (
   channelId: Amity.Channel['channelId'],
-  userIds: Amity.User['userId'][],
+  userIds: Amity.InternalUser['userId'][],
 ): Promise<Amity.Cached<Amity.Membership<'channel'>[]>> => {
   const client = getActiveClient();
   client.log('channel/unbanMembers', { userIds, channelId });

package/src/channelRepsitory/events/onChannelMemberAdded.ts

@@ -12,7 +12,7 @@ import { prepareChannelPayload } from '../utils';
  * })
  * ```
  *
- * Fired when any {@link Amity.User} has been added to any {@link Amity.Channel}
+ * Fired when any {@link Amity.InternalUser} has been added to any {@link Amity.Channel}
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening

package/src/channelRepsitory/events/onChannelMemberBanned.ts

@@ -13,7 +13,7 @@ import { prepareChannelPayload } from '../utils';
  * })
  * ```
  *
- * Fired when any {@link Amity.User} has been banned from any {@link Amity.Channel}
+ * Fired when any {@link Amity.InternalUser} has been banned from any {@link Amity.Channel}
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening

package/src/channelRepsitory/events/onChannelMemberRemoved.ts

@@ -13,7 +13,7 @@ import { prepareChannelPayload } from '../utils';
  * })
  * ```
  *
- * Fired when any {@link Amity.User} has been removed from any {@link Amity.Channel}
+ * Fired when any {@link Amity.InternalUser} has been removed from any {@link Amity.Channel}
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening

package/src/channelRepsitory/events/onChannelMemberUnbanned.ts

@@ -13,7 +13,7 @@ import { prepareChannelPayload } from '../utils';
  * })
  * ```
  *
- * Fired when any {@link Amity.User} has been unbanned from any {@link Amity.Channel}
+ * Fired when any {@link Amity.InternalUser} has been unbanned from any {@link Amity.Channel}
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening

package/src/channelRepsitory/observers/tests/getChannel.test.ts

@@ -0,0 +1,73 @@
+import {
+  channelQueryResponse,
+  client,
+  connectClient,
+  convertRawChannelPayload,
+  disconnectClient,
+  pause,
+} from '~/utils/tests';
+import { getChannel } from '../getChannel';
+
+describe('getChannel (observer)', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  test('When user gets valid channel, it should return valid channel', async () => {
+    const callback = jest.fn();
+    const { channelId } = channelQueryResponse.data.channels[0];
+
+    client.http.get = jest.fn().mockResolvedValue(channelQueryResponse);
+
+    getChannel(channelId, callback);
+
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({
+        data: undefined,
+        loading: true,
+        error: undefined,
+      }),
+    );
+
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        data: convertRawChannelPayload(channelQueryResponse.data).channels[0],
+        loading: false,
+        error: undefined,
+      }),
+    );
+  });
+
+  test('When user queries invalid channel, it should return error', async () => {
+    const callback = jest.fn();
+
+    client.http.get = jest.fn().mockRejectedValue(new Error('error'));
+
+    getChannel('xxxxxx', callback);
+
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({
+        data: undefined,
+        loading: true,
+        error: undefined,
+      }),
+    );
+
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        data: undefined,
+        loading: false,
+        error: new Error('error'),
+      }),
+    );
+  });
+});