@amityco/ts-sdk 7.1.1-67cf0d9.0 → 7.1.1-6dd179b0.0

package/src/{channelRepository → marker}/events/onChannelUnreadUpdatedLocal.ts

@@ -4,12 +4,12 @@ import { createEventSubscriber } from '~/core/events';
 /**
  * Internal used only
  *
- * Fired when an {@link Amity.ChannelUnread} has been updated.
+ * Fired when an {@link Amity.userMessageFeedMarkers} has been resolved by Object Rsesolver
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category Channel Events
+ * @category MessageMarker Events
  */
 export const onChannelUnreadUpdatedLocal = (
   callback: Amity.Listener<Amity.Events['local.channelUnread.updated']>,
@@ -22,7 +22,7 @@ export const onChannelUnreadUpdatedLocal = (
 
   return createEventSubscriber(
     client,
-    'channel/onChannelUnreadUpdatedLocal',
+    'channelMarker/onChannelUnreadUpdatedLocal',
     'local.channelUnread.updated',
     filter,
   );

package/src/messageRepository/events/onMessageCreated.ts

@@ -1,12 +1,11 @@
 import { getActiveClient } from '~/client/api/activeClient';
-import { createEventSubscriber, fireEvent } from '~/core/events';
+import { createEventSubscriber } from '~/core/events';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { updateSubChannelUnreadFromMessage } from '~/marker/utils/updateSubChannelUnreadFromMessage';
 import { reCalculateChannelUnreadInfo } from '~/marker/utils/reCalculateChannelUnreadInfo';
 import { getActiveUser } from '~/client/api/activeUser';
 import { markReadMessage } from '../utils/markReadMessage';
 import { prepareMessagePayload } from '../utils';
-import { pullFromCache, pushToCache } from '~/cache/api';
 
 /**
  * ```js
@@ -41,49 +40,6 @@ export const onMessageCreatedMqtt = (
       });
     }
 
-    if (client.useLegacyUnreadCount) {
-      rawPayload.messages.forEach(message => {
-        const channelUnread = pullFromCache<Amity.ChannelUnread>([
-          'channelUnread',
-          'get',
-          message.channelId,
-        ])?.data;
-
-        if (
-          !channelUnread ||
-          channelUnread.lastSegment >= message.segment ||
-          typeof channelUnread.readToSegment !== 'number' ||
-          typeof channelUnread.lastMentionedSegment !== 'number'
-        )
-          return;
-
-        const lastSegment = message.segment;
-        const isMentionedInMessage = message.mentionedUsers?.some(mention => {
-          return (
-            mention.type === 'channel' ||
-            (mention.type === 'user' &&
-              client.userId &&
-              mention.userPublicIds.includes(client.userId))
-          );
-        });
-
-        const lastMentionedSegment = isMentionedInMessage
-          ? message.segment
-          : channelUnread.lastMentionedSegment;
-
-        const updatedChannelUnread: Amity.ChannelUnread = {
-          ...channelUnread,
-          lastSegment,
-          unreadCount: Math.max(lastSegment - channelUnread.readToSegment, 0),
-          lastMentionedSegment,
-          isMentioned: !(channelUnread.readToSegment >= lastMentionedSegment),
-        };
-
-        pushToCache(['channelUnread', 'get', message.channelId], updatedChannelUnread);
-        fireEvent('local.channelUnread.updated', updatedChannelUnread);
-      });
-    }
-
     // Update in cache
     ingestInCache(payload);
 

package/src/messageRepository/observers/getMessage.ts

@@ -13,6 +13,7 @@ import {
 } from '../events';
 import { onMessageFetched } from '../events/onMessageFetched';
 import { LinkedObject } from '~/utils/linkedObject';
+import { date } from '~/utils/tests';
 
 /* begin_public_function
   id: message.get

package/src/messageRepository/utils/markReadMessage.ts

@@ -1,15 +1,8 @@
-import { getActiveClient } from '~/client/api/activeClient';
 import ReadReceiptSyncEngine from '~/client/utils/ReadReceiptSync/readReceiptSyncEngine';
-import LegacyReadReceiptSyncEngine from '~/client/utils/ReadReceiptSync/legacyReadReceiptSyncEngine';
 
 export const markReadMessage = (message: Amity.InternalMessage) => {
-  const client = getActiveClient();
+  const { subChannelId, channelSegment } = message;
+  const markReadReceiptEngine = ReadReceiptSyncEngine.getInstance();
 
-  if (client.useLegacyUnreadCount) {
-    const markReadReceiptEngine = ReadReceiptSyncEngine.getInstance();
-    markReadReceiptEngine.markRead(message.channelId, message.channelSegment);
-  } else {
-    const markReadReceiptEngine = LegacyReadReceiptSyncEngine.getInstance();
-    markReadReceiptEngine.markRead(message.subChannelId, message.channelSegment);
-  }
+  markReadReceiptEngine.markRead(subChannelId, channelSegment);
 };

package/src/notificationTray/api/index.ts

@@ -0,0 +1,2 @@
+export * from './markItemsSeen';
+export * from './markTraySeen';

package/src/notificationTray/api/markItemsSeen.ts

@@ -0,0 +1,59 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { fireEvent } from '~/core/events';
+import { pullFromCache, pushToCache } from '~/cache/api';
+
+/* begin_public_function
+  id: notificationTrayItem.markSeen
+*/
+/**
+ * ```js
+ * import { notificationTray } from '@amityco/ts-sdk'
+ * const updated = await notificationTray.markItemsSeen()
+ * ```
+ *
+ * Updates an {@link Amity.NotificationItemSeen}
+ *
+ * @param trayItems[] that include id and lastTraySeenAt, The ID of the {@link Amity.NotificationItemSeen} to edit
+ * @returns the updated {@link Amity.NotificationItemSeen} object
+ *
+ * @category NotificationItemSeen API
+ * @async
+ */
+export const markItemsSeen = async (patch: Amity.QueryNotificationItemSeen) => {
+  const client = getActiveClient();
+  client.log('notificationTray/markItemsSeen', {});
+
+  const { data: payload } = await client.http.put<Amity.RawNotificationTraySeenUpdated>(
+    `api/v1/notification-tray/items/seen`,
+    {
+      patch,
+    },
+  );
+
+  const updatedData = patch.trayItems
+    .map(patchItem => {
+      const cacheData = pullFromCache<Amity.InternalNotificationTrayItem>([
+        'notificationTraySeen',
+        'get',
+        patchItem.id,
+      ])?.data;
+
+      if (!cacheData) return;
+
+      const data = {
+        ...cacheData,
+        ...payload,
+      };
+
+      if (client.cache) {
+        const cachedAt = Date.now();
+        pushToCache(['notificationTrayItem', 'get'], data, { cachedAt });
+      }
+
+      return data;
+    })
+    .filter(Boolean) as Amity.InternalNotificationTrayItem[];
+
+  fireEvent('local.notificationTrayItem.updated', { notificationTrayItems: updatedData });
+};
+/* end_public_function */

package/src/notificationTray/api/markTraySeen.ts

@@ -0,0 +1,65 @@
+import { getActiveClient } from '~/client/api';
+import { fireEvent } from '~/core/events';
+import { pullFromCache, pushToCache } from '~/cache/api';
+
+/* begin_public_function
+  id: notificationTray.markSeen
+*/
+/**
+ * ```js
+ * import { notificationTray } from '@amityco/ts-sdk'
+ * const updated = await notificationTray.markTraySeen({
+ *   lastSeenAt: Amity.timestamp,
+ * })
+ * ```
+ *
+ * Updates an {@link Amity.NotificationTraySeen}
+ *
+ * @param userId The ID of the {@link Amity.NotificationTraySeen} to edit
+ * @param lastSeenAt The patch data to apply
+ * @returns the updated {@link Amity.NotificationTraySeen} object
+ *
+ * @category Post API
+ * @async
+ */
+export const markTraySeen = async (
+  lastSeenAt: Amity.timestamp,
+): Promise<Amity.Cached<Amity.NotificationTraySeenUpdatedPayload>> => {
+  const client = getActiveClient();
+  client.log('notificationTray/markTraySeen', {});
+
+  const { data: payload } = await client.http.put<Amity.NotificationTraySeenUpdatedPayload>(
+    `api/v1/notification-tray/tray/seen`,
+    {
+      lastSeenAt,
+    },
+  );
+
+  const cacheData = pullFromCache<Amity.InternalNotificationTraySeen>([
+    'notificationTraySeen',
+    'get',
+  ])?.data;
+
+  const data = {
+    userId: client.userId!,
+    ...payload,
+  } as Amity.InternalNotificationTraySeen;
+
+  const updateCacheData = {
+    ...cacheData,
+    ...data,
+  };
+
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache)
+    pushToCache(['notificationTraySeen', 'get', client.userId!], updateCacheData, { cachedAt });
+
+  fireEvent('local.notificationTraySeen.updated', data);
+
+  return {
+    data: payload,
+    cachedAt,
+  };
+};
+/* end_public_function */

package/src/notificationTray/events/index.ts

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

package/src/notificationTray/events/onNotificationTraySeenUpdated.ts

@@ -0,0 +1,36 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ * ```js
+ * import { onNotificationTraySeenUpdated } from '@amityco/ts-sdk'
+ * const dispose = onNotificationTraySeenUpdated(data => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.NotificationTraySeen} has been updated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category NotificationTraySeen Events
+ */
+export const onNotificationTraySeenUpdated = (
+  callback: Amity.Listener<Amity.InternalNotificationTraySeen>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const disposers = [
+    createEventSubscriber(
+      client,
+      'onNotificationTraySeenUpdated',
+      'local.notificationTraySeen.updated',
+      payload => callback(payload),
+    ),
+  ];
+
+  return () => {
+    disposers.forEach(fn => fn());
+  };
+};

package/src/notificationTray/index.ts

@@ -0,0 +1,3 @@
+export * from './observers';
+export * from './api';
+export * from './events';

package/src/notificationTray/internalApi/getNotificationTraySeen.ts

@@ -0,0 +1,81 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { pullFromCache, pushToCache } from '~/cache/api';
+
+/* begin_public_function
+  id: notificationTray.getNotificationTraySeen
+*/
+/**
+ * ```js
+ * import { notificationTray } from '@amityco/ts-sdk'
+ * const notificationTraySeen = await notificationTray.getNotificationTraySeen()
+ * ```
+ *
+ *
+ * @returns A page of {@link Amity.NotificationTraySeen} objects
+ *
+ * @category NotificationTray API
+ * @async
+ * */
+export const getNotificationTraySeen = async (): Promise<
+  Amity.Cached<Amity.NotificationTraySeen>
+> => {
+  const client = getActiveClient();
+  client.log('notificationTray/getNotificationTraySeen', {});
+
+  const { data: payload } = await client.http.get<Amity.NotificationTraySeenPayload>(
+    `api/v1/notification-tray/tray/seen`,
+  );
+
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache) {
+    const cacheKey = ['notificationTraySeen', 'get', client.userId];
+    pushToCache(cacheKey, {
+      userId: client.userId,
+      lastTraySeenAt: payload.lastTraySeenAt,
+      lastTrayOccuredAt: payload.lastTrayOccuredAt,
+    });
+  }
+
+  return {
+    data: {
+      userId: client.userId!,
+      lastTraySeenAt: payload.lastTraySeenAt,
+      lastTrayOccuredAt: payload.lastTrayOccuredAt,
+      isSeen: payload.lastTraySeenAt > payload.lastTrayOccuredAt,
+    },
+    cachedAt,
+  };
+};
+/* end_public_function */
+
+/**
+ * ```js
+ * import { notificationTray } from '@amityco/ts-sdk'
+ * const notificationTraySeen = await notificationTray.getNotificationTraySeen.locally()
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.NotificationTraySeen} objects from cache
+ *
+ * @returns A page of {@link Amity.NotificationTraySeen} objects
+ *
+ * @category NotificationTray API
+ * @async
+ * */
+getNotificationTraySeen.locally = ():
+  | Amity.Cached<Amity.NotificationTraySeenPayload>
+  | undefined => {
+  const client = getActiveClient();
+  client.log('notificationTray/getNotificationTraySeen.locally', {});
+
+  if (!client.cache) return;
+
+  const queryKey = ['notificationTraySeen', 'get'];
+
+  const { data, cachedAt } =
+    pullFromCache<{ notificationTraySeen: Amity.NotificationTraySeenPayload }>(queryKey) ?? {};
+
+  if (!data?.notificationTraySeen) return;
+
+  return { data: data.notificationTraySeen, cachedAt };
+};

package/src/notificationTray/observers/getNotificationTrayItems/NotificationTrayItemsLiveCollectionController.ts

@@ -0,0 +1,96 @@
+import hash from 'object-hash';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { NotificationTrayItemsPaginationController } from './NotificationTrayItemsPaginationController';
+import { NotificationTrayItemsQuerystreamController } from './NotificationTrayItemsQuerystreamController';
+import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionController';
+import { prepareNotificationTrayItemsPayload } from '~/notificationTray/utils/prepareNotificationTrayItemsPayload';
+import { isNonNullable } from '~/utils';
+import { LinkedObject } from '~/utils/linkedObject';
+
+export class NotificationTrayItemsLiveCollectionController extends LiveCollectionController<
+  'notificationTrayItem',
+  Amity.NotificationTrayItemLiveCollection,
+  Amity.NotificationTrayItem,
+  NotificationTrayItemsPaginationController
+> {
+  private queryStreamController: NotificationTrayItemsQuerystreamController;
+
+  private query: Amity.NotificationTrayItemLiveCollection;
+
+  constructor(
+    query: Amity.NotificationTrayItemLiveCollection,
+    callback: Amity.LiveCollectionCallback<Amity.NotificationTrayItem>,
+  ) {
+    const queryStreamId = hash(query);
+    const cacheKey = ['notificationTrayItem', 'collection', queryStreamId];
+    const paginationController = new NotificationTrayItemsPaginationController(query);
+
+    super(paginationController, queryStreamId, cacheKey, callback);
+
+    this.query = query;
+    this.queryStreamController = new NotificationTrayItemsQuerystreamController(
+      this.query,
+      this.cacheKey,
+      this.notifyChange.bind(this),
+      prepareNotificationTrayItemsPayload,
+    );
+
+    this.callback = callback.bind(this);
+    this.loadPage({ initial: true });
+  }
+
+  protected setup() {
+    const collection = pullFromCache<Amity.NotificationTrayItemLiveCollectionCache>(
+      this.cacheKey,
+    )?.data;
+    if (!collection) {
+      pushToCache(this.cacheKey, {
+        data: [],
+        params: {},
+      });
+    }
+  }
+
+  protected async persistModel(queryPayload: Amity.NotificationTrayPayload & Amity.Pagination) {
+    await this.queryStreamController.saveToMainDB(queryPayload);
+  }
+
+  protected persistQueryStream({
+    response,
+    direction,
+    refresh,
+  }: Amity.LiveCollectionPersistQueryStreamParams<'notificationTrayItem'>) {
+    this.queryStreamController.appendToQueryStream(response, direction, refresh);
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  startSubscription() {
+    return [] as Amity.Unsubscriber[];
+  }
+
+  notifyChange({ origin, loading, error }: Amity.LiveCollectionNotifyParams) {
+    const collection = pullFromCache<Amity.NotificationTrayItemLiveCollectionCache>(
+      this.cacheKey,
+    )?.data;
+    if (!collection) return;
+
+    const data = (
+      collection.data
+        .map(id =>
+          pullFromCache<Amity.InternalNotificationTrayItem>(['notificationTrayItem', 'get', id]),
+        )
+        .filter(isNonNullable)
+        .map(({ data }) => data) ?? []
+    ).map(LinkedObject.notificationTray);
+
+    if (!this.shouldNotify(data) && origin === 'event') return;
+
+    this.callback({
+      onNextPage: () => this.loadPage({ direction: Amity.LiveCollectionPageDirection.NEXT }),
+      data,
+      hasNextPage: !!this.paginationController.getNextToken(),
+      loading,
+      error,
+    });
+  }
+}

package/src/notificationTray/observers/getNotificationTrayItems/NotificationTrayItemsPaginationController.ts

@@ -0,0 +1,31 @@
+import { PaginationController } from '~/core/liveCollection/PaginationController';
+import { COLLECTION_DEFAULT_PAGINATION_LIMIT } from '~/utils/constants';
+
+/**
+ * TODO: handle cache receive cache option, and cache policy
+ * TODO: check if querybyIds is supported
+ */
+export class NotificationTrayItemsPaginationController extends PaginationController<
+  'notificationTrayItem',
+  Amity.NotificationTrayItemLiveCollection
+> {
+  async getRequest(
+    queryParams: Amity.NotificationTrayItemLiveCollection,
+    token: string | undefined,
+  ) {
+    const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, ...params } = queryParams;
+
+    const options = token ? { token } : { limit };
+
+    const { data: queryResponse } = await this.http.get<
+      Amity.NotificationTrayPayload & Amity.Pagination
+    >(`/api/v1/notification-tray`, {
+      params: {
+        ...params,
+        options,
+      },
+    });
+
+    return queryResponse;
+  }
+}

package/src/notificationTray/observers/getNotificationTrayItems/NotificationTrayItemsQuerystreamController.ts

@@ -0,0 +1,68 @@
+import { QueryStreamController } from '~/core/liveCollection/QueryStreamController';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getResolver } from '~/core/model';
+import { getActiveClient } from '~/client';
+
+export class NotificationTrayItemsQuerystreamController extends QueryStreamController<
+  Amity.NotificationTrayPayload,
+  Amity.NotificationTrayItemLiveCollection
+> {
+  private notifyChange: (params: Amity.LiveCollectionNotifyParams) => void;
+
+  private preparePayload: (
+    response: Amity.NotificationTrayPayload,
+  ) => Amity.ProcessedNotificationTrayPayload;
+
+  constructor(
+    query: Amity.NotificationTrayItemLiveCollection,
+    cacheKey: string[],
+    notifyChange: (params: Amity.LiveCollectionNotifyParams) => void,
+    preparePayload: (
+      response: Amity.NotificationTrayPayload,
+    ) => Amity.ProcessedNotificationTrayPayload,
+  ) {
+    super(query, cacheKey);
+    this.notifyChange = notifyChange;
+    this.preparePayload = preparePayload;
+  }
+
+  async saveToMainDB(response: Amity.NotificationTrayPayload) {
+    const processedPayload = await this.preparePayload(response);
+
+    const client = getActiveClient();
+    const cachedAt = client.cache && Date.now();
+
+    if (client.cache) {
+      ingestInCache(processedPayload, { cachedAt });
+    }
+  }
+
+  appendToQueryStream(
+    response: Amity.NotificationTrayPayload & Partial<Amity.Pagination>,
+    direction: Amity.LiveCollectionPageDirection,
+    refresh = false,
+  ) {
+    if (refresh) {
+      pushToCache(this.cacheKey, {
+        data: response.notificationTrayItems.map(getResolver('notificationTrayItem')),
+      });
+    } else {
+      const collection = pullFromCache<Amity.NotificationTrayItemLiveCollectionCache>(
+        this.cacheKey,
+      )?.data;
+
+      const notifications = collection?.data ?? [];
+
+      pushToCache(this.cacheKey, {
+        ...collection,
+        data: [
+          ...new Set([
+            ...notifications,
+            ...response.notificationTrayItems.map(getResolver('notificationTrayItem')),
+          ]),
+        ],
+      });
+    }
+  }
+}

package/src/notificationTray/observers/getNotificationTrayItems.ts

@@ -0,0 +1,44 @@
+import { getActiveClient } from '~/client/api';
+import { dropFromCache } from '~/cache/api';
+import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+import { NotificationTrayItemsLiveCollectionController } from './getNotificationTrayItems/NotificationTrayItemsLiveCollectionController';
+
+/**
+ * Get notification tray items for a notification tray page
+ *
+ * @param params the limit query parameters
+ * @param callback the callback to be called when the notification tray items are updated
+ * @returns items in the notification tray
+ *
+ * @category Notification tray items Live Collection
+ *
+ */
+export const getNotificationTrayItems = (
+  params: Amity.LiveCollectionParams<Amity.NotificationTrayItemLiveCollection>,
+  callback: Amity.LiveCollectionCallback<Amity.NotificationTrayItem>,
+  config?: Amity.LiveCollectionConfig,
+) => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`getNotificationTrayItems(tmpid: ${timestamp}) > listen`);
+
+  const notiTrayItemsLiveCollection = new NotificationTrayItemsLiveCollectionController(
+    params,
+    callback,
+  );
+  const disposers = notiTrayItemsLiveCollection.startSubscription();
+
+  const cacheKey = notiTrayItemsLiveCollection.getCacheKey();
+
+  disposers.push(() => dropFromCache(cacheKey));
+
+  return () => {
+    log(`getNotificationTrayItems(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/notificationTray/observers/getNotificationTraySeen.ts

@@ -0,0 +1,43 @@
+import { liveObject } from '~/utils/liveObject';
+import { getNotificationTraySeen as _getNotificationTraySeen } from '../internalApi/getNotificationTraySeen';
+import { onNotificationTraySeenUpdated } from '../events/onNotificationTraySeenUpdated';
+import { getActiveUser } from '~/client';
+
+/* begin_public_function
+  id: notificationTraySeen.get
+*/
+/**
+ * ```js
+ * import { getNotificationTraySeen } from '@amityco/ts-sdk';
+ *
+ * let notificationTraySeen;
+ *
+ * const unsubscribe = getNotificationTraySeen(userId, response => {
+ *   notificationTraySeen = response.data;
+ * });
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.NotificationTraySeen}
+ *
+ * @param userId the ID of the user to observe
+ * @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 message
+ *
+ * @category NotificationTraySeen Live Object
+ */
+export const getNotificationTraySeen = (
+  callback: Amity.LiveObjectCallback<Amity.NotificationTraySeenPayload>,
+): Amity.Unsubscriber => {
+  const responder: Amity.LiveObjectCallback<Amity.InternalNotificationTraySeen> = (
+    snapshot: Amity.LiveObject<Amity.InternalNotificationTraySeen>,
+  ) => {
+    const { data } = snapshot;
+    callback({ ...snapshot, data });
+  };
+
+  const { userId } = getActiveUser();
+  return liveObject(userId, responder, 'userId', _getNotificationTraySeen, [
+    onNotificationTraySeenUpdated,
+  ]);
+};
+/* end_public_function */

package/src/notificationTray/observers/index.ts

@@ -0,0 +1,2 @@
+export * from './getNotificationTraySeen';
+export * from './getNotificationTrayItems';

package/src/notificationTray/utils/prepareNotificationTrayItemsPayload.ts

@@ -0,0 +1,12 @@
+import { convertRawUserToInternalUser } from '~/userRepository/utils/convertRawUserToInternalUser';
+
+export const prepareNotificationTrayItemsPayload = (
+  rawPayload: Amity.NotificationTrayPayload,
+): Amity.ProcessedNotificationTrayPayload => {
+  const users = rawPayload.users.map(convertRawUserToInternalUser);
+
+  return {
+    ...rawPayload,
+    users,
+  };
+};