@amityco/ts-sdk 0.0.1-02f0fa3.0

package/src/post/api/deletePost.ts

@@ -0,0 +1,43 @@
+import { getActiveClient } from '~/client/api'
+import { getCommunity } from '~/community/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'],
+) => {
+  const client = getActiveClient()
+  client.log('post/deletePost', postId)
+
+  // API-FIX: This endpoint has not been implemented yet.
+  await client.http.delete<{ success: boolean }>(
+    `/api/v3/posts/${postId}`,
+  )
+
+  // API-FIX: as for now we have no choice but to refetch
+  const deleted = await getPost(postId)
+
+  if (deleted.targetType === 'community') {
+    const community = await getCommunity(deleted.targetId);
+    fireEvent('v3.community.didUpdate', { communities: [community] })
+  }
+
+  fireEvent('v3.post.didDelete', { posts: [deleted] })
+
+  return deleted
+}

package/src/post/api/getPost.ts

@@ -0,0 +1,60 @@
+import { getActiveClient } from '~/client/api'
+import { ingestInCache, pullFromCache } from '~/core/cache'
+import { decoratePayload } from '~/core/query'
+
+import { getPosts } from './getPosts'
+
+/**
+ * ```js
+ * import { getPost } from '@amityco/ts-sdk'
+ * const 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']
+) => {
+  const client = getActiveClient()
+  client.log('post/getPost', postId)
+
+  // API-FIX: endpoint should not be /list, parameters should be querystring.
+  const { data } = await client.http.get<Amity.PostPayload>(
+    `/api/v3/posts/${postId}`,
+  )
+
+  decoratePayload(data)
+  ingestInCache(data)
+
+  const { posts } = data
+  return posts.find(post => post.postId === postId)!
+}
+
+/**
+ * ```js
+ * import { getPost } from '@amityco/ts-sdk'
+ * const post = getPost.locally('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
+ */
+getPost.locally = (
+  postId: Amity.Post['postId']
+) => {
+  const client = getActiveClient()
+  client.log('post/getPost.locally', postId)
+
+  const [post] = pullFromCache('post', postId) ?? []
+  return post
+}

package/src/post/api/getPosts.ts

@@ -0,0 +1,63 @@
+import { getActiveClient } from '~/client/api'
+
+import { decoratePayload } from '~/core/query'
+import { ingestInCache, pullFromCache } from '~/core/cache'
+import { toRecord } from '~/core/model'
+
+/**
+ * ```js
+ * import { getPosts } from '@amityco/ts-sdk'
+ * const 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'][]
+) => {
+  const client = getActiveClient()
+  client.log('post/getPosts', postIds)
+
+  // 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 } }
+  )
+
+  decoratePayload(data)
+  ingestInCache(data)
+
+  const { posts } = data
+  return posts
+}
+
+/**
+ * ```js
+ * import { getPosts } from '@amityco/ts-sdk'
+ * const 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'][]
+) => {
+  const client = getActiveClient()
+  client.log('post/getPosts.locally', postIds)
+
+  const cached = pullFromCache('post', ...postIds) ?? []
+
+  if (cached?.length === postIds.length)
+    return toRecord(cached)
+}

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,86 @@
+import { getActiveClient } from '~/client/api'
+
+import { decoratePayload, toPage, toToken } from '~/core/query'
+import { ingestInCache } from '~/core/cache'
+
+import { toRecord } from '~/core/model'
+
+/**
+ * ```js
+ * import { queryPosts } from '@amityco/ts-sdk'
+ * const posts = 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'
+    page?: Amity.Page
+  }
+) => {
+  const client = getActiveClient()
+  client.log('post/queryPosts', query)
+
+  const { page, ...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.PagedResponse<Amity.PostPayload>>>(
+  const { data } = await client.http.get<Amity.PostPayload & Amity.Pagination>(
+    `/api/v3/posts`, { params: {
+      ...params,
+      options: {
+        token: toToken(page, 'skiplimit'),
+      },
+    }, }
+  )
+
+  // API-FIX: backend should answer Amity.Response (2)
+  // const { paging, posts } = unwrapPayload(data)
+  const { paging, ...response } = data
+
+  decoratePayload(response as unknown as Record<string, Object[]>)
+  ingestInCache(response as unknown as Record<string, Object[]>)
+
+  const { posts } = response
+
+  const nextPage = toPage(paging.next)
+  const prevPage = toPage(paging.previous)
+
+  return { data: toRecord(posts), nextPage, prevPage }
+}
+
+/**
+ * ```js
+ * import { queryPosts } from '@amityco/ts-sdk'
+ * const posts = 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],
+) => {
+  const client = getActiveClient()
+  client.log('post/queryPosts.locally', query)
+
+  // TODO
+}

package/src/post/api/updatePost.ts

@@ -0,0 +1,42 @@
+import { getActiveClient } from '~/client/api'
+
+import { decoratePayload } from '~/core/query'
+import { ingestInCache } from '~/core/cache'
+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'>,
+) => {
+  const client = getActiveClient()
+  client.log('user/updatePost', patch)
+
+  const { data } = await client.http.put<Amity.PostPayload>(
+    `/api/v3/posts/${postId}`, patch,
+  )
+
+  decoratePayload(data)
+  ingestInCache(data)
+
+  fireEvent('v3.post.didUpdate', data)
+
+  const { posts } = data
+  return posts.find(post => post.postId === postId)!
+}

package/src/post/events/index.ts

@@ -0,0 +1,3 @@
+export * from './onPostCreated'
+export * from './onPostUpdated'
+export * from './onPostDeleted'

package/src/post/events/onPostCreated.ts

@@ -0,0 +1,39 @@
+import { getActiveClient } from '~/client/api'
+import { createEventSubscriber } from '~/core/events'
+
+import { decoratePayload } from '~/core/query'
+import { ingestInCache } from '~/core/cache'
+
+/**
+ * ```js
+ * import { onPostCreated } from '@amityco/ts-sdk'
+ * const dispose = onPostCreated(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@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 => {
+  const client = getActiveClient()
+
+  const filter = (payload: Amity.PostPayload) => {
+    decoratePayload(payload)
+    ingestInCache(payload)
+    callback(payload.posts[0])
+  }
+
+  return createEventSubscriber(
+    client,
+    'message/onPostCreated',
+    'v3.post.didCreate',
+    filter
+  )
+}

package/src/post/events/onPostDeleted.ts

@@ -0,0 +1,39 @@
+import { getActiveClient } from '~/client/api'
+import { createEventSubscriber } from '~/core/events'
+
+import { decoratePayload } from '~/core/query'
+import { ingestInCache } from '~/core/cache'
+
+/**
+ * ```js
+ * import { onPostDeleted } from '@amityco/ts-sdk'
+ * const dispose = onPostDeleted(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@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 => {
+  const client = getActiveClient()
+
+  const filter = (payload: Amity.PostPayload) => {
+    decoratePayload(payload)
+    ingestInCache(payload)
+    callback(payload.posts[0])
+  }
+
+  return createEventSubscriber(
+    client,
+    'message/onPostDeleted',
+    'v3.post.didDelete',
+    filter
+  )
+}

package/src/post/events/onPostUpdated.ts

@@ -0,0 +1,39 @@
+import { getActiveClient } from '~/client/api'
+import { createEventSubscriber } from '~/core/events'
+
+import { decoratePayload } from '~/core/query'
+import { ingestInCache } from '~/core/cache'
+
+/**
+ * ```js
+ * import { onPostUpdated } from '@amityco/ts-sdk'
+ * const dispose = onPostUpdated(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@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 onPostUpdated = (
+  callback: Amity.Listener<Amity.Post>
+): Amity.Unsubscriber => {
+  const client = getActiveClient()
+
+  const filter = (payload: Amity.PostPayload) => {
+    decoratePayload(payload)
+    ingestInCache(payload)
+    callback(payload.posts[0])
+  }
+
+  return createEventSubscriber(
+    client,
+    'message/onPostUpdated',
+    'v3.post.didUpdate',
+    filter
+  )
+}

package/src/post/observers/index.ts

@@ -0,0 +1,2 @@
+export * from './observePosts'
+export * from './observePost'

package/src/post/observers/observePost.ts

@@ -0,0 +1,72 @@
+import { getActiveClient } from '~/client/api'
+
+import { createQuery, runQuery, queryOptions } from '~/core/query'
+
+import { getPost } from '../api'
+
+import {
+  onPostUpdated,
+  onPostDeleted,
+} from '../events'
+
+/**
+ * ```js
+ * import { observePost } from '@amityco/ts-sdk'
+ *
+ * let post = {}
+ * const dispose = observePost(postId, updated => post = updated)
+ * ```
+ *
+ * Observe all mutation 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']>(
+  postId: string,
+  callback: Amity.ObjectListener<Amity.QueryResult<Amity.Post>, 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.QueryResult<Amity.Post>,
+    action: Events[number]
+  ) => {
+    // filter function
+    if (result.data?.postId !== postId) return
+
+    if (callback instanceof Function)
+      return callback(result)
+
+    if (action !== 'onFetch')
+      callback.onEvent?.(action, result)
+
+    callback[action]?.(result)
+  }
+
+  const disposers: Amity.Unsubscriber[] = []
+
+  disposers.push(
+    onPostUpdated(data => router({ data }, 'onUpdate')),
+    onPostDeleted(data => router({ data }, 'onDelete')),
+  )
+
+  runQuery(
+    createQuery(getPost, postId),
+    (result) => result.data && router(result, 'onFetch'),
+    queryOptions(policy),
+  )
+
+  return () => {
+    log(`observePosts(tmpid: ${timestamp}) > dispose`)
+    disposers.forEach(fn => fn())
+  }
+}

package/src/post/observers/observePosts.ts

@@ -0,0 +1,66 @@
+import { getActiveClient } from '~/client/api'
+
+import {
+  onPostCreated,
+  onPostUpdated,
+  onPostDeleted,
+} from '../events'
+
+/**
+ * ```js
+ * import { observePosts } from '@amityco/ts-sdk'
+ *
+ * let posts = []
+ * const unsub = observePosts({
+ *   targetType: Amity.PostTargetType,
+ *   targetId: Amity.Post['targetId'],
+ * }, post => merge(posts, post))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Post} for a given target object
+ *
+ * @param targetType the type of the target
+ * @param targetId the ID of the target
+ * @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']>
+): Amity.Unsubscriber => {
+  const { log } = getActiveClient()
+
+  const timestamp = Date.now()
+  log(`observePosts(tmpid: ${timestamp}) > listen`)
+
+  const disposers: Amity.Unsubscriber[] = []
+
+  const router = (
+    post: Amity.Post,
+    action: 'onCreate' | 'onUpdate' | 'onDelete'
+  ) => {
+    if (params.targetId !== post.targetId
+      || params.targetType !== post.targetType)
+      return
+
+    if (callback instanceof Function) return callback(post)
+
+    callback.onEvent?.(action, post)
+    callback[action]?.(post)
+  }
+
+  disposers.push(
+    onPostCreated(post => router(post, 'onCreate')),
+    onPostUpdated(post => router(post, 'onUpdate')),
+    onPostDeleted(post => router(post, 'onDelete')),
+  )
+
+  return () => {
+    log(`observePosts(tmpid: ${timestamp}) > dispose`)
+    disposers.forEach(fn => fn())
+  }
+}

package/src/reaction/api/addReaction.ts

@@ -0,0 +1,84 @@
+import { getActiveClient } from '~/client/api'
+
+import { mutateCache } from '~/core/cache'
+
+import { dispatchReactable, fetchReference } from '../utils'
+
+/**
+ * ```js
+ * import { addReaction } from '@amityco/ts-sdk'
+ * const success = await addReaction('post', postId, 'like')
+ * ```
+ *
+ * Creates an {@link Amity.Reaction}
+ *
+ * @param referenceType The type of thing to add a {@link Amity.Reaction} to, such as a post or a comment.
+ * @param referenceId The ID of the thing to add a new {@link Amity.Reaction} to.
+ * @param reactionName Reaction name, such as a `like` or `love`.
+ * @returns The added result.
+ *
+ * @category Reaction API
+ * @async
+ **/
+export const addReaction = async (
+  referenceType: Amity.Reaction['referenceType'],
+  referenceId: Amity.Reaction['referenceId'],
+  reactionName: Amity.Reaction['reactionName']
+) => {
+  const client = getActiveClient()
+  client.log('reaction/createReaction', {
+    referenceId,
+    referenceType,
+    reactionName,
+  })
+
+  await client.http.post<{ addedId: 'string' }>(
+    '/api/v2/reactions',
+    { referenceId, referenceType, reactionName }
+  )
+
+  const model = await fetchReference(referenceType, referenceId)
+  dispatchReactable(referenceType, model)
+
+  return model.myReactions?.includes(reactionName) ?? false
+}
+
+/**
+ * ```js
+ * import { addReaction } from '@amityco/ts-sdk'
+ * const success = addReaction.optimistically('post', postId, 'like')
+ * ```
+ *
+ * Creates an {@link Amity.Reaction} optimistically
+ *
+ * @param referenceType The type of thing to add a {@link Amity.Reaction} to, such as a post or a comment.
+ * @param referenceId The ID of the thing to add a new {@link Amity.Reaction} to.
+ * @param reactionName Reaction name, such as a `like` or `love`.
+ * @returns The added result.
+ *
+ * @category Reaction API
+ **/
+addReaction.optimistically = (
+  referenceType: Amity.ReactableType,
+  referenceId: Amity.Reaction['referenceId'],
+  reactionName: Amity.Reaction['reactionName']
+) => {
+  const model = mutateCache(referenceType, referenceId, model => {
+    if (model.myReactions?.includes(reactionName)) return
+
+    return {
+      ...model,
+      syncedAt: -1,
+      reactionsCount: model.reactionsCount + 1,
+      myReactions: [...(model.myReactions ?? []), reactionName],
+      reactions: {
+        ...model.reactions,
+        [reactionName]: (model.reactions[reactionName] ?? 0) + 1,
+      },
+    }
+  })
+
+  model && dispatchReactable(referenceType, model)
+
+  return model?.myReactions?.includes(reactionName) ?? false
+}

package/src/reaction/api/index.ts

@@ -0,0 +1,2 @@
+export * from './addReaction'
+export * from './removeReaction'