@amityco/ts-sdk 6.35.2 → 6.35.3-024c022.0

package/src/client/observers/getTotalUnreadCount.ts

@@ -1,53 +0,0 @@
-import { ASCError } from '~/core/errors';
-import { getUserMarker } from '~/marker/api';
-import { onUserMarkerFetchedLegacy } from '~/marker/events';
-import { liveObject } from '~/utils/liveObject';
-
-import { getActiveUser } from '../api';
-
-/**
- * @deprecated Please use unreadCount from `getUserUnread` instead.
- *
- * ```js
- * import { getTotalUnreadCount } from '@amityco/ts-sdk';
- *
- * const unsubscribe = getTotalUnreadCount(response => {
- *   totalUnreadCount = response.data;
- * });
- * ```
- *
- * Observe current user's unread count from {@link Amity.UserMarker}
- *
- * @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 events
- *
- * @category Message Live Object
- */
-export const getTotalUnreadCount = (
-  callback: Amity.LiveObjectCallback<number>,
-): Amity.Unsubscriber => {
-  const { _id: userId } = getActiveUser();
-
-  if (!userId)
-    throw new ASCError(
-      'The _id has not been defined in ActiveUser',
-      Amity.ClientError.UNKNOWN_ERROR,
-      Amity.ErrorLevel.ERROR,
-    );
-
-  const callbackDataSelector = (data: Amity.UserMarker | undefined) => data?.unreadCount ?? 0;
-
-  return liveObject(
-    userId,
-    callback,
-    'userId',
-    async (): Promise<Amity.Cached<Amity.UserMarker>> => {
-      const { data: userMarker, cachedAt } = await getUserMarker();
-      return { data: userMarker as Amity.UserMarker, cachedAt };
-    },
-    [onUserMarkerFetchedLegacy],
-    {
-      callbackDataSelector,
-    },
-  );
-};

package/src/client/observers/tests/getTotalUnreadCount.test.ts

@@ -1,101 +0,0 @@
-import { getActiveUser, setActiveUser } from '~/client/api/activeUser';
-import { getTotalUnreadCount } from '~/client/observers';
-import { disableCache, enableCache } from '~/cache/api';
-import { pause, client, connectClient, disconnectClient, generateUserMarker } from '~/utils/tests';
-
-const refreshUpdateTime = <T extends ValueOf<Amity.Events>>(eventPayload: T): T => {
-  if (!eventPayload) return eventPayload;
-
-  // @ts-ignore
-  return Object.fromEntries(
-    Object.entries(eventPayload).map(([k, v]) => [
-      k,
-      v.map((model: Amity.Model) => ({
-        ...model,
-        updatedAt: Date.now(),
-      })),
-    ]),
-  );
-};
-
-const userId = 'user1';
-const userMarkerResponse = {
-  data: { userMarkers: [generateUserMarker({ userId, unreadCount: 0 })] },
-};
-
-describe('getTotalUnreadCount', () => {
-  beforeAll(async () => {
-    await connectClient();
-
-    // overwrite active userId with test id
-    setActiveUser({ ...getActiveUser(), _id: userId });
-  });
-
-  afterAll(disconnectClient);
-
-  beforeEach(enableCache);
-  afterEach(disableCache);
-
-  const events: [string, keyof Amity.Events, ValueOf<Amity.Events>, any][] = [
-    [
-      'it should return correct payload on `onUserMarkerFetched`',
-      'local.userMarker.fetched',
-      {
-        userMarkers: [generateUserMarker({ userId, unreadCount: 2 })],
-      },
-      {
-        origin: 'event',
-        loading: false,
-        data: 2,
-      },
-    ],
-  ];
-
-  test.each(events)('%s', async (test, event, eventPayload, expected) => {
-    const callback = jest.fn();
-    client.http.get = jest.fn().mockResolvedValueOnce(userMarkerResponse);
-
-    getTotalUnreadCount(callback);
-
-    await pause();
-
-    expect(callback).toHaveBeenCalledTimes(2);
-    // on initial, expect 0 unread count
-    expect(callback).toHaveBeenLastCalledWith({
-      origin: 'server',
-      loading: false,
-      error: undefined,
-      data: 0,
-    });
-
-    client.emitter.emit(event, refreshUpdateTime(eventPayload));
-
-    await pause();
-
-    expect(callback).toHaveBeenCalledTimes(3);
-    expect(callback).toHaveBeenLastCalledWith(expected);
-  });
-
-  test('it should filter out duplicated callback', async () => {
-    const callback = jest.fn();
-    client.http.get = jest.fn().mockResolvedValueOnce(userMarkerResponse);
-
-    const eventPayload = {
-      userMarkers: [generateUserMarker({ userId, unreadCount: 2 })],
-    };
-
-    getTotalUnreadCount(callback);
-
-    await pause();
-
-    // initial callback
-    expect(callback).toHaveBeenCalledTimes(2);
-
-    // emit duplicated event
-    client.emitter.emit('local.userMarker.fetched', refreshUpdateTime(eventPayload));
-
-    await pause();
-
-    expect(callback).toHaveBeenCalledTimes(3);
-  });
-});

package/src/commentRepository/observers/observeComment.ts

@@ -1,102 +0,0 @@
-import { getActiveClient } from '~/client/api';
-
-import { createQuery, queryOptions, runQuery } from '~/core/query';
-
-import { getComment } from '../internalApi/getComment';
-
-import {
-  onCommentDeleted,
-  onCommentFlagged,
-  onCommentReactionAdded,
-  onCommentReactionRemoved,
-  onCommentUnflagged,
-  onCommentUpdated,
-} from '../events';
-
-/**
- * ```js
- * import { observeComment } from '@amityco/ts-sdk'
- *
- * let comment = {}
- * const dispose = observeComment(commentId, ({ data }) => comment = data)
- * ```
- *
- * Observe all mutation on a given {@link Amity.InternalComment}
- *
- * @param commentId the ID of the comment 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 comment
- *
- * @category InternalComment Observer
- */
-export const observeComment = <
-  Events extends [
-    'onFetch',
-    'onUpdate',
-    'onDelete',
-    'onFlagged',
-    'onUnflagged',
-    'onReactionAdded',
-    'onReactionRemoved',
-  ],
->(
-  commentId: string,
-  callback: Amity.ObjectListener<Amity.Snapshot<Amity.InternalComment | undefined>, Events>,
-  policy: Amity.QueryPolicy = 'cache_then_server',
-): Amity.Unsubscriber => {
-  const { log } = getActiveClient();
-
-  const timestamp = Date.now();
-  log(`observeComment(tmpid: ${timestamp}) > listen`);
-
-  // wrapper function to make sure
-  const router = (
-    result: Amity.Snapshot<Amity.InternalComment | undefined>,
-    action: Events[number],
-  ) => {
-    if (callback instanceof Function) return callback(result);
-
-    if (action !== 'onFetch') callback.onEvent?.(action, result);
-
-    callback[action]?.(result);
-  };
-
-  const realtimeRouter = (
-    result: Amity.Snapshot<Amity.InternalComment>,
-    action: Events[number],
-  ) => {
-    if (result.data?.commentId !== commentId) return;
-
-    router(result, action);
-  };
-
-  const disposers: Amity.Unsubscriber[] = [];
-
-  disposers.push(
-    onCommentUpdated(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onUpdate')),
-    onCommentDeleted(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onDelete')),
-    onCommentFlagged(data =>
-      realtimeRouter({ data, loading: false, origin: 'event' }, 'onFlagged'),
-    ),
-    onCommentUnflagged(data =>
-      realtimeRouter({ data, loading: false, origin: 'event' }, 'onUnflagged'),
-    ),
-    onCommentReactionAdded(data =>
-      realtimeRouter({ data, loading: false, origin: 'event' }, 'onReactionAdded'),
-    ),
-    onCommentReactionRemoved(data =>
-      realtimeRouter({ data, loading: false, origin: 'event' }, 'onReactionRemoved'),
-    ),
-  );
-
-  runQuery(
-    createQuery(getComment, commentId),
-    result => (result.data || result.error) && router(result, 'onFetch'),
-    queryOptions(policy),
-  );
-
-  return () => {
-    log(`observeComment(tmpid: ${timestamp}) > dispose`);
-    disposers.forEach(fn => fn());
-  };
-};

package/src/commentRepository/observers/observeComments.ts

@@ -1,77 +0,0 @@
-import { getActiveClient } from '~/client/api';
-
-import {
-  onCommentCreated,
-  onCommentDeleted,
-  onCommentFlagged,
-  onCommentReactionAdded,
-  onCommentReactionRemoved,
-  onCommentUnflagged,
-  onCommentUpdated,
-} from '../events';
-
-/**
- * ```js
- * import { observeComments } from '@amityco/ts-sdk'
- *
- * let comments = []
- * const unsub = observeComments(postId, comment => merge(comments, comment))
- * ```
- *
- * Observe all mutations on a list of {@link Amity.InternalComment} for a given {@link Amity.Post} object
- *
- * @param postId the ID of the post where to observe the comments
- * @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 comments
- *
- * @category InternalComment Observer
- */
-export const observeComments = (
-  postId: Amity.Post['postId'],
-  callback: Amity.ObjectListener<
-    Amity.InternalComment,
-    [
-      'onCreate',
-      'onUpdate',
-      'onDelete',
-      'onFlagged',
-      'onUnflagged',
-      'onReactionAdded',
-      'onReactionRemoved',
-    ]
-  >,
-): Amity.Unsubscriber => {
-  const { log } = getActiveClient();
-
-  const timestamp = Date.now();
-  log(`observeComments(tmpid: ${timestamp}) > listen`);
-
-  const disposers: Amity.Unsubscriber[] = [];
-
-  const router = (
-    comment: Amity.InternalComment,
-    action: Exclude<Amity.CommentActionType, 'onFetch'>,
-  ) => {
-    if (comment.referenceId !== postId) return;
-
-    if (callback instanceof Function) return callback(comment);
-
-    callback.onEvent?.(action, comment);
-    callback[action]?.(comment);
-  };
-
-  disposers.push(
-    onCommentCreated(comment => router(comment, 'onCreate')),
-    onCommentUpdated(comment => router(comment, 'onUpdate')),
-    onCommentDeleted(comment => router(comment, 'onDelete')),
-    onCommentFlagged(comment => router(comment, 'onFlagged')),
-    onCommentUnflagged(comment => router(comment, 'onUnflagged')),
-    onCommentReactionAdded(comment => router(comment, 'onReactionAdded')),
-    onCommentReactionRemoved(comment => router(comment, 'onReactionRemoved')),
-  );
-
-  return () => {
-    log(`observeComments(tmpid: ${timestamp}) > dispose`);
-    disposers.forEach(fn => fn());
-  };
-};

package/src/communityRepository/api/getTopTrendingCommunities.ts

@@ -1,97 +0,0 @@
-import { getActiveClient } from '~/client/api';
-
-import { getResolver } from '~/core/model';
-import { pullFromCache, pushToCache } from '~/cache/api';
-import { ingestInCache } from '~/cache/api/ingestInCache';
-
-import { prepareCommunityPayload } from '../utils';
-
-/* begin_public_function
-  id: community.query.trending_communities
-*/
-/**
- * @deprecated This API renamed to `getTrendingCommunities()`.
- * Please use getTrendingCommunities() instead.
- *
- * ```js
- * import { CommunityRepository } from '@amityco/ts-sdk'
- * const trendingCommunities = await CommunityRepository.getTrendingCommunities()
- * ```
- *
- * Gets a list of top trending {@link Amity.Community} objects
- *
- * @param query The query parameters
- * @returns A list of {@link Amity.Community} objects
- *
- * @category Community API
- * @async
- */
-export const getTopTrendingCommunities = async (
-  query?: Partial<Amity.PageLimit>,
-): Promise<Amity.Cached<Amity.Community[]>> => {
-  const client = getActiveClient();
-  client.log('channel/getTopTrendingCommunities', query);
-
-  const { limit = 5 } = query ?? {};
-
-  // API-FIX: backend doesnt answer Amity.Response
-  // const { data } = await client.http.get<Amity.Response<CommunityPayload>>(
-  const { data: payload } = await client.http.get<Amity.CommunityPayload>(
-    `/api/v3/communities/top-trending`,
-    { params: { options: { limit } } },
-  );
-
-  const data = prepareCommunityPayload(payload);
-  const { communities } = data;
-
-  const cachedAt = client.cache && Date.now();
-
-  if (client.cache) {
-    ingestInCache(data, { cachedAt });
-
-    const cacheKey = ['community', 'top-trending', { params: { options: { limit } } }];
-    pushToCache(cacheKey, { communities: communities.map(getResolver('community')) });
-  }
-
-  return { data: communities, cachedAt };
-};
-/* end_public_function */
-
-/**
- * ```js
- * import { getTopTrendingCommunities } from '@amityco/ts-sdk'
- * const communities = getTopTrendingCommunities.locally()
- * ```
- *
- * Gets a list of top trending {@link Amity.Community} objects from cache
- *
- * @param query The query parameters
- * @returns communities
- *
- * @category Community API
- */
-getTopTrendingCommunities.locally = (
-  query: Parameters<typeof getTopTrendingCommunities>[0],
-): Amity.Cached<Amity.Community[]> | undefined => {
-  const client = getActiveClient();
-  client.log('community/getTopTrendingCommunities.locally', query);
-
-  if (!client.cache) return;
-
-  const { limit = 5 } = query ?? {};
-
-  const queryKey = ['community', 'top-trending', { params: { options: { limit } } }];
-  const { data, cachedAt } =
-    pullFromCache<{ communities: Pick<Amity.Community, 'communityId'>[] }>(queryKey) ?? {};
-
-  if (!data?.communities.length) return;
-
-  const communities: Amity.Community[] = data.communities
-    .map(communityId => pullFromCache<Amity.Community>(['community', 'get', communityId])!)
-    .filter(Boolean)
-    .map(({ data }) => data);
-
-  return communities.length === data?.communities?.length
-    ? { data: communities, cachedAt }
-    : undefined;
-};

package/src/communityRepository/api/test/getTopTrendingCommunities.test.ts

@@ -1,102 +0,0 @@
-import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
-import { client, community11, community21 } from '~/utils/tests';
-
-import { getTopTrendingCommunities } from '../getTopTrendingCommunities';
-
-const topTrendCommunities = [community11, community21];
-const topTrendIds = topTrendCommunities.map(({ communityId }) => communityId);
-
-const pagingToken = {
-  previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
-  next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
-};
-
-const pagingCriteria = { limit: 10 };
-
-const resolvedGetValue = {
-  data: {
-    communities: topTrendCommunities,
-    communityUsers: [community11, community21],
-    files: [],
-    users: [],
-    categories: [],
-    feeds: [],
-    paging: pagingToken,
-  },
-};
-
-describe('getTopTrendingCommunities', () => {
-  test('should return fetched top trend communities with correct paging', async () => {
-    client.http.get = jest.fn().mockResolvedValueOnce(resolvedGetValue);
-
-    await expect(getTopTrendingCommunities(pagingCriteria)).resolves.toEqual(
-      expect.objectContaining({ data: topTrendCommunities }),
-    );
-  });
-
-  test('should update cache after fetching top trend communities', async () => {
-    enableCache();
-    client.http.get = jest.fn().mockResolvedValue(resolvedGetValue);
-
-    await getTopTrendingCommunities(pagingCriteria);
-
-    const recieved = pullFromCache([
-      'community',
-      'top-trending',
-      { params: { options: pagingCriteria } },
-    ])?.data;
-
-    expect(recieved).toEqual({ communities: topTrendIds });
-
-    disableCache();
-  });
-
-  test('should throw an error if request fails', async () => {
-    client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
-
-    await expect(getTopTrendingCommunities(pagingCriteria)).rejects.toThrow('error');
-  });
-});
-
-describe('getTopTrendingCommunities.locally', () => {
-  beforeEach(() => enableCache());
-  afterEach(() => disableCache());
-
-  test('should return cached top trend communities', () => {
-    topTrendCommunities.forEach(community =>
-      pushToCache(['community', 'get', community.communityId], community),
-    );
-
-    pushToCache(['community', 'top-trending', { params: { options: pagingCriteria } }], {
-      communities: topTrendIds,
-    });
-
-    expect(getTopTrendingCommunities.locally(pagingCriteria)?.data).toEqual(topTrendCommunities);
-  });
-
-  test('it should return undefined if top trend communities not in cache', () => {
-    topTrendCommunities.forEach(community =>
-      pushToCache(['community', 'get', community.communityId], community),
-    );
-
-    pushToCache(['community', 'top-trending', { params: { options: pagingCriteria } }], {
-      communities: topTrendIds,
-    });
-
-    expect(getTopTrendingCommunities.locally({ limit: -1 })).toBeUndefined();
-  });
-
-  test('should return undefined if cache not enabled', () => {
-    disableCache();
-
-    topTrendCommunities.forEach(community =>
-      pushToCache(['community', 'get', community.communityId], community),
-    );
-
-    pushToCache(['community', 'top-trending', { params: { options: pagingCriteria } }], {
-      communities: topTrendIds,
-    });
-
-    expect(getTopTrendingCommunities.locally(pagingCriteria)).toBeUndefined();
-  });
-});

package/src/communityRepository/observers/observeCommunity.ts

@@ -1,103 +0,0 @@
-import { createQuery, runQuery } from '~/core/query/query';
-
-import { getActiveClient } from '~/client/api';
-
-import { getCommunity } from '../api/getCommunity';
-
-import { onCommunityUpdated, onCommunityDeleted } from '../events';
-import {
-  onCommunityUserAdded,
-  onCommunityUserRemoved,
-  onCommunityUserBanned,
-  onCommunityUserUnbanned,
-  onCommunityJoined,
-  onCommunityLeft,
-} from '../communityMembership/events';
-
-/**
- * ```js
- * import { observeCommunity } from '@amityco/ts-sdk'
- *
- * let community = {}
- * const dispose = observeCommunity(communityId, updated => community = updated)
- * ```
- *
- * Observe all mutation on a given {@link Amity.Community}
- *
- * @param communityId the ID of the community 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 community
- *
- * @category Community Observer
- */
-export const observeCommunity = <
-  Events extends [
-    'onFetch',
-    'onUpdate',
-    'onDelete',
-    'onJoin',
-    'onLeft',
-    'onUserAdded',
-    'onUserRemoved',
-    'onUserBanned',
-    'onUserUnbanned',
-  ],
->(
-  communityId: string,
-  callback: Amity.ObjectListener<Amity.Snapshot<Amity.Community | undefined>, Events>,
-): Amity.Unsubscriber => {
-  const { log } = getActiveClient();
-
-  const timestamp = Date.now();
-  log(`observeCommunity(tmpid: ${timestamp}) > listen`);
-
-  // wrapper function to make sure
-  const router = (result: Amity.Snapshot<Amity.Community | undefined>, action: Events[number]) => {
-    if (callback instanceof Function) return callback(result);
-
-    if (action !== 'onFetch') callback.onEvent?.(action, result);
-
-    callback[action]?.(result);
-  };
-
-  const realtimeRouter = (result: Amity.Snapshot<Amity.Community>, action: Events[number]) => {
-    if (result.data?.communityId !== communityId) return;
-
-    router(result, action);
-  };
-
-  const disposers: Amity.Unsubscriber[] = [];
-
-  disposers.push(
-    onCommunityUpdated(data =>
-      realtimeRouter({ data, loading: false, origin: 'event' }, 'onUpdate'),
-    ),
-    onCommunityDeleted(data =>
-      realtimeRouter({ data, loading: false, origin: 'event' }, 'onDelete'),
-    ),
-    onCommunityJoined(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onJoin')),
-    onCommunityLeft(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onLeft')),
-    onCommunityUserAdded(data =>
-      realtimeRouter({ data, loading: false, origin: 'event' }, 'onUserAdded'),
-    ),
-    onCommunityUserRemoved(data =>
-      realtimeRouter({ data, loading: false, origin: 'event' }, 'onUserRemoved'),
-    ),
-    onCommunityUserBanned(data =>
-      realtimeRouter({ data, loading: false, origin: 'event' }, 'onUserBanned'),
-    ),
-    onCommunityUserUnbanned(data =>
-      realtimeRouter({ data, loading: false, origin: 'event' }, 'onUserUnbanned'),
-    ),
-  );
-
-  runQuery(
-    createQuery(getCommunity, communityId),
-    result => (result.data || result.error) && router(result, 'onFetch'),
-  );
-
-  return () => {
-    log(`observeCommunity(tmpid: ${timestamp}) > dispose`);
-    disposers.forEach(fn => fn());
-  };
-};