@amityco/ts-sdk 0.0.1-beta.1 → 0.0.1-beta.13

package/src/post/api/createPost.ts

@@ -0,0 +1,53 @@
+import { getActiveClient } from '~/client/api'
+
+import { ingestInCache } from '~/cache/api/ingestInCache'
+import { fireEvent } from '~/core/events'
+
+/**
+ * ```js
+ * import { createPost } from '@amityco/ts-sdk'
+ * const created = await 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 | string>(
+  bundle: Pick<Amity.Post, 'targetType' | 'targetId' | 'metadata' | 'mentionees'> & {
+    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))
+    delete bundle.dataType
+
+  const { data } = await client.http.post<Amity.PostPayload>(
+    '/api/v4/posts', bundle
+  )
+
+  const cachedAt = client.cache && Date.now()
+  if (client.cache) ingestInCache(data, { cachedAt })
+
+  fireEvent('post.created', data)
+
+  const { posts } = data
+
+  return {
+    data: posts[0],
+    cachedAt,
+  }
+}

package/src/post/api/deletePost.ts

@@ -0,0 +1,66 @@
+import { getActiveClient } from '~/client/api'
+
+import { getCommunity } from '~/community/api'
+import { dropFromCache } from '~/cache/api'
+import { upsertInCache } from '~/cache/api'
+import { fireEvent } from '~/core/events'
+
+import { getPost } from './getPost'
+
+/**
+ * ```js
+ * import { deletePost } from '@amityco/ts-sdk'
+ * const success = await deletePost('foobar')
+ * ```
+ *
+ * Deletes a {@link Amity.Post}
+ *
+ * @param postId The {@link Amity.Post} ID to delete
+ * @return A success boolean if the {@link Amity.Post} was deleted
+ *
+ * @category Post API
+ * @async
+ */
+export const deletePost = async (
+  postId: Amity.Post['postId'],
+  permanent: boolean = false,
+): Promise<Amity.Post> => {
+  const client = getActiveClient()
+  client.log('post/deletePost', postId)
+
+  let post = await getPost(postId)
+
+  // API-FIX: This endpoint has not been implemented yet.
+  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.data.targetType === 'community') {
+    const community = await getCommunity(post.data.targetId);
+    fireEvent('community.updated', { communities: [community.data] })
+  }
+
+  // to support hard deletion
+  const deleted = { ...post.data, isDeleted: true }
+
+  fireEvent('post.deleted', { posts: [deleted] })
+
+  if (permanent) {
+    setTimeout(() => {
+      dropFromCache(['post', 'get', postId], true)
+    }, 0)
+  } else {
+    upsertInCache(['post', 'get', postId], {isDeleted: true})
+  }
+
+  return deleted
+}

package/src/post/api/getPost.ts

@@ -0,0 +1,84 @@
+import { getActiveClient } from '~/client/api'
+
+import { pullFromCache, dropFromCache } from '~/cache/api'
+import { ingestInCache } from '~/cache/api/ingestInCache'
+
+/**
+ * ```js
+ * import { getPost } from '@amityco/ts-sdk'
+ * const { data: post } = await getPost('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Post} object
+ *
+ * @param postId the ID of the {@link Amity.Post} to fetch
+ * @returns the associated {@link Amity.Post} object
+ *
+ * @category Post API
+ * @async
+ */
+export const getPost = async (
+  postId: Amity.Post['postId']
+): Promise<Amity.Cached<Amity.Post>> => {
+  const client = getActiveClient()
+  client.log('post/getPost', 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/${encodeURIComponent(postId)}`,
+    )
+
+    data = response.data;
+  } catch (error) {
+    if ((error as Amity.ErrorResponse)?.code  === Amity.ServerError.ITEM_NOT_FOUND) {
+      dropFromCache(['post', 'get', postId], true)
+    }
+
+    throw error;
+  }
+
+  const cachedAt = client.cache && Date.now()
+  if (client.cache) ingestInCache(data, { cachedAt })
+
+  const { posts } = data
+
+  return {
+    data: posts.find(post => post.postId === postId)!,
+    cachedAt,
+  }
+}
+
+/**
+ * ```js
+ * import { getPost } from '@amityco/ts-sdk'
+ * const { data. post } = getPost.locally('foobar')
+ * ```
+ *
+ * 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']
+): 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
+
+  return {
+    data: cached.data,
+    cachedAt: cached.cachedAt,
+  }
+}

package/src/post/api/getPosts.ts

@@ -0,0 +1,78 @@
+import { getActiveClient } from '~/client/api'
+
+import { pullFromCache } from '~/cache/api'
+import { ingestInCache } from '~/cache/api/ingestInCache'
+
+/**
+ * ```js
+ * import { getPosts } from '@amityco/ts-sdk'
+ * const { data: posts } = await getPosts(['foo', 'bar'])
+ * ```
+ *
+ * Fetches a collection of {@link Amity.Post} objects
+ *
+ * @param postIds the IDs of the {@link Amity.Post} to fetch
+ * @returns the associated collection of {@link Amity.Post} objects
+ *
+ * @category Post API
+ * @async
+ */
+export const getPosts = async (
+  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: encodedPostIds } }
+  )
+
+  const cachedAt = client.cache && Date.now()
+  if (client.cache) ingestInCache(data, { cachedAt })
+
+  return {
+    data: data.posts,
+    cachedAt
+  }
+}
+
+/**
+ * ```js
+ * import { getPosts } from '@amityco/ts-sdk'
+ * const { data: posts } = getPosts.locally(['foo', 'bar'])
+ * ```
+ *
+ * Fetches a collection of {@link Amity.Post} objects from cache
+ *
+ * @param postIds the IDs of the {@link Amity.Post} to fetch
+ * @returns the associated collection of {@link Amity.Post} objects
+ *
+ * @category Post API
+ */
+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]
+
+  if (cached?.length < postIds.length)
+    return
+
+  return {
+    data: posts,
+    cachedAt: oldest.cachedAt,
+  }
+}

package/src/post/api/index.ts

@@ -0,0 +1,7 @@
+export * from './queryPosts'
+export * from './getPosts'
+export * from './getPost'
+
+export * from './createPost'
+export * from './updatePost'
+export * from './deletePost'

package/src/post/api/queryPosts.ts

@@ -0,0 +1,115 @@
+import { getActiveClient } from '~/client/api'
+
+import { toPageRaw, toToken } from '~/core/query'
+
+import { pullFromCache, pushToCache } from '~/cache/api'
+import { ingestInCache } from '~/cache/api/ingestInCache'
+import { getResolver } from '~/core/model'
+
+/**
+ * ```js
+ * import { queryPosts } from '@amityco/ts-sdk'
+ * const { data: posts, prevPage, nextPage } = await queryPosts({ targetId, targetType })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Post} objects
+ *
+ * @param query The query parameters
+ * @returns posts
+ *
+ * @category Post API
+ * @async
+ */
+export const queryPosts = async (
+  query: {
+    targetId: string,
+    targetType: Amity.Post['targetType'],
+    sortBy?: 'lastCreated' | 'firstCreated' | 'lastUpdated' | 'firstUpdated'
+    dataType?: string
+    isDeleted?: Amity.Post['isDeleted']
+    hasFlag?: boolean
+    feedType?: 'reviewing' | 'published'
+    tags?: Amity.Taggable['tags'],
+    matchingOnlyParentPost?: boolean
+    page?: Amity.Page
+  }
+): Promise<Amity.Cached<Amity.PagedRaw<Amity.Post>>> => {
+  const client = getActiveClient()
+  client.log('post/queryPosts', query)
+
+  const { page = { limit: 10 }, ...params } = query
+
+  // API-FIX: parameters should be querystring. (1)
+  // API-FIX: backend should answer Amity.Response (2)
+  // const { data } = await client.http.get<Amity.Response<Amity.PagedRawResponse<Amity.PostPayload>>>(
+  const { data } = await client.http.get<Amity.PostPayload & Amity.Pagination>(
+    `/api/v4/posts`, { params: {
+      ...params,
+      options: {
+        token: toToken(page, 'afterbeforeraw'),
+      },
+    }, }
+  )
+
+  // API-FIX: backend should answer Amity.Response (2)
+  // const { paging, posts } = unwrapPayload(data)
+  // unpacking
+  const { paging, ...payload } = data
+  const { posts } = payload
+
+  const cachedAt = client.cache && Date.now()
+
+  if (client.cache) {
+    ingestInCache(payload as Amity.PostPayload, { cachedAt })
+
+    const cacheKey = ['post', 'query', { ...params, options: { ...page } } as Amity.Serializable]
+    pushToCache(cacheKey, { posts: posts.map(getResolver('post')), paging })
+  }
+
+  const nextPage = toPageRaw(paging.next)
+  const prevPage = toPageRaw(paging.previous)
+
+  return { data: posts, cachedAt, prevPage, nextPage }
+}
+
+/**
+ * ```js
+ * import { queryPosts } from '@amityco/ts-sdk'
+ * const { data: posts, prevPage, nextPage } = queryPosts.locally({ targetId, targetType })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Post} objects from cache
+ *
+ * @param query The query parameters
+ * @returns posts
+ *
+ * @category Post API
+ */
+queryPosts.locally = (
+  query: Parameters<typeof queryPosts>[0],
+): Amity.Cached<Amity.PagedRaw<Amity.Post>> | undefined => {
+  const client = getActiveClient()
+  client.log('post/queryPosts.locally', query)
+
+  if (!client.cache) return
+
+  const { page = { limit: 10 }, ...params } = query
+
+  const queryKey = ['post', 'query', { ...params, options: { ...page }} as Amity.Serializable];
+  const { data, cachedAt } = pullFromCache<{posts: Pick<Amity.Post, 'postId'>[]} & Amity.Pagination>(queryKey) ?? {}
+
+  if (!data?.posts.length)
+    return
+
+  const posts: Amity.Post[] = data.posts
+    .map(postId => pullFromCache<Amity.Post>(['post', 'get', postId])!)
+    .filter(Boolean)
+    .map(({ data }) => data)
+
+  const prevPage = toPageRaw(data?.paging.previous)
+  const nextPage = toPageRaw(data?.paging.next)
+
+  return posts.length === data?.posts?.length
+    ? { data: posts, cachedAt, prevPage, nextPage }
+    : undefined
+}

package/src/post/api/updatePost.ts

@@ -0,0 +1,46 @@
+import { getActiveClient } from '~/client/api'
+
+import { ingestInCache } from '~/cache/api/ingestInCache'
+import { fireEvent } from '~/core/events'
+
+/**
+ * ```js
+ * import { updatePost } from '@amityco/ts-sdk'
+ * 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 (
+  postId: Amity.Post['postId'],
+  patch: Patch<Amity.Post, 'data' | 'metadata' | 'mentionees'>,
+): Promise<Amity.Cached<Amity.Post>> => {
+  const client = getActiveClient()
+  client.log('user/updatePost', patch)
+
+  const { data } = await client.http.put<Amity.PostPayload>(
+    `/api/v4/posts/${encodeURIComponent(postId)}`, patch,
+  )
+
+  const cachedAt = client.cache && Date.now()
+  if (client.cache) ingestInCache(data, { cachedAt })
+
+  fireEvent('post.updated', data)
+
+  const { posts } = data
+
+  return {
+    data: posts.find(post => post.postId === postId)!,
+    cachedAt,
+  }
+
+}

package/src/post/events/index.ts

@@ -0,0 +1,12 @@
+export * from './onPostCreated'
+export * from './onPostUpdated'
+export * from './onPostDeleted'
+
+export * from './onPostApproved'
+export * from './onPostDeclined'
+
+export * from './onPostFlagged'
+export * from './onPostUnflagged'
+
+export * from './onPostReactionAdded'
+export * from './onPostReactionRemoved'

package/src/post/events/onPostApproved.ts

@@ -0,0 +1,19 @@
+import { createPostEventSubscriber } from './utils'
+
+/**
+ * ```js
+ * import { onPostApproved } from '@amityco/ts-sdk'
+ * const dispose = onPostApproved(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Post} has been updated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+export const onPostApproved = (callback: Amity.Listener<Amity.Post>): Amity.Unsubscriber =>
+  createPostEventSubscriber('post.approved', callback)

package/src/post/events/onPostCreated.ts

@@ -0,0 +1,19 @@
+import { createPostEventSubscriber } from './utils'
+
+/**
+ * ```js
+ * import { onPostCreated } from '@amityco/ts-sdk'
+ * const dispose = onPostCreated(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Post} has been created
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+export const onPostCreated = (callback: Amity.Listener<Amity.Post>): Amity.Unsubscriber =>
+  createPostEventSubscriber('post.created', callback)

package/src/post/events/onPostDeclined.ts

@@ -0,0 +1,19 @@
+import { createPostEventSubscriber } from './utils'
+
+/**
+ * ```js
+ * import { onPostDeclined } from '@amityco/ts-sdk'
+ * const dispose = onPostDeclined(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Post} has been updated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+export const onPostDeclined = (callback: Amity.Listener<Amity.Post>): Amity.Unsubscriber =>
+  createPostEventSubscriber('post.declined', callback)

package/src/post/events/onPostDeleted.ts

@@ -0,0 +1,19 @@
+import { createPostEventSubscriber } from './utils'
+
+/**
+ * ```js
+ * import { onPostDeleted } from '@amityco/ts-sdk'
+ * const dispose = onPostDeleted(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Post} has been deleted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+export const onPostDeleted = (callback: Amity.Listener<Amity.Post>): Amity.Unsubscriber =>
+  createPostEventSubscriber('post.deleted', callback)

package/src/post/events/onPostFlagged.ts

@@ -0,0 +1,19 @@
+import { createPostEventSubscriber } from './utils'
+
+/**
+ * ```js
+ * import { onPostFlagged } from '@amityco/ts-sdk'
+ * const dispose = onPostFlagged(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Post} has been flagged
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+export const onPostFlagged = (callback: Amity.Listener<Amity.Post>): Amity.Unsubscriber =>
+  createPostEventSubscriber('post.flagged', callback)

package/src/post/events/onPostReactionAdded.ts

@@ -0,0 +1,46 @@
+import { getActiveClient } from '~/client/api'
+import { pullFromCache } from '~/cache/api'
+import { ingestInCache } from '~/cache/api/ingestInCache'
+import { createEventSubscriber } from '~/core/events'
+import { preparePayloadForCache } from '~/reaction/utils'
+
+/**
+ * ```js
+ * import { onPostReactionAdded } from '@amityco/ts-sdk'
+ * const dispose = onPostReactionAdded(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Post} has been reacted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+export const onPostReactionAdded = (callback: Amity.Listener<Amity.Post>): Amity.Unsubscriber => {
+  const client = getActiveClient()
+
+  const filter = (payload: Amity.Events['post.addReaction']) => {
+    if (!client.cache) {
+      callback(payload.posts[0])
+    } else {
+      preparePayloadForCache('post.addReaction', payload)
+      const { reactor, ...postPayload } = payload;
+
+      ingestInCache(postPayload as Amity.CommentPayload)
+
+      const post = pullFromCache<Amity.Post>(['post', 'get', payload.posts[0].postId])!
+
+      callback(post.data)
+    }
+  }
+
+  return createEventSubscriber(
+    client,
+    'post.addReaction',
+    'post.addReaction',
+    filter
+  )
+}

package/src/post/events/onPostReactionRemoved.ts

@@ -0,0 +1,46 @@
+import { getActiveClient } from '~/client/api'
+import { pullFromCache } from '~/cache/api'
+import { ingestInCache } from '~/cache/api/ingestInCache'
+import { createEventSubscriber } from '~/core/events'
+import { preparePayloadForCache } from '~/reaction/utils'
+
+/**
+ * ```js
+ * import { onPostReactionRemoved } from '@amityco/ts-sdk'
+ * const dispose = onPostReactionRemoved(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a reaction has been removed from a {@link Amity.Post}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+export const onPostReactionRemoved = (callback: Amity.Listener<Amity.Post>): Amity.Unsubscriber => {
+  const client = getActiveClient()
+
+  const filter = (payload: Amity.Events['post.removeReaction']) => {
+    if (!client.cache) {
+      callback(payload.posts[0])
+    } else {
+      preparePayloadForCache('post.removeReaction', payload)
+      const { reactor, ...postPayload } = payload;
+
+      ingestInCache(postPayload as Amity.CommentPayload)
+
+      const post = pullFromCache<Amity.Post>(['post', 'get', payload.posts[0].postId])!
+
+      callback(post.data)
+    }
+  }
+
+  return createEventSubscriber(
+    client,
+    'post.removeReaction',
+    'post.removeReaction',
+    filter
+  )
+}

package/src/post/events/onPostUnflagged.ts

@@ -0,0 +1,19 @@
+import { createPostEventSubscriber } from './utils'
+
+/**
+ * ```js
+ * import { onPostUnflagged } from '@amityco/ts-sdk'
+ * const dispose = onPostUnflagged(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a flag has been removed from a {@link Amity.Post}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+export const onPostUnflagged = (callback: Amity.Listener<Amity.Post>): Amity.Unsubscriber =>
+  createPostEventSubscriber('post.unflagged', callback)