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

package/src/category/api/queryCategories.ts

@@ -0,0 +1,48 @@
+import { getActiveClient } from '~/client/api/activeClient'
+
+import { toPage, toToken } from '~/core/query'
+// import { ingestInCache } from '~/cache/api/ingestInCache'
+
+/**
+ * ```js
+ * import { queryCategories } from '@amityco/ts-sdk'
+ * const categories = await queryCategories()
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Category} objects
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Category} objects
+ *
+ * @category Community API
+ * @async
+ **/
+export const queryCategories = async (query?: {
+  sortBy?: 'lastCreated' | 'firstCreated' | 'name'
+  isDeleted?: Amity.Category['isDeleted']
+  page?: Amity.Page
+}) => {
+  const client = getActiveClient()
+  client.log('category/queryCategories', query)
+
+  const { page, ...params } = query ?? {}
+
+  const { data } = await client.http.get<Amity.CategoryPayload & Amity.Pagination>(
+    `/api/v3/community-categories`, { params : {
+      ...params,
+      options: {
+        token: toToken(page, 'skiplimit')
+      }
+    } })
+
+  const { paging, ...response } = data
+
+  // decoratePayload(response as unknown as Record<string, any[]>)
+  // ingestInCache(response as unknown as Record<string, any[]>)
+
+  const prevPage = toPage(paging?.previous)
+  const nextPage = toPage(paging?.next)
+
+  const { categories } = response
+  return { data: categories, prevPage, nextPage }
+}

package/src/channel/api/addChannelMembers.ts

@@ -0,0 +1,44 @@
+import { getActiveClient } from '~/client/api'
+
+import { ingestInCache } from '~/cache/api/ingestInCache'
+import { fireEvent } from '~/core/events'
+
+/**
+ * ```js
+ * import { addChannelMembers } from '@amityco/ts-sdk'
+ * const updated = await addChannelMembers(channelId, ['foo', 'bar'])
+ * ```
+ *
+ * Adds a list of {@link Amity.User} to a {@link Amity.Channel}
+ *
+ * @param channelId The ID of the {@link Amity.Channel} to perform
+ * @param userIds The list of IDs {@link Amity.User} to add
+ * @returns A success boolean if the {@link Amity.User} were added to the {@link Amity.Channel}
+ *
+ * @category Channel API
+ * @async
+ */
+export const addChannelMembers = async (
+  channelId: Amity.Channel['channelId'],
+  userIds: Amity.User['userId'][]
+): Promise<boolean> => {
+  const client = getActiveClient()
+  client.log('channel/addChannelMembers', channelId, userIds)
+
+  const { data } = await client.http.post<Amity.ChannelMembershipPayload>(
+    `/api/v3/channels/${encodeURIComponent(channelId)}/users`,
+    { channelId, userIds }
+  )
+
+  if (client.cache) ingestInCache(data)
+
+  fireEvent('v3.channel.didAddUsers', {
+    channels: data.channels!,
+  })
+
+  const { channelUsers } = data
+  return !!channelUsers.find(
+    channelUser =>
+      channelUser.channelId === channelId && channelUser.membership === 'member'
+  )
+}

package/src/channel/api/addChannelMembersRole.ts

@@ -0,0 +1,41 @@
+import { getActiveClient } from '~/client/api'
+
+import { ingestInCache } from '~/cache/api/ingestInCache'
+
+/**
+ * ```js
+ * import { addChannelMembersRole } from '@amityco/ts-sdk'
+ * const updated = await addChannelMembersRole(channelId, 'foo', ['bar'])
+ * ```
+ *
+ * Adds an {@link Amity.Role} to a list of {@link Amity.User} on a {@link Amity.Channel}
+ *
+ * @param channelId The ID of the {@link Amity.Channel} to perform
+ * @param roleId The ID of the {@link Amity.Role} to apply
+ * @param userId Array of IDs of the {@link Amity.User} to perform
+ * @returns A success boolean if the {@link Amity.Role} were added to list of {@link Amity.User} in the {@link Amity.Channel}
+ *
+ * @category Channel API
+ * @async
+ */
+export const addChannelMembersRole = async (
+  channelId: Amity.Channel['channelId'],
+  roleId: Amity.Role['roleId'],
+  userIds: Amity.User['userId'][]
+): Promise<boolean> => {
+  const client = getActiveClient()
+  client.log('channel/addChannelMembersRole', channelId, roleId, userIds)
+
+  const { data } = await client.http.post<Amity.ChannelMembershipPayload>(
+    `/api/v3/channels/${encodeURIComponent(channelId)}/users/roles`,
+    { channelId, role: roleId, userIds }
+  )
+
+  if (client.cache) ingestInCache(data)
+
+  const { channelUsers } = data
+  return !!channelUsers.find(
+    channelUser =>
+      channelUser.channelId === channelId && channelUser.roles.includes(roleId)
+  )
+}

package/src/channel/api/createChannel.ts

@@ -0,0 +1,42 @@
+import { getActiveClient } from '~/client/api'
+
+import { ingestInCache } from '~/cache/api/ingestInCache'
+
+/**
+ * ```js
+ * import { createChannel } from '@amityco/ts-sdk'
+ * const created = await createChannel({ channelId: 'foobar', displayName: 'foobar' })
+ * ```
+ *
+ * Creates an {@link Amity.Channel}
+ *
+ * @param bundle The data necessary to create a new {@link Amity.Channel}
+ * @returns The newly created {@link Amity.Channel}
+ *
+ * @category Channel API
+ * @async
+ */
+export const createChannel = async <T extends Amity.ChannelType>(
+  bundle: { type: T, userIds?: Amity.User['userId'] }
+  & Pick<Amity.Channel<T>, 'displayName' | 'avatarFileId' | 'tags' | 'metadata'>
+): Promise<Amity.Cached<Amity.Channel>> => {
+  const client = getActiveClient()
+  client.log('user/createChannel', bundle)
+
+  let payload;
+
+  if (bundle?.type === 'conversation') {
+    payload = await client.http.post<Amity.ChannelPayload>('/api/v3/channels/conversation', {...bundle, isDistinct: true })
+  } else {
+    payload = await client.http.post<Amity.ChannelPayload>('/api/v3/channels', bundle)
+  }
+
+  const cachedAt = client.cache && Date.now()
+  if (client.cache) ingestInCache(payload.data, { cachedAt })
+
+  const { channels } = payload.data
+  return {
+    data: channels[0],
+    cachedAt,
+  }
+}

package/src/channel/api/deleteChannel.ts

@@ -0,0 +1,34 @@
+import { getActiveClient } from '~/client/api'
+
+import { getChannel } from './getChannel'
+
+/**
+ * ```js
+ * import { deleteChannel } from '@amityco/ts-sdk'
+ * const success = await deleteChannel('foobar')
+ * ```
+ *
+ * Deletes a {@link Amity.Channel}
+ *
+ * @param channelId The {@link Amity.Channel} ID to delete
+ * @return A success boolean if the {@link Amity.Channel} was deleted
+ *
+ * @category Channel API
+ * @async
+ */
+export const deleteChannel = async (
+  channelId: Amity.Channel['channelId'],
+): Promise<Amity.Channel> => {
+  const client = getActiveClient()
+  client.log('channel/deleteChannel', channelId)
+
+  // API-FIX: This endpoint has not been implemented yet.
+  await client.http.delete<{ success: boolean }>(
+    `/api/v3/channels/${encodeURIComponent(channelId)}`
+  )
+
+  const deleted = await getChannel(channelId)
+  // no need for event, fired by server
+
+  return deleted.data
+}

package/src/channel/api/getChannel.ts

@@ -0,0 +1,72 @@
+import { getActiveClient } from '~/client/api'
+
+import { pullFromCache } from '~/cache/api'
+import { ingestInCache } from '~/cache/api/ingestInCache'
+
+/**
+ * ```js
+ * import { getChannel } from '@amityco/ts-sdk'
+ * const channel = await getChannel('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Channel} object
+ *
+ * @param channelId the ID of the {@link Amity.Channel} to fetch
+ * @returns the associated {@link Amity.Channel} object
+ *
+ * @category Channel API
+ * @async
+ */
+export const getChannel = async (
+  channelId: Amity.Channel['channelId'],
+): Promise<Amity.Cached<Amity.Channel>> => {
+  const client = getActiveClient()
+  client.log('channel/getChannel', channelId)
+
+  // API-FIX: endpoint should not be /list, parameters should be querystring.
+  const { data } = await client.http.get<Amity.ChannelPayload>(
+    `/api/v3/channels/${encodeURIComponent(channelId)}`,
+  )
+
+  const cachedAt = client.cache && Date.now()
+  if (client.cache) ingestInCache(data, { cachedAt })
+
+  const { channels } = data
+
+  return {
+    data: channels.find(channel => channel.channelId === channelId)!,
+    cachedAt,
+  }
+}
+
+/**
+ * ```js
+ * import { getChannel } from '@amityco/ts-sdk'
+ * const channel = getChannel.locally('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Channel} object from cache
+ *
+ * @param channelId the ID of the {@link Amity.Channel} to fetch
+ * @returns the associated {@link Amity.Channel} object
+ *
+ * @category Channel API
+ */
+getChannel.locally = (
+  channelId: Amity.Channel['channelId'],
+): Amity.Cached<Amity.Channel> | undefined => {
+  const client = getActiveClient()
+  client.log('channel/getChannel.locally', channelId)
+
+  if (!client.cache) return
+
+  const cached = pullFromCache<Amity.Channel>(['channel', 'get', channelId])
+
+  if (!cached)
+    return
+
+  return {
+    data: cached.data,
+    cachedAt: cached.cachedAt,
+  }
+}

package/src/channel/api/getChannels.ts

@@ -0,0 +1,78 @@
+import { getActiveClient } from '~/client/api'
+
+import { pullFromCache } from '~/cache/api'
+import { ingestInCache } from '~/cache/api/ingestInCache'
+
+/**
+ * ```js
+ * import { getChannels } from '@amityco/ts-sdk'
+ * const channels = await getChannels(['foo', 'bar'])
+ * ```
+ *
+ * Fetches a collection of {@link Amity.Channel} objects
+ *
+ * @param channelIds the IDs of the {@link Amity.Channel} to fetch
+ * @returns the associated collection of {@link Amity.Channel} objects
+ *
+ * @category Channel API
+ * @async
+ */
+export const getChannels = async (
+  channelIds: Amity.Channel['channelId'][],
+): Promise<Amity.Cached<Amity.Channel[]>> => {
+  const client = getActiveClient()
+  client.log('channel/getChannels', channelIds)
+
+  const encodedChannelIds = channelIds.map(channelId => encodeURIComponent(channelId));
+
+  // API-FIX: endpoint should not be /list, parameters should be querystring.
+  const { data } = await client.http.get<Amity.ChannelPayload>(
+    `/api/v3/channels/list`,
+    { params: { channelIds: encodedChannelIds } },
+  )
+
+  const cachedAt = client.cache && Date.now()
+  if (client.cache) ingestInCache(data, { cachedAt })
+
+  return {
+    data: data.channels,
+    cachedAt
+  }
+}
+
+/**
+ * ```js
+ * import { getChannels } from '@amityco/ts-sdk'
+ * const channels = getChannels.locally(['foo', 'bar']) ?? []
+ * ```
+ *
+ * Fetches a collection of {@link Amity.Channel} objects from cache
+ *
+ * @param channelIds the IDs of the {@link Amity.Channel} to fetch
+ * @returns the associated collection of {@link Amity.Channel} objects
+ *
+ * @category Channel API
+ */
+getChannels.locally = (
+  channelIds: Amity.Channel['channelId'][],
+): Amity.Cached<Amity.Channel[]> | undefined => {
+  const client = getActiveClient()
+  client.log('channel/getChannels.locally', channelIds)
+
+  if (!client.cache) return
+
+  const cached = channelIds
+    .map(channelId => pullFromCache<Amity.Channel>(['channel', 'get', channelId])!)
+    .filter(Boolean)
+
+  const channels = cached.map(({ data }) => data)
+  const oldest = cached.sort((a, b) => a.cachedAt! < b.cachedAt! ? -1 : 1)?.[0]
+
+  if (cached?.length < channelIds.length)
+    return
+
+  return {
+    data: channels,
+    cachedAt: oldest.cachedAt,
+  }
+}

package/src/channel/api/index.ts

@@ -0,0 +1,18 @@
+export * from './queryChannels'
+export * from './getChannels'
+export * from './getChannel'
+
+export * from './createChannel'
+export * from './updateChannel'
+export * from './deleteChannel'
+
+export * from './joinChannel'
+export * from './leaveChannel'
+
+export * from './queryChannelMembers'
+
+export * from './addChannelMembers'
+export * from './removeChannelMembers'
+
+export * from './addChannelMembersRole'
+export * from './removeChannelMembersRole'

package/src/channel/api/joinChannel.ts

@@ -0,0 +1,37 @@
+import { getActiveClient } from '~/client/api'
+
+import { ingestInCache } from '~/cache/api/ingestInCache'
+
+/**
+ * ```js
+ * import { joinChannel } from '@amityco/ts-sdk'
+ * const isJoined = await joinChannel('foobar')
+ * ```
+ *
+ * Joins a {@link Amity.Channel} object
+ *
+ * @param channelId the {@link Amity.Channel} to join
+ * @returns A success boolean if the {@link Amity.Channel} was joined
+ *
+ * @category Channel API
+ * @async
+ */
+export const joinChannel = async (
+  channelId: Amity.Channel['channelId']
+): Promise<boolean> => {
+  const client = getActiveClient()
+  client.log('channel/joinChannel', channelId)
+
+  const { data } = await client.http.post<Amity.ChannelMembershipPayload>(
+    `/api/v3/channels/${encodeURIComponent(channelId)}/join`,
+  )
+
+  if (client.cache) ingestInCache(data)
+
+  const { channelUsers } = data
+
+  return !!channelUsers.find(channelUser => (
+    channelUser.channelId === channelId
+    && channelUser.membership === 'member'
+  ))
+}

package/src/channel/api/leaveChannel.ts

@@ -0,0 +1,37 @@
+import { getActiveClient } from '~/client/api'
+
+import { ingestInCache } from '~/cache/api/ingestInCache'
+
+/**
+ * ```js
+ * import { leaveChannel } from '@amityco/ts-sdk'
+ * const isLeft = await leaveChannel('foobar')
+ * ```
+ *
+ * Leave a {@link Amity.Channel} object
+ *
+ * @param channelId the {@link Amity.Channel} to leave
+ * @returns A success boolean if the {@link Amity.Channel} was left
+ *
+ * @category Channel API
+ * @async
+ */
+export const leaveChannel = async (
+  channelId: Amity.Channel['channelId']
+): Promise<boolean> => {
+  const client = getActiveClient()
+  client.log('channel/leaveChannel', channelId)
+
+  const { data } = await client.http.delete<Amity.ChannelMembershipPayload>(
+    `/api/v3/channels/${encodeURIComponent(channelId)}/leave`,
+  )
+
+  if (client.cache) ingestInCache(data)
+
+  const { channelUsers } = data
+
+  return !!channelUsers.find(channelUser => (
+    channelUser.channelId === channelId
+    && channelUser.membership !== 'member'
+  ))
+}

package/src/channel/api/queryChannelMembers.ts

@@ -0,0 +1,77 @@
+import { getActiveClient } from '~/client/api'
+
+import { toPage, toToken } from '~/core/query'
+import { ingestInCache } from '~/cache/api/ingestInCache'
+
+/**
+ * ```js
+ * import { queryChannelMembers } from '@amityco/ts-sdk'
+ * const channelMembers = await queryChannelMembers({ channelId: 'foo' })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.ChannelUser} objects
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.ChannelUser} objects
+ *
+ * @category Channel API
+ * @async
+ **/
+export const queryChannelMembers = async (query: {
+  channelId: string
+  membership?: 'all' | 'muted' | 'banned' | 'member&banned'
+  roles?: string[]
+  sortBy?: 'firstCreated' | 'lastCreated'
+  page?: Amity.Page
+}): Promise<Amity.Cached<Amity.Paged<Amity.Membership<"channel">>>> => {
+  const client = getActiveClient()
+  client.log('channel/queryChannelMembers', query)
+
+  const { page, channelId, membership, ...params } = query ?? {}
+
+  const { data } = await client.http.get<
+    Amity.ChannelMembershipPayload & Amity.Pagination
+  >(`/api/v3/channels/${encodeURIComponent(channelId)}/users`, {
+    params: {
+      ...params,
+      filter: membership,
+      options: {
+        token: toToken(page, 'skiplimit'),
+      },
+    },
+  })
+
+  const { paging, ...payload } = data
+  const { channelUsers } = payload
+
+  if (client.cache) {
+    ingestInCache(payload as Amity.ChannelMembershipPayload)
+  }
+
+  const nextPage = toPage(paging.next)
+  const prevPage = toPage(paging.previous)
+
+  return { data: channelUsers, nextPage, prevPage }
+}
+
+/**
+ * ```js
+ * import { queryChannelMembers } from '@amityco/ts-sdk'
+ * const channelMembers = await queryChannelMembers(query)
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Post} objects from cache
+ *
+ * @param query The query parameters
+ * @returns posts
+ *
+ * @category Post API
+ */
+queryChannelMembers.locally = (
+  query: Parameters<typeof queryChannelMembers>[0]
+) => {
+  const client = getActiveClient()
+  client.log('channel/queryChannelMembers', query)
+
+  // TODO
+}

package/src/channel/api/queryChannels.ts

@@ -0,0 +1,96 @@
+import { getActiveClient } from '~/client/api'
+
+import { toPage, toToken } from '~/core/query'
+import { pushToCache } from '~/cache/api'
+import { ingestInCache } from '~/cache/api/ingestInCache'
+import { getResolver } from '~/core/model'
+
+/**
+ * ```js
+ * import { queryChannels } from '@amityco/ts-sdk'
+ * const channels = await queryChannels()
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Channel} objects
+ * Search is performed by displayName such as `.startsWith(search)`
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Channel} objects
+ *
+ * @category Channel API
+ * @async
+ */
+export const queryChannels = async (
+  query?: {
+    displayName?: string
+    membership?: 'all' | 'member' | 'notMember'
+    sortBy?: ('displayName' | 'firstCreated' | 'lastCreated')
+    types?: Amity.ChannelType
+    page?: Amity.Page
+  }
+): Promise<Amity.Cached<Amity.Paged<Amity.Channel>>> => {
+  const client = getActiveClient()
+  client.log('channel/queryChannels', query)
+
+  // safe decapsulation
+  const {
+    page = { limit: 10 },
+    displayName,
+    membership,
+    ...params
+  } = query ?? {}
+
+  // API-FIX: parameters should be querystring.
+  // API-FIX: backend doesnt answer Amity.Response
+  // const { data } = await client.http.get<Amity.Response<Amity.Paged<ChannelPayload>>>(
+  const { data } = await client.http.get<Amity.ChannelPayload & Amity.Pagination>(
+    `/api/v3/channels`, { params: {
+      ...params,
+      keyword: displayName,
+      filter: membership,
+      options: {
+        token: toToken(page, 'skiplimit'),
+      },
+    } }
+  )
+
+  const { paging, ...payload } = data
+  const { channels } = payload
+
+  const cachedAt = client.cache && Date.now()
+
+  if (client.cache) {
+    ingestInCache(payload as Amity.ChannelPayload, { cachedAt })
+
+    const cacheKey = ['channel', 'query', { ...params, options: { ...page } } as Amity.Serializable]
+    pushToCache(cacheKey, { channels: channels.map(getResolver('channel')), paging })
+  }
+
+  const nextPage = toPage(paging.next)
+  const prevPage = toPage(paging.previous)
+
+  return { data: channels, cachedAt, prevPage, nextPage }
+}
+
+/**
+ * ```js
+ * import { queryChannels } from '@amityco/ts-sdk'
+ * const channels = queryChannels.locally()
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Channel} objects from cache
+ *
+ * @param query The query parameters
+ * @returns channels
+ *
+ * @category Channel API
+ */
+queryChannels.locally = (
+  query: Parameters<typeof queryChannels>[0],
+) => {
+  const client = getActiveClient()
+  client.log('channel/queryChannels.locally', query)
+
+  // TODO
+
+}

package/src/channel/api/removeChannelMembers.ts

@@ -0,0 +1,44 @@
+import { getActiveClient } from '~/client/api'
+
+import { ingestInCache } from '~/cache/api/ingestInCache'
+import { fireEvent } from '~/core/events'
+
+/**
+ * ```js
+ * import { removeChannelMembers } from '@amityco/ts-sdk'
+ * const updated = await removeChannelMembers(channelId, ['foo', 'bar'])
+ * ```
+ *
+ * Removes a list of {@link Amity.User} from a {@link Amity.Channel}
+ *
+ * @param channelId The ID of the {@link Amity.Channel} to perform
+ * @param userIds The list of IDs {@link Amity.User} to remove
+ * @returns A success boolean if the list of {@link Amity.User} were removed from the {@link Amity.Channel}
+ *
+ * @category Channel API
+ * @async
+ */
+export const removeChannelMembers = async (
+  channelId: Amity.Channel['channelId'],
+  userIds: Amity.User['userId'][]
+): Promise<boolean> => {
+  const client = getActiveClient()
+  client.log('channel/removeChannelMembers', channelId, userIds)
+
+  const { data } = await client.http.delete<Amity.ChannelMembershipPayload>(
+    `/api/v3/channels/${encodeURIComponent(channelId)}/users`,
+    { data: { channelId, userIds } }
+  )
+
+  if (client.cache) ingestInCache(data)
+
+  fireEvent('v3.channel.didRemoveUsers', {
+    channels: data.channels!,
+  })
+
+  const { channelUsers } = data
+  return !!channelUsers.find(
+    channelUser =>
+      channelUser.channelId === channelId && channelUser.membership !== 'member'
+  )
+}