@amityco/ts-sdk 0.0.1-beta.42.2 → 0.0.1-beta.43

package/src/marker/api/getMessageMarkers.ts

@@ -0,0 +1,54 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { fireEvent } from '~/core/events';
+import { toPage, toToken } from '~/core/query';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { getMessageMarkers } from '@amityco/ts-sdk'
+ * const messageMarkers = await getMessageMarkers(['sch1', 'sch2'])
+ * ```
+ *
+ * Fetches a paginable list of {@link Amity.MessageMarker} objects
+ *
+ * @param messageIds the feed IDs of the {@link Amity.RawMessage} marker to fetch
+ * @param page
+ * @returns A page of {@link Amity.MessageMarker} objects
+ *
+ * @category Channel API
+ * @async
+ * @private
+ */
+export const getMessageMarkers = async (
+  messageIds: Amity.RawMessage['messageFeedId'][],
+  page: Amity.Page = { limit: 100 },
+): Promise<Amity.Cached<Amity.Paged<Amity.MessageMarker>>> => {
+  const client = getActiveClient();
+  client.log('channel/getMessageMarkers', messageIds, page);
+
+  const { data: queryPayload } = await client.http.get<
+    Amity.MessageMarkerPayload & Amity.Pagination
+  >(`/api/v1/markers/messages`, {
+    params: {
+      messageIds,
+      options: {
+        token: toToken(page, 'skiplimit'),
+      },
+    },
+  });
+
+  const { paging, ...payload } = queryPayload;
+  const { contentMarkers, feedMarkers, userMarkers } = payload;
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(payload as Amity.MessageMarkerPayload, { cachedAt });
+
+  feedMarkers.length && fireEvent('local.feedMarker.fetched', { feedMarkers });
+  contentMarkers.length && fireEvent('local.messageMarker.fetched', { contentMarkers });
+  userMarkers.length && fireEvent('local.userMarker.fetched', { userMarkers });
+
+  const nextPage = toPage(paging.next);
+  const prevPage = toPage(paging.previous);
+
+  return { data: contentMarkers, cachedAt, prevPage, nextPage };
+};

package/src/marker/api/getSubChannelMarkers.ts

@@ -0,0 +1,54 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { fireEvent } from '~/core/events';
+import { toPage, toToken } from '~/core/query';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { getSubChannelMarkers } from '@amityco/ts-sdk'
+ * const subChannelMarkers = await getSubChannelMarkers(['sch1', 'sch2'])
+ * ```
+ *
+ * Fetches a paginable list of {@link Amity.SubChannelMarker} objects
+ *
+ * @param messageFeedIds the feed IDs of the {@link Amity.RawSubChannel} marker to fetch
+ * @param page
+ * @returns A page of {@link Amity.SubChannelMarker} objects
+ *
+ * @category Channel API
+ * @async
+ * @private
+ */
+export const getSubChannelMarkers = async (
+  messageFeedIds: Amity.RawSubChannel['messageFeedId'][],
+  page: Amity.Page = { limit: 100 },
+): Promise<Amity.Cached<Amity.Paged<Amity.SubChannelMarker>>> => {
+  const client = getActiveClient();
+  client.log('channel/getSubChannelMarkers', messageFeedIds, page);
+
+  const { data: queryPayload } = await client.http.get<
+    Amity.SubChannelMarkerPayload & Amity.Pagination
+  >(`/api/v1/markers/message-feeds`, {
+    params: {
+      messageFeedIds,
+      options: {
+        token: toToken(page, 'skiplimit'),
+      },
+    },
+  });
+
+  const { paging, ...payload } = queryPayload;
+  const { userEntityMarkers, userFeedMarkers, userMarkers } = payload;
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(payload as Amity.SubChannelMarkerPayload, { cachedAt });
+
+  userEntityMarkers.length && fireEvent('local.channelMarker.fetched', { userEntityMarkers });
+  userFeedMarkers.length && fireEvent('local.subChannelMarker.fetched', { userFeedMarkers });
+  userMarkers.length && fireEvent('local.userMarker.fetched', { userMarkers });
+
+  const nextPage = toPage(paging.next);
+  const prevPage = toPage(paging.previous);
+
+  return { data: userFeedMarkers, cachedAt, prevPage, nextPage };
+};

package/src/marker/api/getUserMarker.ts

@@ -0,0 +1,47 @@
+import { pullFromCache } from '~/cache/api';
+import { getActiveClient } from '~/client/api/activeClient';
+import { getActiveUser } from '~/client/api/activeUser';
+import { ASCError } from '~/core/errors';
+import { getResolver } from '~/core/model';
+
+const locally = () => {
+  const client = getActiveClient();
+  const user = getActiveUser();
+  client.log('marker/getUserMarker.locally');
+
+  const { _id: userId } = user;
+
+  if (!userId)
+    throw new ASCError(
+      'The userId has not been defined in active client',
+      Amity.ClientError.UNKNOWN_ERROR,
+      Amity.ErrorLevel.ERROR,
+    );
+
+  const createdTime = new Date().toISOString();
+  const cachedAt = client.cache && Date.now();
+
+  const data: Amity.UserMarker = pullFromCache<Amity.UserMarker>([
+    'userMarker',
+    'get',
+    getResolver('userMarker')({ userId }),
+  ])?.data ?? {
+    userId,
+    unreadCount: 0,
+    lastSyncAt: createdTime,
+    createdAt: createdTime,
+    updatedAt: createdTime,
+  };
+
+  return {
+    data,
+    cachedAt,
+  };
+};
+
+export const getUserMarker = (): Promise<Amity.Cached<Amity.UserMarker>> => {
+  // API-FIX: backend should implement user marker get API
+  return Promise.resolve(locally());
+};
+
+getUserMarker.locally = locally;

package/src/marker/api/index.ts

@@ -0,0 +1,4 @@
+export * from './getChannelMarkers';
+export * from './getMessageMarkers';
+export * from './getSubChannelMarkers';
+export * from './getUserMarker';

package/src/marker/api/tests/getChannelMarkers.test.ts

@@ -0,0 +1,109 @@
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { ASCApiError } from '~/core/errors';
+import { getResolver } from '~/core/model';
+import { onUserMarkerFetched } from '~/marker/events';
+import { onChannelMarkerFetched } from '~/marker/events/onChannelMarkerFetched';
+import { client, generateChannelMarker, generateUserMarker } from '~/utils/tests';
+
+import { getChannelMarkers } from '../getChannelMarkers';
+
+const pagingToken = {
+  previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+  next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+};
+
+const pagingCriteria = { limit: 10 };
+
+const userId = 'user1';
+
+const expectedChannelMarkers = [
+  generateChannelMarker({ entityId: 'ch1', userId }),
+  generateChannelMarker({ entityId: 'ch2', userId }),
+];
+
+const expectedUserMarkers = [generateUserMarker({ userId: 'currentUser1' })];
+
+const channelIds = expectedChannelMarkers.map(({ entityId }) => entityId);
+
+const resolvedGetValue = {
+  data: {
+    userEntityMarkers: expectedChannelMarkers,
+    userMarkers: expectedUserMarkers,
+    paging: pagingToken,
+  },
+};
+
+describe('getChannelMarkers', () => {
+  it('should return channel markers', async () => {
+    client.http.get = jest.fn().mockResolvedValue(resolvedGetValue);
+
+    const { data } = await getChannelMarkers(channelIds);
+
+    expect(data).toEqual(expectedChannelMarkers);
+  });
+
+  test('should return fetched channel markers with correct paging', async () => {
+    client.http.get = jest.fn().mockResolvedValueOnce(resolvedGetValue);
+
+    await expect(getChannelMarkers(channelIds, pagingCriteria)).resolves.toEqual(
+      expect.objectContaining({
+        data: expectedChannelMarkers,
+        prevPage: { before: 55, limit: 10 },
+        nextPage: { before: 55, limit: 10 },
+      }),
+    );
+  });
+
+  test('should update cache after fetching channelMarkers ', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValue(resolvedGetValue);
+
+    await getChannelMarkers(channelIds);
+    const cacheKeyResolver = getResolver('channelMarker');
+
+    const received = channelIds.map(
+      entityId =>
+        pullFromCache(['channelMarker', 'get', cacheKeyResolver({ entityId, userId })])?.data,
+    );
+
+    expect(received).toEqual(expectedChannelMarkers);
+
+    disableCache();
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.get = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('Not Found', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(getChannelMarkers(channelIds)).rejects.toThrow('Amity SDK (400400): Not Found');
+  });
+
+  test('should fire event `onChannelMarkerFetched`', async () => {
+    let dispose;
+    client.http.get = jest.fn().mockResolvedValue(resolvedGetValue);
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onChannelMarkerFetched(resolve);
+    }).finally(dispose);
+
+    await getChannelMarkers(channelIds);
+
+    await expect(callbackPromise).resolves.toMatchObject(expectedChannelMarkers[0]);
+  });
+
+  test('should fire event `onUserMarkerFetched`', async () => {
+    let dispose;
+    client.http.get = jest.fn().mockResolvedValue(resolvedGetValue);
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onUserMarkerFetched(resolve);
+    }).finally(dispose);
+
+    await getChannelMarkers(channelIds);
+
+    await expect(callbackPromise).resolves.toMatchObject(expectedUserMarkers[0]);
+  });
+});

package/src/marker/api/tests/getMessageMarkers.test.ts

@@ -0,0 +1,114 @@
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { ASCApiError } from '~/core/errors';
+import { getResolver } from '~/core/model';
+import { onMessageMarkerFetched, onUserMarkerFetched } from '~/marker/events';
+import {
+  client,
+  generateFeedMarker,
+  generateMessageMarker,
+  generateUserMarker,
+} from '~/utils/tests';
+
+import { getMessageMarkers } from '../getMessageMarkers';
+
+const pagingToken = {
+  previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+  next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+};
+
+const pagingCriteria = { limit: 10 };
+
+const expectedMessageMarkers = [
+  generateMessageMarker({ feedId: 'sub-ch1', contentId: 'message1' }),
+  generateMessageMarker({ feedId: 'sub-ch1', contentId: 'message2' }),
+];
+
+const expectedFeedMarkers = [generateFeedMarker({ feedId: 'sub-ch1', entityId: 'feed1' })];
+
+const expectedUserMarkers = [generateUserMarker({ userId: 'currentUser1' })];
+
+const messageIds = expectedMessageMarkers.map(({ contentId }) => contentId);
+const messageMarkerResolver = getResolver('messageMarker');
+const messageMarkerCacheIds = expectedMessageMarkers.map(messageMarkerResolver);
+
+const resolvedGetValue = {
+  data: {
+    contentMarkers: expectedMessageMarkers,
+    feedMarkers: expectedFeedMarkers,
+    userMarkers: expectedUserMarkers,
+    paging: pagingToken,
+  } as Amity.MessageMarkerPayload,
+};
+
+describe('getMessageMarkers', () => {
+  it('should return message markers', async () => {
+    client.http.get = jest.fn().mockResolvedValue(resolvedGetValue);
+
+    const { data } = await getMessageMarkers(messageIds);
+
+    expect(data).toEqual(expectedMessageMarkers);
+  });
+
+  test('should return fetched message markers with correct paging', async () => {
+    client.http.get = jest.fn().mockResolvedValueOnce(resolvedGetValue);
+
+    await expect(getMessageMarkers(messageIds, pagingCriteria)).resolves.toEqual(
+      expect.objectContaining({
+        data: expectedMessageMarkers,
+        prevPage: { before: 55, limit: 10 },
+        nextPage: { before: 55, limit: 10 },
+      }),
+    );
+  });
+
+  test('should update cache after fetching message markers ', async () => {
+    enableCache();
+
+    client.http.get = jest.fn().mockResolvedValue(resolvedGetValue);
+
+    await getMessageMarkers(messageIds);
+    const received = messageMarkerCacheIds.map(
+      id => pullFromCache(['messageMarker', 'get', id])?.data,
+    );
+
+    expect(received).toEqual(expectedMessageMarkers);
+
+    disableCache();
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.get = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('Not Found', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(getMessageMarkers(messageIds)).rejects.toThrow('Amity SDK (400400): Not Found');
+  });
+
+  test('should fire event `onMessageMarkerFetched`', async () => {
+    let dispose;
+    client.http.get = jest.fn().mockResolvedValue(resolvedGetValue);
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onMessageMarkerFetched(resolve);
+    }).finally(dispose);
+
+    await getMessageMarkers(messageIds);
+
+    await expect(callbackPromise).resolves.toMatchObject(expectedMessageMarkers[0]);
+  });
+
+  test('should fire event `onUserMarkerFetched`', async () => {
+    let dispose;
+    client.http.get = jest.fn().mockResolvedValue(resolvedGetValue);
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onUserMarkerFetched(resolve);
+    }).finally(dispose);
+
+    await getMessageMarkers(messageIds);
+
+    await expect(callbackPromise).resolves.toMatchObject(expectedUserMarkers[0]);
+  });
+});

package/src/marker/api/tests/getSubChannelMarkers.test.ts

@@ -0,0 +1,116 @@
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { ASCApiError } from '~/core/errors';
+import { getResolver } from '~/core/model';
+import { onSubChannelMarkerFetched, onUserMarkerFetched } from '~/marker/events';
+import {
+  client,
+  generateChannelMarker,
+  generateSubChannelMarker,
+  generateUserMarker,
+} from '~/utils/tests';
+
+import { getSubChannelMarkers } from '../getSubChannelMarkers';
+
+const pagingToken = {
+  previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+  next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+};
+
+const pagingCriteria = { limit: 10 };
+
+const expectedSubChannelMarkers = [
+  generateSubChannelMarker({ feedId: 'sub-ch1', entityId: 'ch1' }),
+  generateSubChannelMarker({ feedId: 'sub-ch2', entityId: 'ch1' }),
+];
+
+const expectedChannelMarkers = [generateChannelMarker({ entityId: 'ch1', userId: 'user1' })];
+
+const expectedUserMarkers = [generateUserMarker({ userId: 'currentUser1' })];
+
+const subChannelIds = expectedSubChannelMarkers.map(({ feedId }) => feedId);
+const subChannelMarkerResolver = getResolver('subChannelMarker');
+const subChannelMarkerCacheIds = expectedSubChannelMarkers.map(subChannelMarkerResolver);
+
+const resolvedGetValue = {
+  data: {
+    userFeedMarkers: expectedSubChannelMarkers,
+    userEntityMarkers: expectedChannelMarkers,
+    userMarkers: expectedUserMarkers,
+    paging: pagingToken,
+  } as Amity.SubChannelMarkerPayload,
+};
+
+describe('getSubChannelMarkers', () => {
+  it('should return sub channel markers', async () => {
+    client.http.get = jest.fn().mockResolvedValue(resolvedGetValue);
+
+    const { data } = await getSubChannelMarkers(subChannelIds);
+
+    expect(data).toEqual(expectedSubChannelMarkers);
+  });
+
+  test('should return fetched sub channel markers with correct paging', async () => {
+    client.http.get = jest.fn().mockResolvedValueOnce(resolvedGetValue);
+
+    await expect(getSubChannelMarkers(subChannelIds, pagingCriteria)).resolves.toEqual(
+      expect.objectContaining({
+        data: expectedSubChannelMarkers,
+        prevPage: { before: 55, limit: 10 },
+        nextPage: { before: 55, limit: 10 },
+      }),
+    );
+  });
+
+  test('should update cache after fetching sub channel markers ', async () => {
+    enableCache();
+
+    client.http.get = jest.fn().mockResolvedValue(resolvedGetValue);
+
+    await getSubChannelMarkers(subChannelIds);
+    const received = subChannelMarkerCacheIds.map(
+      id => pullFromCache(['subChannelMarker', 'get', id])?.data,
+    );
+
+    expect(received).toEqual(expectedSubChannelMarkers);
+
+    disableCache();
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.get = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('Not Found', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(getSubChannelMarkers(subChannelIds)).rejects.toThrow(
+      'Amity SDK (400400): Not Found',
+    );
+  });
+
+  test('should fire event `onSubChannelMarkerFetched`', async () => {
+    let dispose;
+    client.http.get = jest.fn().mockResolvedValue(resolvedGetValue);
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onSubChannelMarkerFetched(resolve);
+    }).finally(dispose);
+
+    await getSubChannelMarkers(subChannelIds);
+
+    await expect(callbackPromise).resolves.toMatchObject(expectedSubChannelMarkers[0]);
+  });
+
+  test('should fire event `onUserMarkerFetched`', async () => {
+    let dispose;
+    client.http.get = jest.fn().mockResolvedValue(resolvedGetValue);
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onUserMarkerFetched(resolve);
+    }).finally(dispose);
+
+    await getSubChannelMarkers(subChannelIds);
+
+    await expect(callbackPromise).resolves.toMatchObject(expectedUserMarkers[0]);
+  });
+});

package/src/marker/events/index.ts

@@ -0,0 +1,10 @@
+export * from './onChannelMarkerFetched';
+
+export * from './onSubChannelMarkerFetched';
+export * from './onSubChannelMarkerUpdated';
+
+export * from './onFeedlMarkerFetched';
+
+export * from './onUserMarkerFetched';
+
+export * from './onMessageMarkerFetched';

package/src/marker/events/onChannelMarkerFetched.ts

@@ -0,0 +1,34 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ * ```js
+ * import { onChannelMarkerFetched } from '@amityco/ts-sdk'
+ * const dispose = onChannelMarkerFetched(channelMarker => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.ChannelMarker} has been fetched
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category ChannelMarker Events
+ */
+export const onChannelMarkerFetched = (
+  callback: Amity.Listener<Amity.ChannelMarker>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.Events['local.channelMarker.fetched']) => {
+    callback(payload.userEntityMarkers[0]);
+  };
+
+  return createEventSubscriber(
+    client,
+    'channelMarker/onChannelMarkerFetched',
+    'local.channelMarker.fetched',
+    filter,
+  );
+};

package/src/marker/events/onFeedlMarkerFetched.ts

@@ -0,0 +1,34 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ * ```js
+ * import { onFeedMarkerFetched } from '@amityco/ts-sdk'
+ * const dispose = onFeedMarkerFetched(feedMarker => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.FeedMarker} has been fetched
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category FeedMarker Events
+ */
+export const onFeedMarkerFetched = (
+  callback: Amity.Listener<Amity.FeedMarker>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.Events['local.feedMarker.fetched']) => {
+    callback(payload.feedMarkers[0]);
+  };
+
+  return createEventSubscriber(
+    client,
+    'feedMarker/onFeedMarkerFetched',
+    'local.feedMarker.fetched',
+    filter,
+  );
+};

package/src/marker/events/onMessageMarkerFetched.ts

@@ -0,0 +1,34 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ * ```js
+ * import { onMessageMarkerFetched } from '@amityco/ts-sdk'
+ * const dispose = onMessageMarkerFetched(messageMarker => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.MessageMarker} has been fetched
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category MessageMarker Events
+ */
+export const onMessageMarkerFetched = (
+  callback: Amity.Listener<Amity.MessageMarker>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.Events['local.messageMarker.fetched']) => {
+    callback(payload.contentMarkers[0]);
+  };
+
+  return createEventSubscriber(
+    client,
+    'messageMarker/onMessageMarkerFetched',
+    'local.messageMarker.fetched',
+    filter,
+  );
+};

package/src/marker/events/onSubChannelMarkerFetched.ts

@@ -0,0 +1,34 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ * ```js
+ * import { onSubChannelMarkerFetched } from '@amityco/ts-sdk'
+ * const dispose = onSubChannelMarkerFetched(subChannelMarker => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.SubChannelMarker} has been fetched
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category SubChannelMarker Events
+ */
+export const onSubChannelMarkerFetched = (
+  callback: Amity.Listener<Amity.SubChannelMarker>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.Events['local.subChannelMarker.fetched']) => {
+    callback(payload.userFeedMarkers[0]);
+  };
+
+  return createEventSubscriber(
+    client,
+    'subChannelMarker/onSubChannelMarkerFetched',
+    'local.subChannelMarker.fetched',
+    filter,
+  );
+};

package/src/marker/events/onSubChannelMarkerUpdated.ts

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