@amityco/ts-sdk-react-native 6.7.1-80c1951.0

package/src/pollRepository/api/getPoll.ts

@@ -0,0 +1,68 @@
+import { getActiveClient } from '~/client/api';
+
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/* begin_public_function
+  id: poll.get
+*/
+/**
+ * ```js
+ * import { getPoll } from '@amityco/ts-sdk-react-native'
+ * const poll = await getPoll('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Poll} object
+ *
+ * @param pollId the ID of the {@link Amity.Poll} to fetch
+ * @returns the associated {@link Amity.Poll} object
+ *
+ * @category Poll API
+ * @async
+ */
+export const getPoll = async (pollId: Amity.Poll['pollId']): Promise<Amity.Cached<Amity.Poll>> => {
+  const client = getActiveClient();
+  client.log('poll/getPoll', pollId);
+
+  const { data } = await client.http.get<Amity.PollPayload>(`/api/v3/polls/${pollId}`);
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const { polls } = data;
+
+  return {
+    data: polls.find(poll => poll.pollId === pollId)!,
+    cachedAt,
+  };
+};
+/* end_public_function */
+
+/**
+ * ```js
+ * import { getPoll } from '@amityco/ts-sdk-react-native'
+ * const poll = getPoll.locally('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Poll} object
+ *
+ * @param pollId the ID of the {@link Amity.Poll} to fetch
+ * @returns the associated {@link Amity.Poll} object
+ *
+ * @category Poll API
+ */
+getPoll.locally = (pollId: Amity.Poll['pollId']): Amity.Cached<Amity.Poll> | undefined => {
+  const client = getActiveClient();
+  client.log('poll/getPoll', pollId);
+
+  if (!client.cache) return;
+
+  const cached = pullFromCache<Amity.Poll>(['poll', 'get', pollId]);
+
+  if (!cached) return;
+
+  return {
+    data: cached.data,
+    cachedAt: cached.cachedAt,
+  };
+};

package/src/pollRepository/api/index.ts

@@ -0,0 +1,5 @@
+export * from './createPoll';
+export * from './closePoll';
+export * from './deletePoll';
+
+export * from './votePoll';

package/src/pollRepository/api/tests/closePoll.test.ts

@@ -0,0 +1,50 @@
+import { client, pause, poll11 } from '~/utils/tests';
+import { ASCError } from '~/core/errors';
+import { disableCache, enableCache } from '~/cache/api';
+import { onPollUpdated } from '~/pollRepository/events';
+import { closePoll } from '../closePoll';
+import { getPoll } from '../getPoll';
+
+describe('closePoll', () => {
+  beforeAll(enableCache);
+  afterAll(disableCache);
+
+  // integration_test_id: b679db23-6a49-4858-ba53-2b64ced2f587
+  it('should close the poll', async () => {
+    client.http.put = jest
+      .fn()
+      .mockResolvedValueOnce({ data: { polls: [{ ...poll11, status: 'closed' }] } });
+    const callback = jest.fn();
+    onPollUpdated(callback);
+
+    const { data: poll } = await closePoll(poll11.pollId);
+    const { data: cachedPoll } = getPoll.locally(poll.pollId)!;
+    await pause();
+
+    expect(poll.status).toEqual('closed');
+    expect(cachedPoll).toMatchObject(poll);
+    expect(callback).toHaveBeenCalledWith(poll);
+  });
+
+  // integration_test_id: ec12e345-0e93-435b-9750-e81408fcb791
+  it('should fail to close if the poll does not exist', async () => {
+    client.http.put = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCError('error message', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.FATAL),
+      );
+
+    await expect(() => closePoll('non-existent-poll-id')).rejects.toThrow();
+  });
+
+  // integration_test_id: ed6ea62d-199c-4446-a3c3-554812707b42
+  it('should fail to close if user does not have permissions', async () => {
+    client.http.put = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCError('error message', Amity.ServerError.FORBIDDEN, Amity.ErrorLevel.FATAL),
+      );
+
+    await expect(() => closePoll('no-permissions-poll-id')).rejects.toThrow();
+  });
+});

package/src/pollRepository/api/tests/createPoll.test.ts

@@ -0,0 +1,70 @@
+import { client, poll11 } from '~/utils/tests';
+import { ASCError } from '~/core/errors';
+import { disableCache, enableCache } from '~/cache/api';
+import { createPoll } from '../createPoll';
+import { getPoll } from '../getPoll';
+
+describe('createPoll', () => {
+  beforeAll(enableCache);
+  afterAll(disableCache);
+
+  const bundle: Parameters<typeof createPoll>[0] = {
+    answerType: 'single',
+    answers: [
+      {
+        data: 'answer1',
+        dataType: 'text',
+      },
+      {
+        data: 'answer1',
+        dataType: 'text',
+      },
+    ],
+    question: 'question',
+  };
+
+  // integration_test_id: 5dc099fd-8e89-4f78-bf6c-fda6dbd06b66
+  it('should create a poll with a single answer', async () => {
+    client.http.post = jest.fn().mockResolvedValueOnce({ data: { polls: [poll11] } });
+
+    const { data: poll } = await createPoll(bundle);
+    const { data: cachedPoll } = getPoll.locally(poll.pollId)!;
+
+    expect(poll.pollId).toBeDefined();
+    expect(cachedPoll).toMatchObject(poll);
+  });
+
+  // integration_test_id: d18d4f13-6ac5-42f1-822b-a22fc0a7cf90
+  it('should create a poll with multiple answers', async () => {
+    client.http.post = jest.fn().mockResolvedValueOnce({ data: { polls: [poll11] } });
+
+    const { data: poll } = await createPoll({
+      ...bundle,
+      answerType: 'multiple',
+    });
+
+    expect(poll.pollId).toBeDefined();
+  });
+
+  // integration_test_id: 4cda145c-0bc8-4aaf-9ec0-02676bbde8a6
+  it('should fail if question exceeds 500 characters', async () => {
+    client.http.post = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCError('error message', Amity.ServerError.BUSINESS_ERROR, Amity.ErrorLevel.FATAL),
+      );
+
+    await expect(() => createPoll(bundle)).rejects.toThrow();
+  });
+
+  // integration_test_id: a96780e1-758e-4de7-9c18-fdb34c4cacc7
+  it('should fail if question exceeds 200 characters', async () => {
+    client.http.post = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCError('error message', Amity.ServerError.BUSINESS_ERROR, Amity.ErrorLevel.FATAL),
+      );
+
+    await expect(() => createPoll(bundle)).rejects.toThrow();
+  });
+});

package/src/pollRepository/api/tests/getPoll.test.ts

@@ -0,0 +1,31 @@
+import { client, poll11 } from '~/utils/tests';
+import { ASCError } from '~/core/errors';
+import { disableCache, enableCache } from '~/cache/api';
+import { getPoll } from '../getPoll';
+
+describe('getPoll', () => {
+  beforeAll(enableCache);
+  afterAll(disableCache);
+
+  // integration_test_id: 0d096a75-2f42-489e-8435-e3022eafb1a3
+  it('should fetch the poll', async () => {
+    client.http.get = jest.fn().mockResolvedValueOnce({ data: { polls: [poll11] } });
+
+    const { data: poll } = await getPoll(poll11.pollId);
+    const { data: cachedPoll } = getPoll.locally(poll11.pollId)!;
+
+    expect(poll.pollId).toEqual(poll11.pollId);
+    expect(cachedPoll).toMatchObject(poll);
+  });
+
+  // integration_test_id: 074fdf85-bbb6-4957-a89e-26aa10871dc4
+  it('should fail to fetch if the poll does not exist', async () => {
+    client.http.get = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCError('error message', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.FATAL),
+      );
+
+    await expect(() => getPoll('non-existent-poll-id')).rejects.toThrow();
+  });
+});

package/src/pollRepository/api/tests/votePoll.test.ts

@@ -0,0 +1,41 @@
+import { client, pause, poll11 } from '~/utils/tests';
+import { ASCError } from '~/core/errors';
+import { disableCache, enableCache } from '~/cache/api';
+import { onPollUpdated } from '~/pollRepository/events';
+import { votePoll } from '../votePoll';
+import { getPoll } from '../getPoll';
+
+describe('votePoll', () => {
+  beforeAll(enableCache);
+  afterAll(disableCache);
+
+  // integration_test_id: 2abcbca5-f845-4e96-9405-23781013738e
+  it('should vote', async () => {
+    client.http.post = jest
+      .fn()
+      .mockResolvedValueOnce({ data: { polls: [{ ...poll11, isVoted: true }] } });
+    const callback = jest.fn();
+    onPollUpdated(callback);
+
+    const { data: poll } = await votePoll(poll11.pollId, [poll11.answers[0].id]);
+    const { data: cachedPoll } = getPoll.locally(poll.pollId)!;
+    await pause();
+
+    expect(poll.isVoted).toEqual(true);
+    expect(cachedPoll).toMatchObject(poll);
+    expect(callback).toHaveBeenCalledWith(poll);
+  });
+
+  // integration_test_id: b6ab2681-7f25-47a0-bc14-f4f542a3cf80
+  it('should fail to vote for in an invalid poll', async () => {
+    client.http.post = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCError('error message', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.FATAL),
+      );
+
+    await expect(() =>
+      votePoll('non-existent-poll-id', ['non-existent-answer-id']),
+    ).rejects.toThrow();
+  });
+});

package/src/pollRepository/api/votePoll.ts

@@ -0,0 +1,48 @@
+import { fireEvent } from '~/core/events';
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/* begin_public_function
+  id: poll.vote
+*/
+/**
+ * ```js
+ * import { votePoll } from '@amityco/ts-sdk-react-native'
+ * const voted = await votePoll(pollId)
+ * ```
+ *
+ * Votes for an {@link Amity.Poll}
+ *
+ * @param pollId The ID of the {@link Amity.Poll} to vote
+ * @param answerIds The IDs of the {@link Amity.Poll} answers to vote {@link Amity.Poll}
+ * @returns the updated {@link Amity.Poll} object
+ *
+ * @category Poll API
+ * @async
+ */
+export const votePoll = async (
+  pollId: Amity.Poll['pollId'],
+  answerIds: string[],
+): Promise<Amity.Cached<Amity.Poll>> => {
+  const client = getActiveClient();
+  client.log('user/votePoll', pollId);
+
+  const { data } = await client.http.post<Amity.PollPayload>(
+    `/api/v3/polls/${encodeURIComponent(pollId)}/votes`,
+    { pollId, answerIds },
+  );
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const { polls } = data;
+
+  fireEvent('poll.updated', data);
+
+  return {
+    data: polls.find(poll => poll.pollId === pollId)!,
+    cachedAt,
+  };
+};
+/* end_public_function */

package/src/pollRepository/events/index.ts

@@ -0,0 +1,2 @@
+export * from './onPollUpdated';
+export * from './onPollDeleted';

package/src/pollRepository/events/onPollDeleted.ts

@@ -0,0 +1,31 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { onPollDeleted } from '@amityco/ts-sdk-react-native'
+ * const dispose = onPollDeleted(poll => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.Poll} has been deleted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Poll Events
+ */
+export const onPollDeleted = (callback: Amity.Listener<Amity.Poll>): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.Events['poll.deleted']) => {
+    if (client.cache) ingestInCache(payload);
+
+    callback(payload.polls[0]);
+  };
+
+  return createEventSubscriber(client, 'poll/onPollDeleted', 'poll.deleted', filter);
+};

package/src/pollRepository/events/onPollUpdated.ts

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

package/src/pollRepository/index.ts

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

package/src/pollRepository/observers/getPoll.ts

@@ -0,0 +1,33 @@
+import { liveObject } from '~/utils/liveObject';
+import { getPoll as _getPoll } from '../api/getPoll';
+import { onPollDeleted, onPollUpdated } from '../events';
+
+/* begin_public_function
+  id: poll.get
+*/
+/**
+ * ```js
+ * import { PollRepository } from '@amityco/ts-sdk-react-native';
+ *
+ * let poll;
+ *
+ * const unsub = PollRepository.getPoll(commentId, response => {
+ *   poll = response.data;
+ * });
+ * ```
+ *
+ * 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 Live Object
+ */
+export const getPoll = (
+  pollId: Amity.Poll['pollId'],
+  callback: Amity.LiveObjectCallback<Amity.Poll>,
+): Amity.Unsubscriber => {
+  return liveObject(pollId, callback, 'pollId', _getPoll, [onPollUpdated, onPollDeleted]);
+};
+/* end_public_function */

package/src/pollRepository/observers/index.ts

@@ -0,0 +1,2 @@
+export * from './observePoll';
+export * from './getPoll';

package/src/pollRepository/observers/observePoll.ts

@@ -0,0 +1,67 @@
+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/approvePost.ts

@@ -0,0 +1,52 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+import { prepareMembershipPayload } from '~/group/utils';
+
+/* begin_public_function
+  id: post.approve
+*/
+/**
+ * ```js
+ * import { approvePost } from '@amityco/ts-sdk-react-native'
+ *
+ * const { data: post } = await approvePost('postId')
+ * ```
+ *
+ * Approves a {@link Amity.Post}
+ *
+ * @param postId The {@link Amity.Post} ID to be approved
+ * @return A {@link Amity.Post} that was approved
+ *
+ * @category Post API
+ * @async
+ */
+export const approvePost = async (
+  postId: Amity.Post['postId'],
+): Promise<Amity.Cached<Amity.Post>> => {
+  const client = getActiveClient();
+  client.log('post/approvePost', postId);
+
+  const { data: payload } = await client.http.post<Amity.PostPayload>(
+    `/api/v3/posts/${encodeURIComponent(postId)}/approve`,
+  );
+
+  fireEvent('post.approved', payload);
+
+  // fire virtual event for community update
+  if (payload.posts[0].targetType === 'community') {
+    fireEvent('community.updated', payload);
+  }
+
+  const data = prepareMembershipPayload(payload, 'communityUsers');
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  return {
+    data: data.posts.find(post => post.postId === postId)!,
+    cachedAt,
+  };
+};
+/* end_public_function */

package/src/postRepository/api/createPost.ts

@@ -0,0 +1,60 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+import { prepareMembershipPayload } from '~/group/utils';
+
+/* begin_public_function
+  id: post.create.text_post, post.create.image_post, post.create.file_post, post.create.video_post, post.create.poll_post, post.create.livestream_post, post.create.custom_post
+*/
+/**
+ * ```js
+ * import { PostRepository } from '@amityco/ts-sdk-react-native'
+ * const created = await PostRepository.createPost({
+ *   targetType: 'user',
+ *   targetId: 'foobar',
+ *   data: { text: 'hello world' }
+ * }))
+ * ```
+ *
+ * Creates an {@link Amity.Post}
+ *
+ * @param bundle The data necessary to create a new {@link Amity.Post}
+ * @returns The newly created {@link Amity.Post}
+ *
+ * @category Post API
+ * @async
+ */
+export const createPost = async <T extends Amity.PostContentType>(
+  bundle: Pick<Amity.Post, 'targetType' | 'targetId' | 'metadata' | 'mentionees' | 'tags'> & {
+    dataType?: T;
+    data?: { [k: string]: any };
+    attachments?: { type: T; fileId: Amity.File['fileId'] }[];
+  },
+): Promise<Amity.Cached<Amity.Post>> => {
+  const client = getActiveClient();
+  client.log('post/createPost', bundle);
+
+  // API-FIX: backend rejects that we pass the dataType manually T_T
+  if (!bundle.dataType || ['text', 'image', 'file', 'video'].includes(bundle.dataType)) {
+    // eslint-disable-next-line no-param-reassign
+    delete bundle.dataType;
+  }
+
+  const { data: payload } = await client.http.post<Amity.PostPayload>('/api/v4/posts', bundle);
+
+  fireEvent('post.created', payload);
+
+  const data = prepareMembershipPayload(payload, 'communityUsers');
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const { posts } = data;
+
+  return {
+    data: posts[0],
+    cachedAt,
+  };
+};
+/* end_public_function */

package/src/postRepository/api/declinePost.ts

@@ -0,0 +1,52 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+import { prepareMembershipPayload } from '~/group/utils';
+
+/* begin_public_function
+  id: post.decline
+*/
+/**
+ * ```js
+ * import { declinePost } from '@amityco/ts-sdk-react-native'
+ *
+ * const {data: post} = await declinePost('postId')
+ * ```
+ *
+ * Declines a {@link Amity.Post}
+ *
+ * @param postId The {@link Amity.Post} ID to be declined
+ * @return A {@link Amity.Post} that was declined
+ *
+ * @category Post API
+ * @async
+ */
+export const declinePost = async (
+  postId: Amity.Post['postId'],
+): Promise<Amity.Cached<Amity.Post>> => {
+  const client = getActiveClient();
+  client.log('post/declinePost', postId);
+
+  const { data: payload } = await client.http.post<Amity.PostPayload>(
+    `/api/v3/posts/${encodeURIComponent(postId)}/decline`,
+  );
+
+  // fire virtual event
+  if (payload.posts[0].targetType === 'community') {
+    fireEvent('community.updated', payload);
+  }
+
+  fireEvent('post.declined', payload);
+
+  const data = prepareMembershipPayload(payload, 'communityUsers');
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  return {
+    data: payload.posts.find(post => post.postId === postId)!,
+    cachedAt,
+  };
+};
+/* end_public_function */