@amityco/ts-sdk-react-native 6.36.0 → 7.0.0

package/src/messageRepository/observers/observeMessages.ts

@@ -1,89 +0,0 @@
-import { getActiveClient } from '~/client/api';
-import { onMessageMarked, onMessageMarkerFetched } from '~/marker/events';
-import { convertEventPayload } from '~/utils/event';
-
-import { LinkedObject } from '~/utils/linkedObject';
-import {
-  onMessageCreatedLocal,
-  onMessageCreatedMqtt,
-  onMessageDeleted,
-  onMessageUpdated,
-} from '../events';
-
-/**
- * ```js
- * import { observeMessages } from '@amityco/ts-sdk-react-native'
- *
- * let messages = []
- *
- * const unsubscribe = observeMessages(channelId, message => merge(messages, message))
- * ```
- *
- * Observe all mutations on a list of {@link Amity.Message} for a given {@link Amity.SubChannel} object
- *
- * @param subChannelId the ID of the channel where to observe the messages
- * @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 Message Observer
- */
-export const observeMessages = (
-  subChannelId: Amity.SubChannel['subChannelId'],
-  callback: Amity.ObjectListener<
-    Amity.Snapshot<Amity.Message>,
-    ['onCreate', 'onUpdate', 'onDelete']
-  >,
-): Amity.Unsubscriber => {
-  const { log } = getActiveClient();
-
-  const timestamp = Date.now();
-  log(`observeMessages(tmpid: ${timestamp}) > listen`);
-
-  const disposers: Amity.Unsubscriber[] = [];
-
-  const router = (
-    message: Amity.Snapshot<Amity.Message>,
-    action: 'onCreate' | 'onUpdate' | 'onDelete',
-  ) => {
-    if (message.data?.subChannelId !== subChannelId) return;
-
-    if (callback instanceof Function) return callback(message);
-
-    callback.onEvent?.(action, message);
-    callback[action]?.(message);
-  };
-
-  disposers.push(
-    onMessageCreatedMqtt(data =>
-      router({ data: LinkedObject.message(data), loading: false, origin: 'event' }, 'onCreate'),
-    ),
-    onMessageCreatedLocal(data =>
-      router({ data: LinkedObject.message(data), loading: false, origin: 'event' }, 'onCreate'),
-    ),
-    onMessageUpdated(data =>
-      router({ data: LinkedObject.message(data), loading: false, origin: 'event' }, 'onUpdate'),
-    ),
-    onMessageDeleted(data =>
-      router({ data: LinkedObject.message(data), loading: false, origin: 'event' }, 'onDelete'),
-    ),
-    convertEventPayload(
-      onMessageMarkerFetched,
-      'contentId',
-      'message',
-    )(data =>
-      router({ data: LinkedObject.message(data), loading: false, origin: 'event' }, 'onCreate'),
-    ),
-    convertEventPayload(
-      onMessageMarked,
-      'contentId',
-      'message',
-    )(data =>
-      router({ data: LinkedObject.message(data), loading: false, origin: 'event' }, 'onCreate'),
-    ),
-  );
-
-  return () => {
-    log(`observeMessages(tmpid: ${timestamp}) > dispose`);
-    disposers.forEach(fn => fn());
-  };
-};

package/src/pollRepository/observers/observePoll.ts

@@ -1,67 +0,0 @@
-import { getActiveClient } from '~/client/api';
-
-import { createQuery, runQuery, queryOptions } from '~/core/query';
-
-import { getPoll as _getPoll } from '../api/getPoll';
-
-import { onPollUpdated, onPollDeleted } from '../events';
-
-/**
- * ```js
- * import { observePoll } from '@amityco/ts-sdk-react-native'
- *
- * let poll = {}
- * const dispose = observePoll(pollId, updated => poll = updated)
- * ```
- *
- * Observe all mutation on a given {@link Amity.Poll}
- *
- * @param pollId the ID of the poll 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 poll
- *
- * @category Poll Observer
- */
-export const observePoll = <Events extends ['onFetch', 'onUpdate', 'onDelete']>(
-  pollId: string,
-  callback: Amity.ObjectListener<Amity.Snapshot<Amity.Poll | undefined>, Events>,
-  policy: Amity.QueryPolicy = 'cache_then_server',
-): Amity.Unsubscriber => {
-  const { log } = getActiveClient();
-
-  const timestamp = Date.now();
-  log(`observePoll(tmpid: ${timestamp}) > listen`);
-
-  // wrapper function to make sure
-  const router = (result: Amity.Snapshot<Amity.Poll | 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.Poll>, action: Events[number]) => {
-    if (result.data?.pollId !== pollId) return;
-
-    router(result, action);
-  };
-
-  const disposers: Amity.Unsubscriber[] = [];
-
-  disposers.push(
-    onPollUpdated(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onUpdate')),
-    onPollDeleted(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onDelete')),
-  );
-
-  runQuery(
-    createQuery(_getPoll, pollId),
-    result => (result.data || result.error) && router(result, 'onFetch'),
-    queryOptions(policy),
-  );
-
-  return () => {
-    log(`observePoll(tmpid: ${timestamp}) > dispose`);
-    disposers.forEach(fn => fn());
-  };
-};

package/src/postRepository/api/updatePost.ts

@@ -1,63 +0,0 @@
-import { getActiveClient } from '~/client/api';
-
-import { ingestInCache } from '~/cache/api/ingestInCache';
-import { fireEvent } from '~/core/events';
-import { prepareMembershipPayload } from '~/group/utils';
-import { LinkedObject } from '~/utils/linkedObject';
-
-/* begin_public_function
-  id: post.edit
-*/
-/**
- * ```js
- * import { updatePost } from '@amityco/ts-sdk-react-native'
- * const updated = await updatePost(postId, {
- *   data: { text: 'hello world' }
- * })
- * ```
- *
- * Updates an {@link Amity.Post}
- *
- * @param postId The ID of the {@link Amity.Post} to edit
- * @param patch The patch data to apply
- * @returns the updated {@link Amity.Post} object
- *
- * @category Post API
- * @async
- */
-export const updatePost = async <T extends Amity.PostContentType>(
-  postId: Amity.Post['postId'],
-  patch: Patch<Amity.Post, 'data' | 'metadata' | 'mentionees' | 'tags'> & {
-    attachments?: {
-      type: T;
-      fileId: Amity.File['fileId'];
-    }[];
-  },
-): Promise<Amity.Cached<Amity.Post>> => {
-  const client = getActiveClient();
-  client.log('user/updatePost', patch);
-
-  console.warn(
-    'Deprecation: updatePost has been renamed to editPost. Update post API will be deprecated soon.',
-  );
-
-  const { data: payload } = await client.http.put<Amity.PostPayload>(
-    `/api/v4/posts/${encodeURIComponent(postId)}`,
-    patch,
-  );
-
-  const data = prepareMembershipPayload(payload, 'communityUsers');
-
-  const cachedAt = client.cache && Date.now();
-  if (client.cache) ingestInCache(data, { cachedAt });
-
-  fireEvent('local.post.updated', payload);
-
-  const { posts } = data;
-
-  return {
-    data: LinkedObject.post(posts.find(post => post.postId === postId)!),
-    cachedAt,
-  };
-};
-/* end_public_function */

package/src/postRepository/observers/observePost.ts

@@ -1,115 +0,0 @@
-import { getActiveClient } from '~/client/api';
-
-import { createQuery, queryOptions, runQuery } from '~/core/query';
-
-import { LinkedObject } from '~/utils/linkedObject';
-import { getPost } from '../api/getPost';
-
-import {
-  onPostApproved,
-  onPostDeclined,
-  onPostDeleted,
-  onPostFlagged,
-  onPostReactionAdded,
-  onPostReactionRemoved,
-  onPostUnflagged,
-  onPostUpdated,
-} from '../events';
-
-/**
- * ```js
- * import { observePost } from '@amityco/ts-sdk-react-native'
- *
- * let post = {}
- * const dispose = observePost(postId, updated => post = updated)
- * ```
- *
- * Observe all mutations on a given {@link Amity.Post}
- *
- * @param postId the ID of the post 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 post
- *
- * @category Post Observer
- */
-export const observePost = <
-  Events extends [
-    'onFetch',
-    'onUpdate',
-    'onDelete',
-    'onApproved',
-    'onDeclined',
-    'onFlagged',
-    'onUnflagged',
-    'onReactionAdded',
-    'onReactionRemoved',
-  ],
->(
-  postId: Amity.Post['postId'],
-  callback: Amity.ObjectListener<Amity.Snapshot<Amity.Post | undefined>, Events>,
-  policy: Amity.QueryPolicy = 'cache_then_server',
-): Amity.Unsubscriber => {
-  const { log } = getActiveClient();
-
-  const timestamp = Date.now();
-  log(`observePost(tmpid: ${timestamp}) > listen`);
-
-  // wrapper function to make sure
-  const router = (result: Amity.Snapshot<Amity.Post | 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.InternalPost>, action: Events[number]) => {
-    if (result.data?.postId !== postId) return;
-
-    router(
-      {
-        ...result,
-        data: result.data && LinkedObject.post(result.data),
-      },
-      action,
-    );
-  };
-
-  const disposers: Amity.Unsubscriber[] = [];
-
-  disposers.push(
-    onPostUpdated(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onUpdate')),
-    onPostDeleted(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onDelete')),
-    onPostApproved(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onApproved')),
-    onPostDeclined(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onDeclined')),
-    onPostFlagged(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onFlagged')),
-    onPostUnflagged(data =>
-      realtimeRouter({ data, loading: false, origin: 'event' }, 'onUnflagged'),
-    ),
-    onPostReactionAdded(data =>
-      realtimeRouter({ data, loading: false, origin: 'event' }, 'onReactionAdded'),
-    ),
-    onPostReactionRemoved(data =>
-      realtimeRouter({ data, loading: false, origin: 'event' }, 'onReactionRemoved'),
-    ),
-  );
-
-  runQuery(
-    createQuery(getPost, postId),
-    result =>
-      (result.data || result.error) &&
-      router(
-        {
-          ...result,
-          data: result.data && LinkedObject.post(result.data),
-        },
-        'onFetch',
-      ),
-    queryOptions(policy),
-  );
-
-  return () => {
-    log(`observePosts(tmpid: ${timestamp}) > dispose`);
-    disposers.forEach(fn => fn());
-  };
-};

package/src/postRepository/observers/observePosts.ts

@@ -1,86 +0,0 @@
-import { getActiveClient } from '~/client/api';
-import { LinkedObject } from '~/utils/linkedObject';
-import {
-  onPostApproved,
-  onPostCreated,
-  onPostDeclined,
-  onPostDeleted,
-  onPostFlagged,
-  onPostReactionAdded,
-  onPostReactionRemoved,
-  onPostUnflagged,
-  onPostUpdated,
-} from '../events';
-
-/**
- * ```js
- * import { PostRepository } from '@amityco/ts-sdk-react-native'
- *
- * let posts = []
- * const unsub = PostRepository.observePosts({
- *   targetType: Amity.PostTargetType,
- *   targetId: Amity.InternalPost['targetId'],
- * }, post => merge(posts, post))
- * ```
- *
- * Observe all mutations on a list of {@link Amity.Post} for a given target object
- *
- * @param params
- * @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 Post Observer
- */
-export const observePosts = (
-  params: {
-    targetType: Amity.PostTargetType;
-    targetId: Amity.Post['targetId'];
-  },
-  callback: Amity.ObjectListener<
-    Amity.Post,
-    [
-      'onCreate',
-      'onUpdate',
-      'onDelete',
-      'onApproved',
-      'onDeclined',
-      'onFlagged',
-      'onUnflagged',
-      'onReactionAdded',
-      'onReactionRemoved',
-    ]
-  >,
-): Amity.Unsubscriber => {
-  const { log } = getActiveClient();
-
-  const timestamp = Date.now();
-  log(`observePosts(tmpid: ${timestamp}) > listen`);
-
-  const disposers: Amity.Unsubscriber[] = [];
-
-  const router = (post: Amity.InternalPost, action: Exclude<Amity.PostActionType, 'onFetch'>) => {
-    if (params.targetId !== post.targetId || params.targetType !== post.targetType) return;
-
-    if (callback instanceof Function) return callback(LinkedObject.post(post));
-
-    callback.onEvent?.(action, LinkedObject.post(post));
-    callback[action]?.(LinkedObject.post(post));
-  };
-
-  disposers.push(
-    onPostCreated(post => router(post, 'onCreate')),
-    onPostUpdated(post => router(post, 'onUpdate')),
-    onPostDeleted(post => router(post, 'onDelete')),
-    onPostApproved(post => router(post, 'onApproved')),
-    onPostDeclined(post => router(post, 'onDeclined')),
-    onPostFlagged(post => router(post, 'onFlagged')),
-    onPostUnflagged(post => router(post, 'onUnflagged')),
-    onPostReactionAdded(post => router(post, 'onReactionAdded')),
-    onPostReactionRemoved(post => router(post, 'onReactionRemoved')),
-  );
-
-  return () => {
-    log(`observePosts(tmpid: ${timestamp}) > dispose`);
-    disposers.forEach(fn => fn());
-  };
-};

package/src/streamRepository/api/queryStreams.ts

@@ -1,63 +0,0 @@
-import { getActiveClient } from '~/client/api';
-
-import { toPage, toToken } from '~/core/query';
-import { ingestInCache } from '~/cache/api/ingestInCache';
-
-/* begin_public_function
-  id: stream.query
-*/
-/**
- * @deprecated This API renamed to `getStreams`.
- * Please use getStreams() instead.
- * ```js
- * import { getStreams } from '@amityco/ts-sdk-react-native'
- * const streams = await getStreams()
- * ```
- *
- * Queries a paginable list of {@link Amity.InternalStream} objects
- *
- * @param query The query parameters
- * @returns A page of {@link Amity.InternalStream} objects
- *
- * @category Stream API
- * @async
- */
-export const queryStreams = async (query?: {
-  isLive?: boolean;
-  statuses?: Amity.StreamStatus[];
-  userPublicIds?: Amity.InternalUser['userId'][];
-  sortBy?: 'lastCreated' | 'firstCreated';
-  isDeleted?: Amity.InternalStream['isDeleted'];
-  page?: Amity.Page;
-}): Promise<Amity.Cached<Amity.Paged<Amity.InternalStream>>> => {
-  const client = getActiveClient();
-  client.log('stream/queryStreams', query);
-
-  const { page, ...params } = query ?? {};
-
-  const { data } = await client.http.get<{ results: Amity.StreamPayload } & Amity.Pagination>(
-    `/api/v3/video-streaming`,
-    {
-      params: {
-        ...params,
-        options: {
-          token: toToken(page, 'skiplimit'),
-        },
-      },
-    },
-  );
-
-  // API-FIX: backend to response Amity.Response: const { paging, videoStreamings } = unwrapPayload(data)
-  // API-FIX: seems returned data has a results identifier on top of data, like no other apis, and this is beautiful
-  const { paging, results: payload } = data;
-  const { videoStreamings } = payload;
-
-  const cachedAt = client.cache && Date.now();
-  if (client.cache) ingestInCache(payload as Amity.StreamPayload, { cachedAt });
-
-  const nextPage = toPage(paging.next);
-  const prevPage = toPage(paging.previous);
-
-  return { data: videoStreamings, cachedAt, prevPage, nextPage };
-};
-/* end_public_function */

package/src/userRepository/observers/getViewedUsers.ts

@@ -1,99 +0,0 @@
-import { getActiveClient } from '~/client';
-import { COLLECTION_DEFAULT_CACHING_POLICY, ENABLE_CACHE_MESSAGE } from '~/utils/constants';
-import { dropFromCache, pullFromCache, pushToCache } from '~/cache/api';
-import { createQuery, queryOptions, runQuery } from '~/core/query';
-import { CACHE_SHORTEN_LIFESPAN } from '~/cache/utils';
-import { queryReachUser } from '~/analytic/api/queryReachUser';
-
-/**
- * @deprecated: Please use {@link UserRepository.getReachUsers} instead
- * @param params
- * @param callback
- */
-export const getViewedUsers = (
-  params: Amity.PostViewedUsersLiveCollection,
-  callback: Amity.LiveCollectionCallback<Amity.User | undefined>,
-): Amity.Unsubscriber => {
-  const { log, cache } = getActiveClient();
-  const cacheKey = ['postViewedUsers', 'collection', { postId: params.postId }];
-
-  if (!cache) {
-    console.log(ENABLE_CACHE_MESSAGE);
-  }
-
-  const timestamp = Date.now();
-  log(`getViewedUsers(tmpid: ${timestamp}) > listen`);
-
-  const { limit: queryLimit, postId } = params;
-
-  const responder = (snapshot: {
-    loading?: boolean;
-    params?: { page: { next: Amity.Token; previous?: Amity.Token } };
-    data: Amity.User['userId'][];
-  }) => {
-    let users: (Amity.User | undefined)[] = [];
-
-    if (snapshot?.data) {
-      users =
-        snapshot.data
-          .map((userId: Amity.User['userId']) => pullFromCache<Amity.User>(['user', 'get', userId]))
-          .filter(Boolean)
-          .map(data => data?.data) || [];
-    }
-
-    callback({
-      // eslint-disable-next-line no-use-before-define
-      onNextPage: onFetch,
-      data: users,
-      hasNextPage: !!snapshot.params?.page?.next,
-      loading: snapshot.loading || false,
-    });
-  };
-
-  const onFetch = (initial = false) => {
-    const collection = pullFromCache<Amity.PostViewedUsersLiveCollectionCache>(cacheKey)?.data;
-
-    const users = collection?.data ?? [];
-
-    if (!initial && users.length > 0 && !collection?.params.page) return;
-
-    const query = createQuery(queryReachUser, {
-      viewId: postId,
-      viewedType: Amity.AnalyticEventContentType.Post,
-      limit: queryLimit || 10,
-      token: !initial ? collection?.params.page?.next : undefined,
-    });
-
-    runQuery(
-      query,
-      result => {
-        let userIds =
-          pullFromCache<Amity.PostViewedUsersLiveCollectionCache>(cacheKey)?.data?.data ?? [];
-
-        if (result.data?.users) {
-          userIds = [
-            ...new Set([...userIds, ...result.data.users.map(({ userId }: Amity.User) => userId)]),
-          ];
-        }
-
-        const saveToCache = {
-          loading: result.loading,
-          params: { page: result.data?.paging },
-          data: userIds || [],
-        };
-
-        pushToCache(cacheKey, saveToCache);
-
-        responder(saveToCache);
-      },
-      queryOptions(COLLECTION_DEFAULT_CACHING_POLICY, CACHE_SHORTEN_LIFESPAN),
-    );
-  };
-
-  onFetch(true);
-
-  return () => {
-    log(`getViewedUsers(tmpid: ${timestamp}) > dispose`);
-    dropFromCache(cacheKey);
-  };
-};

package/src/userRepository/observers/observeUser.ts

@@ -1,71 +0,0 @@
-import { createQuery, runQuery } from '~/core/query/query';
-
-import { getActiveClient } from '~/client/api';
-
-import { getUser } from '../api/getUser';
-import {
-  onUserUpdated,
-  onUserDeleted,
-  onUserFlagged,
-  onUserUnflagged,
-  onUserFlagCleared,
-} from '../events';
-import { LinkedObject } from '~/utils/linkedObject';
-
-/**
- * ```js
- * import { observeUser } from '@amityco/ts-sdk-react-native'
- *
- * let user = {}
- * const dispose = observeUser(userId, updated => user = updated)
- * ```
- *
- * @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 user
- *
- * Observe all mutation on a given {@link Amity.InternalUser}
- * @category User Observer
- */
-export const observeUser = <
-  Events extends ['onFetch', 'onUpdate', 'onDelete', 'onFlagged', 'onUnflagged', 'onFlagCleared'],
->(
-  userId: string,
-  callback: Amity.ObjectListener<Amity.Snapshot<Amity.InternalUser>, Events>,
-): Amity.Unsubscriber => {
-  const { log } = getActiveClient();
-
-  const timestamp = Date.now();
-  log(`observeUser(tmpid: ${timestamp}) > listen`);
-
-  // wrapper function to make sure
-  const router = (result: Amity.Snapshot<Amity.InternalUser>, action: Events[number]) => {
-    // filter function
-    if (result.data?.userId !== userId) return;
-
-    const newResult = { ...result, data: LinkedObject.user(result.data) };
-
-    if (callback instanceof Function) return callback(newResult);
-
-    if (action !== 'onFetch') callback.onEvent?.(action, newResult);
-
-    callback[action]?.(newResult);
-  };
-
-  const disposers: Amity.Unsubscriber[] = [];
-
-  disposers.push(
-    onUserUpdated(data => router({ data, loading: false, origin: 'event' }, 'onUpdate')),
-    onUserDeleted(data => router({ data, loading: false, origin: 'event' }, 'onDelete')),
-    onUserFlagged(data => router({ data, loading: false, origin: 'event' }, 'onFlagged')),
-    onUserUnflagged(data => router({ data, loading: false, origin: 'event' }, 'onUnflagged')),
-    onUserFlagCleared(data => router({ data, loading: false, origin: 'event' }, 'onFlagCleared')),
-  );
-
-  runQuery(createQuery(getUser, userId), result => result.data && router(result, 'onFetch'));
-
-  return () => {
-    log(`observeUser(tmpid: ${timestamp}) > dispose`);
-    disposers.forEach(fn => fn());
-  };
-};

package/src/userRepository/observers/tests/getViewedUsers.test.ts

@@ -1,39 +0,0 @@
-import { disableCache, enableCache } from '~/cache/api';
-import {
-  client,
-  connectClient,
-  deepCopy,
-  disconnectClient,
-  pause,
-  post11,
-  viewedUserQueryResponse,
-} from '~/utils/tests';
-
-import { getViewedUsers } from '../getViewedUsers';
-
-describe('getViewedUsers', () => {
-  beforeAll(connectClient);
-  afterAll(disconnectClient);
-
-  beforeEach(enableCache);
-  afterEach(disableCache);
-
-  test('should return users collection', async () => {
-    const callback = jest.fn();
-    client.http.get = jest.fn().mockResolvedValue(viewedUserQueryResponse);
-
-    getViewedUsers({ postId: post11.postId }, callback);
-    await pause();
-
-    expect(callback).toHaveBeenCalledTimes(2);
-    expect(deepCopy(callback.mock.calls[1][0])).toEqual(
-      expect.objectContaining(
-        deepCopy({
-          data: viewedUserQueryResponse.data.users,
-          loading: false,
-          hasNextPage: false,
-        }),
-      ),
-    );
-  });
-});