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

package/src/message/api/getMessage.ts

@@ -0,0 +1,60 @@
+import { getActiveClient } from '~/client/api'
+import { ingestInCache, pullFromCache } from '~/core/cache'
+import { decoratePayload } from '~/core/query'
+
+import { getMessages } from './getMessages'
+
+/**
+ * ```js
+ * import { getMessage } from '@amityco/ts-sdk'
+ * const message = await getMessage('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Message} object
+ *
+ * @param messageId the ID of the {@link Amity.Message} to fetch
+ * @returns the associated {@link Amity.Message} object
+ *
+ * @category Message API
+ * @async
+ */
+export const getMessage = async (
+  messageId: Amity.Message['messageId'],
+) => {
+  const client = getActiveClient()
+  client.log('message/getMessage', messageId)
+
+  // API-FIX: endpoint should not be /list, parameters should be querystring.
+  const { data } = await client.http.get<Amity.MessagePayload>(
+    `/api/v3/messages/${messageId}`,
+  )
+
+  decoratePayload(data)
+  ingestInCache(data)
+
+  const { messages } = data
+  return messages.find(message => message.messageId === messageId)!
+}
+
+/**
+ * ```js
+ * import { getMessage } from '@amityco/ts-sdk'
+ * const message = getMessage.locally('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Message} object
+ *
+ * @param messageId the ID of the {@link Amity.Message} to fetch
+ * @returns the associated {@link Amity.Message} object
+ *
+ * @category Message API
+ */
+getMessage.locally = (
+  messageId: Amity.Message['messageId'],
+) => {
+  const client = getActiveClient()
+  client.log('message/getMessage.locally', messageId)
+
+  const [message] = pullFromCache('message', messageId) ?? []
+  return message
+}

package/src/message/api/getMessages.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 { getMessages } from '@amityco/ts-sdk'
+ * const messages = await getMessages(['foo', 'bar'])
+ * ```
+ *
+ * Fetches a collection of {@link Amity.Message} objects
+ *
+ * @param messageIds the IDs of the {@link Amity.Message} to fetch
+ * @returns the associated collection of {@link Amity.Message} objects
+ *
+ * @category Message API
+ * @async
+ */
+export const getMessages = async (
+  messageIds: Amity.Message['messageId'][],
+) => {
+  const client = getActiveClient()
+  client.log('message/getMessages', messageIds)
+
+  // API-FIX: endpoint should not be /list, parameters should be querystring.
+  const { data } = await client.http.get<Amity.MessagePayload>(
+    `/api/v3/messages/list`,
+    { params: { messageIds } },
+  )
+
+  decoratePayload(data)
+  ingestInCache(data)
+
+  const { messages } = data
+  return toRecord(messages)
+}
+
+/**
+ * ```js
+ * import { getMessages } from '@amityco/ts-sdk'
+ * const messages = getMessages.locally(['foo', 'bar']) ?? []
+ * ```
+ *
+ * Fetches a collection of {@link Amity.Message} objects from cache
+ *
+ * @param messageIds the IDs of the {@link Amity.Message} to fetch
+ * @returns the associated collection of {@link Amity.Message} objects
+ *
+ * @category Message API
+ */
+getMessages.locally = (
+  messageIds: Amity.Message['messageId'][],
+) => {
+  const client = getActiveClient()
+  client.log('message/getMessages.locally', messageIds)
+
+  const cached = pullFromCache('message', ...messageIds) ?? []
+
+  if (cached?.length === messageIds.length)
+    return toRecord(cached)
+}

package/src/message/api/index.ts

@@ -0,0 +1,6 @@
+export * from './getMessage'
+export * from './getMessages'
+export * from './queryMessages'
+export * from './createMessage'
+export * from './updateMessage'
+export * from './deleteMessage'

package/src/message/api/queryMessages.ts

@@ -0,0 +1,145 @@
+import { getActiveClient } from '~/client/api'
+
+import {
+  decoratePayload,
+  toPage,
+  toToken,
+  filterByPropEquality,
+  sortByChannelSegment,
+} from '~/core/query'
+
+import { ingestInCache, pullFromCache } from '~/core/cache'
+
+import { toRecord } from '~/core/model'
+
+/**
+ * ```js
+ * import { queryMessages } from '@amityco/ts-sdk'
+ * const messages = await queryMessages({ channelId })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Message} objects
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Message} objects
+ *
+ * @category Message API
+ * @async
+ */
+export const queryMessages = async (query: {
+  channelId: Amity.Channel['channelId']
+  type?: Amity.MessageContentType
+  parentId?: Amity.Message['parentId']
+  filterByParentId?: boolean
+  isDeleted?: boolean
+  tags?: Amity.Taggable['tags']
+  excludeTags?: Amity.Taggable['tags']
+  page?: Amity.Page
+}) => {
+  const client = getActiveClient()
+  client.log('message/queryMessages', query)
+
+  const { page, ...params } = query ?? {}
+
+  // API-FIX: parameters should be querystring. (1)
+  // API-FIX: backend should answer Amity.Response (2)
+  // API-FIX: pagination should not be indexed on channelSegment (3)
+  // const { data } = await client.http.get<Amity.Response<Amity.Paged<Amity.MessagePayload>>>(
+  const { data } = await client.http.get<Amity.MessagePayload & Amity.Pagination>(
+    `/api/v3/messages`, { params: {
+      ...params,
+      options: {
+        token: toToken(page, 'afterbefore'),
+      },
+    },}
+  )
+
+  // API-FIX: backend should answer Amity.Response (2)
+  // const { paging, messages } = unwrapPayload(data)
+  const { paging, ...response } = data
+
+  decoratePayload(response as unknown as Record<string, any[]>)
+  ingestInCache(response as unknown as Record<string, any[]>)
+
+  const { messages } = response
+
+  const nextPage = toPage(paging.next)
+  const prevPage = toPage(paging.previous)
+
+  return { data: toRecord(messages), nextPage, prevPage }
+}
+
+/**
+ * ```js
+ * import { queryMessages } from '@amityco/ts-sdk'
+ * const messages = queryMessages.locally!({ channelId })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Message} objects from cache
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Message} objects
+ *
+ * @category Message API
+ */
+queryMessages.locally = (query: Parameters<typeof queryMessages>[0]) => {
+  const client = getActiveClient()
+  client.log('message/queryMessages.locally', query)
+
+  const { channelId, page } = query
+
+  const [channel] = pullFromCache('channel', channelId) ?? []
+
+  let messages: Amity.Message<any>[] = pullFromCache('message') ?? []
+
+  // filter
+  messages = filterByPropEquality(messages, 'channelId', channelId)
+
+  // API-FIX filter by isDeleted doesn't work in backend... srsly wtf... how do they test things???
+  // messages = filterByPropEquality(messages, 'isDeleted', query?.isDeleted)
+
+  // sort
+  messages = messages.sort(sortByChannelSegment)
+
+  // paging
+  if (page) {
+    // slice
+    // API-FIX we can't reuse proper page because the message page is done
+    // by channelSegment which is sadly unique to the entire platform.
+    // this part is copied and adapted from sliceByPaging function
+
+    let start: number | undefined = 0
+    let end: number | undefined = undefined
+
+    // next page behavior
+    if ('after' in page) {
+      start = page.after !== 0
+        ? messages.findIndex(message => message.channelSegment === page?.after) + 1
+        : 0
+
+      end = start + page.limit
+
+    // prev page behavior
+    } else if ('before' in page) {
+      end = page.before !== 0
+        ? messages.findIndex(message => message.channelSegment === page?.before) + 1
+        : messages.length - 1
+
+      start = end > page.limit ? end - page.limit : 0
+    }
+
+    const paged = messages.slice(start, end)
+
+    messages = paged.length === page.limit ? paged : []
+  }
+
+  const prevPage = messages[0]?.channelSegment > 0
+    ? { before: messages[0].channelSegment, limit: page?.limit }
+    : undefined
+
+  const nextPage = messages[messages.length - 1]?.channelSegment < (channel?.messageCount ?? 0)
+    ? { after: messages[messages.length - 1].channelSegment, limit: page?.limit }
+    : undefined
+
+  return { data: toRecord(messages), nextPage, prevPage }
+}

package/src/message/api/updateMessage.ts

@@ -0,0 +1,79 @@
+import { getActiveClient } from '~/client/api'
+
+import { decoratePayload } from '~/core/query'
+import { ingestInCache, pullFromCache, pushToCache } from '~/core/cache'
+import { fireEvent } from '~/core/events'
+
+/**
+ * ```js
+ * import { updateMessage } from '@amityco/ts-sdk'
+ * const updated = await updateMessage(messageId, {
+ *   data: { text: 'hello world' }
+ * })
+ * ```
+ *
+ * Updates an {@link Amity.Message}
+ *
+ * @param messageId The ID of the {@link Amity.Message} to edit
+ * @param patch The patch data to apply
+ * @returns the updated {@link Amity.Message} object
+ *
+ * @category Message API
+ * @async
+ */
+export const updateMessage = async (
+  messageId: Amity.Message['messageId'],
+  patch: Patch<Amity.Message, 'data' | 'metadata'>,
+) => {
+  const client = getActiveClient()
+  client.log('user/updateMessage', patch)
+
+  const { data } = await client.http.put<Amity.MessagePayload>(
+    `/api/v3/messages/${messageId}`, patch,
+  )
+
+  decoratePayload(data)
+  ingestInCache(data)
+  // no need for event, fired by server
+
+  return data.messages.find(message => message.messageId === messageId)!
+}
+
+/**
+ * ```js
+ * import { updateMessage } from '@amityco/ts-sdk'
+ * const updated = updateMessage.locally('foobar', {
+ *   data: { text: 'hello world' }
+ * })
+ * ```
+ *
+ * Updates an {@link Amity.Message} in cache
+ *
+ * @param messageId The ID of the {@link Amity.Message} to edit
+ * @param patch The patch data to apply
+ * @returns the updated {@link Amity.Message} object
+ *
+ * @category Message API
+ */
+updateMessage.optimistically = (
+  messageId: Amity.Message['messageId'],
+  patch: Patch<Amity.Message, 'data' | 'metadata'>,
+) => {
+  const client = getActiveClient()
+  client.log('user/updateMessage', patch)
+
+  const [message] = pullFromCache('message', messageId) ?? []
+
+  if (!message) return
+
+  const updated: Amity.Message = {
+    ...message,
+    ...patch,
+    updatedAt: new Date().toISOString(),
+  }
+
+  pushToCache('message', updated)
+  fireEvent('v3.message.didUpdate', { messages: [updated] })
+
+  return updated
+}

package/src/message/events/index.ts

@@ -0,0 +1,3 @@
+export * from './onMessageCreated'
+export * from './onMessageUpdated'
+export * from './onMessageDeleted'

package/src/message/events/onMessageCreated.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 { onMessageCreated } from '@amityco/ts-sdk'
+ * const dispose = onMessageCreated(message => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.Message} has been created
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Message Events
+ */
+export const onMessageCreated = (
+  callback: Amity.Listener<Amity.Message>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient()
+
+  const filter = (payload: Amity.MessagePayload) => {
+    decoratePayload(payload)
+    ingestInCache(payload)
+    callback(payload.messages[0])
+  }
+
+  return createEventSubscriber(
+    client,
+    'message/onMessageCreated',
+    'v3.message.didCreate',
+    filter,
+  )
+}

package/src/message/events/onMessageDeleted.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 { onMessageDeleted } from '@amityco/ts-sdk'
+ * const dispose = onMessageDeleted(message => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.Message} was deleted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Message Events
+ */
+export const onMessageDeleted = (
+  callback: Amity.Listener<Amity.Message>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient()
+
+  const filter = (payload: Amity.MessagePayload) => {
+    decoratePayload(payload)
+    ingestInCache(payload)
+    callback(payload.messages[0])
+  }
+
+  return createEventSubscriber(
+    client,
+    'message/onMessageDeleted',
+    'v3.message.didDelete',
+    filter,
+  )
+}

package/src/message/events/onMessageUpdated.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 { onMessageUpdated } from '@amityco/ts-sdk'
+ * const dispose = onMessageUpdated(message => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.Message} has been updated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Message Events
+ */
+export const onMessageUpdated = (
+  callback: Amity.Listener<Amity.Message>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient()
+
+  const filter = (payload: Amity.MessagePayload) => {
+    decoratePayload(payload)
+    ingestInCache(payload)
+    callback(payload.messages[0])
+  }
+
+  return createEventSubscriber(
+    client,
+    'message/onMessageUpdated',
+    'v3.message.didUpdate',
+    filter,
+  )
+}

package/src/message/observers/index.ts

@@ -0,0 +1,2 @@
+export { observeMessage } from './observeMessage'
+export { observeMessages } from './observeMessages'

package/src/message/observers/observeMessage.ts

@@ -0,0 +1,76 @@
+import { getActiveClient } from '~/client/api'
+
+import { createQuery, runQuery, queryOptions } from '~/core/query'
+
+import { getMessage } from '../api'
+
+import {
+  onMessageUpdated,
+  onMessageDeleted,
+} from '../events'
+
+/**
+ * ```js
+ * import { observeMessage } from '@amityco/ts-sdk'
+ *
+ * let message = {}
+ * const unsub = observeMessage(messageId, updated => message = updated)
+ * ```
+ *
+ * Observe all mutations on a {@link Amity.Message} given a single messageId
+ *
+ * @param client the client to observe the message with
+ * @param messageId the ID of the message to observe
+ * @param callback the function to call when new data are available
+ * @param policy a query policy option for this observer
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the message
+ *
+ * @category Message Observer
+ */
+export const observeMessage = <Events extends ['onFetch', 'onUpdate', 'onDelete']>(
+  messageId: Amity.Message['messageId'],
+  callback: Amity.ObjectListener<Amity.QueryResult<Amity.Message>, Events>,
+  policy: Amity.QueryPolicy = 'cache_then_server',
+): Amity.Unsubscriber => {
+  const { log } = getActiveClient()
+
+  const timestamp = Date.now()
+  log(`observeMessage(tmpid: ${timestamp}) > listen`)
+
+  // wrapper function to make sure
+  const router = (
+    result: Amity.QueryResult<Amity.Message>,
+    action: Events[number]
+  ) => {
+    // filter function
+    if (result.data?.messageId !== messageId) return
+
+    if (callback instanceof Function)
+      return callback(result)
+
+    if (action !== 'onFetch')
+      callback.onEvent?.(action, result)
+
+    callback[action]?.(result)
+  }
+
+  const disposers: Amity.Unsubscriber[] = []
+
+  disposers.push(
+    onMessageUpdated(message => router(message, 'onUpdate')),
+    onMessageDeleted(message => router(message, 'onDelete')),
+  )
+
+  if (policy !== 'no_fetch') {
+    runQuery(
+      createQuery(getMessage, messageId),
+      (result) => result.data && router(result, 'onFetch'),
+      queryOptions(policy)
+    )
+  }
+
+  return () => {
+    log(`observeMessages(tmpid: ${timestamp}) > dispose`)
+    disposers.forEach(fn => fn())
+  }
+}

package/src/message/observers/observeMessages.ts

@@ -0,0 +1,60 @@
+import { getActiveClient } from '~/client/api'
+
+import {
+  onMessageCreated,
+  onMessageUpdated,
+  onMessageDeleted,
+} from '../events'
+
+/**
+ * ```js
+ * import { observeMessages } from '@amityco/ts-sdk'
+ *
+ * let messages = []
+ * const unsub = observeMessages(channelId, message => merge(messages, message))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Message} for a given {@link Amity.Channel} object
+ *
+ * @param client the client to observe the message with
+ * @param channelId 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 = (
+  channelId: Amity.Channel['channelId'],
+  callback: Amity.ObjectListener<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.Message,
+    action: 'onCreate' | 'onUpdate' | 'onDelete',
+  ) => {
+    if (message.channelId !== channelId) return
+
+    if (callback instanceof Function)
+      return callback(message)
+
+    callback.onEvent?.(action, message)
+    callback[action]?.(message)
+  }
+
+  disposers.push(
+    onMessageCreated(message => router(message, 'onCreate')),
+    onMessageUpdated(message => router(message, 'onUpdate')),
+    onMessageDeleted(message => router(message, 'onDelete')),
+  )
+
+  return () => {
+    log(`observeMessages(tmpid: ${timestamp}) > dispose`)
+    disposers.forEach(fn => fn())
+  }
+}

package/src/post/api/createPost.ts

@@ -0,0 +1,45 @@
+import { getActiveClient } from '~/client/api'
+
+import { decoratePayload } from '~/core/query'
+import { ingestInCache } from '~/core/cache'
+import { fireEvent } from '~/core/events'
+
+/**
+ * ```js
+ * import { createPost } from '@amityco/ts-sdk'
+ * const newPost = await createPost(bundle)
+ * ```
+ *
+ * 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'> & {
+    dataType?: T, data: { [k: string]: any }
+  },
+) => {
+  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
+
+  const { data } = await client.http.post<Amity.PostPayload>(
+    '/api/v3/posts', bundle
+  )
+
+  decoratePayload(data)
+  ingestInCache(data)
+
+  fireEvent('v3.community.didUpdate', { communities: data.communities! })
+  fireEvent('v3.post.didCreate', data)
+
+  const { posts } = data
+  return posts[0]
+}