@amityco/ts-sdk 0.0.1-be4fc2f.0 → 0.0.1-bef76fa.0

package/src/poll/observers/observePoll.ts

@@ -0,0 +1,67 @@
+import { getActiveClient } from '~/client/api';
+
+import { createQuery, runQuery, queryOptions } from '~/core/query';
+
+import { getPoll } from '../api';
+
+import { onPollUpdated, onPollDeleted } from '../events';
+
+/**
+ * ```js
+ * import { observePoll } from '@amityco/ts-sdk'
+ *
+ * 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/post/api/approvePost.ts

@@ -0,0 +1,48 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+
+/**
+ * ```js
+ * import { approvePost } from '@amityco/ts-sdk'
+ *
+ * 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: approved } = await client.http.post<Amity.PostPayload>(
+    `/api/v3/posts/${encodeURIComponent(postId)}/approve`,
+  );
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(approved, { cachedAt });
+
+  // fire virtual event for community update
+  if (approved.posts[0].targetType === 'community') {
+    const community = approved.communities?.[0];
+
+    // @ts-ignore as communities is optional currently in PostPayload
+    fireEvent('community.updated', { communities: [community] });
+  }
+
+  fireEvent('post.approved', { posts: [approved.posts[0]] });
+
+  return {
+    data: approved.posts.find(post => post.postId === postId)!,
+    cachedAt,
+  };
+};

package/src/post/api/createPost.ts

@@ -1,8 +1,7 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { decoratePayload } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
-import { fireEvent } from '~/core/events'
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
 
 /**
  * ```js
@@ -23,27 +22,32 @@ import { fireEvent } from '~/core/events'
  * @async
  */
 export const createPost = async <T extends Amity.PostContentType | string>(
-  bundle: Pick<Amity.Post, 'targetType' | 'targetId' | 'metadata'> & {
-    dataType?: T, data: { [k: string]: any }
+  bundle: Pick<Amity.Post, 'targetType' | 'targetId' | 'metadata' | 'mentionees' | 'tags'> & {
+    dataType?: T;
+    data?: { [k: string]: any };
+    attachments?: { type: T; fileId: Amity.File['fileId'] }[];
   },
-) => {
-  const client = getActiveClient()
-  client.log('post/createPost', bundle)
+): 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'].includes(bundle.dataType))
-    delete bundle.dataType
+  if (!bundle.dataType || ['text', 'image', 'file', 'video'].includes(bundle.dataType)) {
+    // eslint-disable-next-line no-param-reassign
+    delete bundle.dataType;
+  }
 
-  const { data } = await client.http.post<Amity.PostPayload>(
-    '/api/v3/posts', bundle
-  )
+  const { data } = await client.http.post<Amity.PostPayload>('/api/v4/posts', bundle);
 
-  decoratePayload(data)
-  ingestInCache(data)
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
 
-  fireEvent('community.updated', { communities: data.communities! })
-  fireEvent('post.created', data)
+  fireEvent('post.created', data);
 
-  const { posts } = data
-  return posts[0]
-}
+  const { posts } = data;
+
+  return {
+    data: posts[0],
+    cachedAt,
+  };
+};

package/src/post/api/declinePost.ts

@@ -0,0 +1,48 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+
+/**
+ * ```js
+ * import { declinePost } from '@amityco/ts-sdk'
+ *
+ * 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: declined } = await client.http.post<Amity.PostPayload>(
+    `/api/v3/posts/${encodeURIComponent(postId)}/decline`,
+  );
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(declined, { cachedAt });
+
+  // fire virtual event
+  if (declined.posts[0].targetType === 'community') {
+    const community = declined.communities?.[0];
+
+    // @ts-ignore as communities is optional currently in PostPayload
+    fireEvent('community.updated', { communities: [community] });
+  }
+
+  fireEvent('post.declined', { posts: [declined.posts[0]] });
+
+  return {
+    data: declined.posts.find(post => post.postId === postId)!,
+    cachedAt,
+  };
+};

package/src/post/api/deletePost.ts

@@ -1,9 +1,11 @@
-import { getActiveClient } from '~/client/api'
-import { getCommunity } from '~/community/api'
-import { fireEvent } from '~/core/events'
-import { dropFromCache, mergeInCache } from '~/core/cache'
+import { getActiveClient } from '~/client/api';
 
-import { getPost } from './getPost'
+import { fireEvent } from '~/core/events';
+import { upsertInCache } from '~/cache/api';
+import { getCommunity } from '~/community/api';
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
+
+import { getPost } from './getPost';
 
 /**
  * ```js
@@ -21,44 +23,42 @@ import { getPost } from './getPost'
  */
 export const deletePost = async (
   postId: Amity.Post['postId'],
-  permanent: boolean = false,
-) => {
-  const client = getActiveClient()
-  client.log('post/deletePost', postId)
+  permanent = false,
+): Promise<Amity.Post> => {
+  const client = getActiveClient();
+  client.log('post/deletePost', postId);
 
-  let post = await getPost(postId)
+  const post = await getPost(postId);
 
   // API-FIX: This endpoint has not been implemented yet.
-  await client.http.delete<{ success: boolean }>(
-    `/api/v4/posts/${postId}`, {
-      params: {
-        postId,
-        permanent,
-      },
+  await client.http.delete<{ success: boolean }>(`/api/v4/posts/${encodeURIComponent(postId)}`, {
+    params: {
+      postId,
+      permanent,
     },
-  )
+  });
 
   // there is currently a limitation which doesn't allow us to fire event to tell that community
   // has been updated. reason is that, when the object is deleted, we don't have its `communityId`
   // and so we cannot refetch the community or advertise on events. hopefully this should be solved
   // later when realtime events covers that for us.
-  if (post.targetType === 'community') {
-    const community = await getCommunity(post.targetId);
-    fireEvent('community.updated', { communities: [community] })
+  if (post.data.targetType === 'community') {
+    const community = await getCommunity(post.data.targetId);
+    fireEvent('community.updated', { communities: [community.data] });
   }
 
   // to support hard deletion
-  const deleted = { ...post, isDeleted: true }
+  const deleted = { ...post.data, isDeleted: true };
 
-  fireEvent('post.afterDeleted', { posts: [deleted] })
+  fireEvent('post.deleted', { posts: [deleted] });
 
   if (permanent) {
     setTimeout(() => {
-      dropFromCache('post', {postId})
-    }, 0)
+      pushToTombstone('post', postId);
+    }, 0);
   } else {
-    mergeInCache('post', {postId, isDeleted: true})
+    upsertInCache(['post', 'get', postId], { isDeleted: true });
   }
 
-  return deleted
-}
+  return deleted;
+};

package/src/post/api/getPost.ts

@@ -1,13 +1,15 @@
-import { getActiveClient } from '~/client/api'
-import { ingestInCache, pullFromCache, dropFromCache } from '~/core/cache'
-import { decoratePayload } from '~/core/query'
+import { getActiveClient } from '~/client/api';
 
-import { getPosts } from './getPosts'
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { isInTombstone } from '~/cache/api/isInTombstone';
+import { checkIfShouldGoesToTombstone } from '~/cache/utils';
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
 
 /**
  * ```js
  * import { getPost } from '@amityco/ts-sdk'
- * const post = await getPost('foobar')
+ * const { data: post } = await getPost('foobar')
  * ```
  *
  * Fetches a {@link Amity.Post} object
@@ -18,55 +20,64 @@ import { getPosts } from './getPosts'
  * @category Post API
  * @async
  */
-export const getPost = async (
-  postId: Amity.Post['postId']
-) => {
-  const client = getActiveClient()
-  client.log('post/getPost', postId)
+export const getPost = async (postId: Amity.Post['postId']): Promise<Amity.Cached<Amity.Post>> => {
+  const client = getActiveClient();
+  client.log('post/getPost', postId);
+
+  isInTombstone('post', postId);
 
   let data: Amity.PostPayload;
 
   try {
     // API-FIX: endpoint should not be /list, parameters should be querystring.
     const response = await client.http.get<Amity.PostPayload>(
-      `/api/v3/posts/${postId}`,
-    )
-
+      `/api/v3/posts/${encodeURIComponent(postId)}`,
+    );
     data = response.data;
   } catch (error) {
-    if ((error as Amity.ErrorResponse)?.code  === Amity.ServerError.ITEM_NOT_FOUND) {
-      dropFromCache('post', {postId})
+    if (checkIfShouldGoesToTombstone((error as Amity.ErrorResponse)?.code)) {
+      pushToTombstone('post', postId);
     }
 
     throw error;
   }
 
-  decoratePayload(data)
-  ingestInCache(data)
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
 
-  const { posts } = data
-  return posts.find(post => post.postId === postId)!
-}
+  const { posts } = data;
+
+  return {
+    data: posts.find(post => post.postId === postId)!,
+    cachedAt,
+  };
+};
 
 /**
  * ```js
  * import { getPost } from '@amityco/ts-sdk'
- * const post = getPost.locally('foobar')
+ * const { data: post } = getPost.locally('foobar')
  * ```
  *
- * Fetches a {@link Amity.Post} object
+ * Fetches a {@link Amity.Post} object from cache
  *
  * @param postId the ID of the {@link Amity.Post} to fetch
  * @returns the associated {@link Amity.Post} object
  *
  * @category Post API
  */
-getPost.locally = (
-  postId: Amity.Post['postId']
-) => {
-  const client = getActiveClient()
-  client.log('post/getPost.locally', postId)
+getPost.locally = (postId: Amity.Post['postId']): Amity.Cached<Amity.Post> | undefined => {
+  const client = getActiveClient();
+  client.log('post/getPost.locally', postId);
+
+  if (!client.cache) return;
+
+  const cached = pullFromCache<Amity.Post>(['post', 'get', postId]);
+
+  if (!cached) return;
 
-  const [post] = pullFromCache('post', postId) ?? []
-  return post
-}
+  return {
+    data: cached.data,
+    cachedAt: cached.cachedAt,
+  };
+};

package/src/post/api/getPosts.ts

@@ -1,13 +1,12 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { decoratePayload } from '~/core/query'
-import { ingestInCache, pullFromCache } from '~/core/cache'
-import { toRecord } from '~/core/model'
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
 
 /**
  * ```js
  * import { getPosts } from '@amityco/ts-sdk'
- * const posts = await getPosts(['foo', 'bar'])
+ * const { data: posts } = await getPosts(['foo', 'bar'])
  * ```
  *
  * Fetches a collection of {@link Amity.Post} objects
@@ -19,28 +18,31 @@ import { toRecord } from '~/core/model'
  * @async
  */
 export const getPosts = async (
-  postIds: Amity.Post['postId'][]
-) => {
-  const client = getActiveClient()
-  client.log('post/getPosts', postIds)
+  postIds: Amity.Post['postId'][],
+): Promise<Amity.Cached<Amity.Post[]>> => {
+  const client = getActiveClient();
+  client.log('post/getPosts', postIds);
+
+  const encodedPostIds = postIds.map(postId => encodeURIComponent(postId));
 
   // API-FIX: endpoint should not be /list, parameters should be querystring.
-  const { data } = await client.http.get<Amity.PostPayload>(
-    `/api/v3/posts/list`,
-    { params: { postIds } }
-  )
+  const { data } = await client.http.get<Amity.PostPayload>(`/api/v3/posts/list`, {
+    params: { postIds: encodedPostIds },
+  });
 
-  decoratePayload(data)
-  ingestInCache(data)
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
 
-  const { posts } = data
-  return posts
-}
+  return {
+    data: data.posts,
+    cachedAt,
+  };
+};
 
 /**
  * ```js
  * import { getPosts } from '@amityco/ts-sdk'
- * const posts = getPosts.locally(['foo', 'bar'])
+ * const { data: posts } = getPosts.locally(['foo', 'bar'])
  * ```
  *
  * Fetches a collection of {@link Amity.Post} objects from cache
@@ -50,14 +52,23 @@ export const getPosts = async (
  *
  * @category Post API
  */
-getPosts.locally = (
-  postIds: Amity.Post['postId'][]
-) => {
-  const client = getActiveClient()
-  client.log('post/getPosts.locally', postIds)
+getPosts.locally = (postIds: Amity.Post['postId'][]): Amity.Cached<Amity.Post[]> | undefined => {
+  const client = getActiveClient();
+  client.log('post/getPosts.locally', postIds);
+
+  if (!client.cache) return;
+
+  const cached = postIds
+    .map(postId => pullFromCache<Amity.Post>(['post', 'get', postId])!)
+    .filter(Boolean);
+
+  const posts = cached.map(({ data }) => data);
+  const oldest = cached.sort((a, b) => (a.cachedAt! < b.cachedAt! ? -1 : 1))?.[0];
 
-  const cached = pullFromCache('post', ...postIds) ?? []
+  if (cached?.length < postIds.length) return;
 
-  if (cached?.length === postIds.length)
-    return toRecord(cached)
-}
+  return {
+    data: posts,
+    cachedAt: oldest.cachedAt,
+  };
+};

package/src/post/api/index.ts

@@ -1,7 +1,10 @@
-export * from './queryPosts'
-export * from './getPosts'
-export * from './getPost'
+export * from './queryPosts';
+export * from './getPosts';
+export * from './getPost';
 
-export * from './createPost'
-export * from './updatePost'
-export * from './deletePost'
+export * from './createPost';
+export * from './updatePost';
+export * from './deletePost';
+
+export * from './approvePost';
+export * from './declinePost';