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

package/src/channel/api/queryChannels.ts

@@ -0,0 +1,89 @@
+import { getActiveClient } from '~/client/api'
+
+import { decoratePayload, toPage, toToken } from '~/core/query'
+import { ingestInCache } from '~/core/cache'
+import { toRecord } 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
+  }
+) => {
+  const client = getActiveClient()
+  client.log('channel/queryChannels', query)
+
+  // safe decapsulation
+  const {
+    page,
+    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, ...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 { channels } = response
+  return { data: toRecord(channels), 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,45 @@
+import { getActiveClient } from '~/client/api'
+
+import { decoratePayload } from '~/core/query'
+import { ingestInCache } from '~/core/cache'
+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'][]
+) => {
+  const client = getActiveClient()
+  client.log('channel/removeChannelMembers', channelId, userIds)
+
+  const { data } = await client.http.delete<Amity.ChannelMembershipPayload>(
+    `/api/v3/channels/${channelId}/users`,
+    { data: { channelId, userIds } }
+  )
+
+  decoratePayload(data)
+  ingestInCache(data)
+  fireEvent('v3.channel.didRemoveUsers', {
+    channels: data.channels!,
+  })
+
+  const { channelUsers } = data
+  return !!channelUsers.find(
+    channelUser =>
+      channelUser.channelId === channelId && channelUser.membership !== 'member'
+  )
+}

package/src/channel/api/removeChannelMembersRole.ts

@@ -0,0 +1,43 @@
+import { getActiveClient } from '~/client/api'
+
+import { decoratePayload } from '~/core/query'
+import { ingestInCache } from '~/core/cache'
+
+/**
+ * ```js
+ * import { removeChannelMembersRole } from '@amityco/ts-sdk'
+ * const updated = await removeChannelMembersRole(channelId, 'foo', ['bar'])
+ * ```
+ *
+ * Removes an {@link Amity.Role} from 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 removed from list of {@link Amity.User} in the {@link Amity.Channel}
+ *
+ * @category Channel API
+ * @async
+ */
+export const removeChannelMembersRole = async (
+  channelId: Amity.Channel['channelId'],
+  roleId: Amity.Role['roleId'],
+  userIds: Amity.User['userId'][]
+) => {
+  const client = getActiveClient()
+  client.log('channel/removeChannelMembersRole', channelId, roleId, userIds)
+
+  const { data } = await client.http.delete<Amity.ChannelMembershipPayload>(
+    `/api/v3/channels/${channelId}/users/roles`,
+    { data: { channelId, role: roleId, userIds } }
+  )
+
+  decoratePayload(data)
+  ingestInCache(data)
+
+  const { channelUsers } = data
+  return !!channelUsers.find(
+    channelUser =>
+      channelUser.channelId === channelId && !channelUser.roles.includes(roleId)
+  )
+}

package/src/channel/api/updateChannel.ts

@@ -0,0 +1,38 @@
+import { getActiveClient } from '~/client/api'
+
+import { decoratePayload } from '~/core/query'
+import { ingestInCache } from '~/core/cache'
+
+/**
+ * ```js
+ * import { updateChannel } from '@amityco/ts-sdk'
+ * const updated = await updateChannel(channelId, { displayName: 'foobar' })
+ * ```
+ *
+ * Updates an {@link Amity.Channel}
+ *
+ * @param channelId The ID of the {@link Amity.Channel} to edit
+ * @param patch The patch data to apply
+ * @returns the updated {@link Amity.Channel} object
+ *
+ * @category Channel API
+ * @async
+ */
+export const updateChannel = async (
+  channelId: Amity.Channel['channelId'],
+  patch: Patch<Amity.Channel, 'displayName' | 'description' | 'avatarFileId' | 'metadata'>,
+) => {
+  const client = getActiveClient()
+  client.log('channel/updateChannel', channelId, patch)
+
+  const { data } = await client.http.put<Amity.ChannelPayload>(
+    `/api/v3/channels/${channelId}`, patch,
+  )
+
+  decoratePayload(data)
+  ingestInCache(data)
+  // no need for event, fired by server
+
+  const { channels } = data
+  return channels.find(channel => channel.channelId === channelId)!
+}

package/src/channel/events/index.ts

@@ -0,0 +1,6 @@
+export * from './onChannelUpdated'
+export * from './onChannelDeleted'
+export * from './onChannelJoined'
+export * from './onChannelLeft'
+export * from './onMemberAdded'
+export * from './onMemberRemoved'

package/src/channel/events/onChannelCreated.ts

@@ -0,0 +1,37 @@
+import { getActiveClient } from '~/client/api'
+import { createEventSubscriber } from '~/core/events'
+
+import { decoratePayload } from '~/core/query'
+import { ingestInCache } from '~/core/cache'
+
+/**
+ * ```js
+ * import { onChannelCreated } from '@amityco/ts-sdk'
+ * const dispose = onChannelCreated(channel => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.Channel} have been created
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+export const onChannelCreated = (callback: Amity.Listener<Amity.Channel>) => {
+  const client = getActiveClient()
+
+  const filter = (payload: Amity.ChannelPayload) => {
+    decoratePayload(payload)
+    ingestInCache(payload)
+    callback(payload.channels[0])
+  }
+
+  return createEventSubscriber(
+    client,
+    'onChannelCreated',
+    'v3.channel.didCreate',
+    filter
+  )
+}

package/src/channel/events/onChannelDeleted.ts

@@ -0,0 +1,37 @@
+import { getActiveClient } from '~/client/api'
+import { createEventSubscriber } from '~/core/events'
+
+import { decoratePayload } from '~/core/query'
+import { ingestInCache } from '~/core/cache'
+
+/**
+ * ```js
+ * import { onChannelDeleted } from '@amityco/ts-sdk'
+ * const dispose = onChannelDeleted(channel => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.Channel} have been deleted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+export const onChannelDeleted = (callback: Amity.Listener<Amity.Channel>) => {
+  const client = getActiveClient()
+
+  const filter = (payload: Amity.ChannelPayload) => {
+    decoratePayload(payload)
+    ingestInCache(payload)
+    callback(payload.channels[0])
+  }
+
+  return createEventSubscriber(
+    client,
+    'onChannelDeleted',
+    'v3.channel.didDelete',
+    filter
+  )
+}

package/src/channel/events/onChannelJoined.ts

@@ -0,0 +1,37 @@
+import { getActiveClient } from '~/client/api'
+import { createEventSubscriber } from '~/core/events'
+
+import { decoratePayload } from '~/core/query'
+import { ingestInCache } from '~/core/cache'
+
+/**
+ * ```js
+ * import { onChannelJoined } from '@amityco/ts-sdk'
+ * const dispose = onChannelJoined(channel => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.Channel} was joined
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+export const onChannelJoined = (callback: Amity.Listener<Amity.Channel>) => {
+  const client = getActiveClient()
+
+  const filter = (payload: Amity.ChannelPayload) => {
+    decoratePayload(payload)
+    ingestInCache(payload)
+    callback(payload.channels[0])
+  }
+
+  return createEventSubscriber(
+    client,
+    'onChannelJoined',
+    'v3.channel.didJoin',
+    filter
+  )
+}

package/src/channel/events/onChannelLeft.ts

@@ -0,0 +1,37 @@
+import { getActiveClient } from '~/client/api'
+import { createEventSubscriber } from '~/core/events'
+
+import { decoratePayload } from '~/core/query'
+import { ingestInCache } from '~/core/cache'
+
+/**
+ * ```js
+ * import { onChannelLeft } from '@amityco/ts-sdk'
+ * const dispose = onChannelLeft(channel => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.Channel} was left
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+export const onChannelLeft = (callback: Amity.Listener<Amity.Channel>) => {
+  const client = getActiveClient()
+
+  const filter = (payload: Amity.ChannelPayload) => {
+    decoratePayload(payload)
+    ingestInCache(payload)
+    callback(payload.channels[0])
+  }
+
+  return createEventSubscriber(
+    client,
+    'onChannelLeft',
+    'v3.channel.didLeave',
+    filter
+  )
+}

package/src/channel/events/onChannelUpdated.ts

@@ -0,0 +1,37 @@
+import { getActiveClient } from '~/client/api'
+import { createEventSubscriber } from '~/core/events'
+
+import { decoratePayload } from '~/core/query'
+import { ingestInCache } from '~/core/cache'
+
+/**
+ * ```js
+ * import { onChannelUpdated } from '@amityco/ts-sdk'
+ * const dispose = onChannelUpdated(channel => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.Channel} have been updated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+export const onChannelUpdated = (callback: Amity.Listener<Amity.Channel>) => {
+  const client = getActiveClient()
+
+  const filter = (payload: Amity.ChannelPayload) => {
+    decoratePayload(payload)
+    ingestInCache(payload)
+    callback(payload.channels[0])
+  }
+
+  return createEventSubscriber(
+    client,
+    'onChannelUpdated',
+    'v3.channel.didUpdate',
+    filter
+  )
+}

package/src/channel/events/onMemberAdded.ts

@@ -0,0 +1,37 @@
+import { getActiveClient } from '~/client/api'
+import { createEventSubscriber } from '~/core/events'
+
+import { decoratePayload } from '~/core/query'
+import { ingestInCache } from '~/core/cache'
+
+/**
+ * ```js
+ * import { onMemberAdded } from '@amityco/ts-sdk'
+ * const dispose = onMemberAdded(channel => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.User} has been added to any {@link Amity.Channel}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+export const onMemberAdded = (callback: Amity.Listener<Amity.Channel>) => {
+  const client = getActiveClient()
+
+  const filter = (payload: Amity.ChannelPayload) => {
+    decoratePayload(payload)
+    ingestInCache(payload)
+    callback(payload.channels[0])
+  }
+
+  return createEventSubscriber(
+    client,
+    'onMemberAdded',
+    'v3.channel.didAddUsers',
+    filter
+  )
+}

package/src/channel/events/onMemberRemoved.ts

@@ -0,0 +1,37 @@
+import { getActiveClient } from '~/client/api'
+import { createEventSubscriber } from '~/core/events'
+
+import { decoratePayload } from '~/core/query'
+import { ingestInCache } from '~/core/cache'
+
+/**
+ * ```js
+ * import { onMemberRemoved } from '@amityco/ts-sdk'
+ * const dispose = onMemberRemoved(channel => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.User} has been removed from any {@link Amity.Channel}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+export const onMemberRemoved = (callback: Amity.Listener<Amity.Channel>) => {
+  const client = getActiveClient()
+
+  const filter = (payload: Amity.ChannelPayload) => {
+    decoratePayload(payload)
+    ingestInCache(payload)
+    callback(payload.channels[0])
+  }
+
+  return createEventSubscriber(
+    client,
+    'onMemberRemoved',
+    'v3.channel.didRemoveUsers',
+    filter
+  )
+}

package/src/channel/observers/index.ts

@@ -0,0 +1 @@
+export * from './observeChannel'

package/src/channel/observers/observeChannel.ts

@@ -0,0 +1,80 @@
+import { createQuery, runQuery } from '~/core/query/query'
+
+import { getActiveClient } from '~/client/api'
+
+import { getChannel } from '../api'
+
+import {
+  onChannelUpdated,
+  onChannelDeleted,
+  onChannelJoined,
+  onChannelLeft,
+  onMemberAdded,
+  onMemberRemoved,
+} from '../events'
+
+/**
+ * ```js
+ * import { observeChannel } from '@amityco/ts-sdk'
+ *
+ * let channel = {}
+ * const dispose = observeChannel(channelId, ({ data }) => channel = data)
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.Channel}
+ *
+ * @param channelId the ID of the channel 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 channel
+ *
+ * @category Channel Observer
+ */
+export const observeChannel = <
+  Events extends ['onFetch', 'onUpdate', 'onDelete', 'onJoin', 'onLeft', 'onMemberAdded', 'onMemberRemoved']
+>(
+  channelId: string,
+  callback: Amity.ObjectListener<Amity.QueryResult<Amity.Channel>, Events>
+): Amity.Unsubscriber => {
+  const { log } = getActiveClient()
+
+  const timestamp = Date.now()
+  log(`observeChannel(tmpid: ${timestamp}) > listen`)
+
+  // wrapper function to make sure
+  const router = (
+    result: Amity.QueryResult<Amity.Channel>,
+    action: Events[number]
+  ) => {
+    // filter function
+    if (result.data?.channelId !== channelId) return
+
+    if (callback instanceof Function)
+      return callback(result)
+
+    if (action !== 'onFetch')
+      callback.onEvent?.(action, result)
+
+    callback[action]?.(result)
+  }
+
+  const disposers: Amity.Unsubscriber[] = []
+
+  disposers.push(
+    onChannelUpdated(data => router({ data }, 'onUpdate')),
+    onChannelDeleted(data => router({ data }, 'onDelete')),
+    onChannelJoined(data => router({ data }, 'onJoin')),
+    onChannelLeft(data => router({ data }, 'onLeft')),
+    onMemberAdded(data => router({ data }, 'onMemberAdded')),
+    onMemberRemoved(data => router({ data }, 'onMemberRemoved')),
+  )
+
+  runQuery(
+    createQuery(getChannel, channelId),
+    result => result.data && router(result, 'onFetch'),
+  )
+
+  return () => {
+    log(`observeChannel(tmpid: ${timestamp}) > dispose`)
+    disposers.forEach(fn => fn())
+  }
+}

package/src/client/api/activeClient.ts

@@ -0,0 +1,33 @@
+import { ASCError } from '~/core/errors'
+
+let activeClient: Amity.Client | null = null
+
+/**
+ * Get the active client
+ *
+ * @returns the active client instance
+ *
+ * @hidden
+ */
+export const getActiveClient = () => {
+  if (!activeClient) {
+    throw new ASCError(
+      'There is no active client',
+      Amity.ClientError.UNKNOWN_ERROR,
+      Amity.ErrorLevel.FATAL,
+    )
+  }
+
+  return activeClient!
+}
+
+/**
+ * Sets the active client
+ *
+ * @param client the client to assume as currently active client
+ *
+ * @hidden
+ */
+export const setActiveClient = (client: Amity.Client) => {
+  activeClient = client
+}

package/src/client/api/clearCache.ts

@@ -0,0 +1,23 @@
+import { getActiveClient } from './activeClient'
+
+/**
+ * ```js
+ * import { clearCache } from '@amityco/ts-sdk'
+ * clearCache()
+ * ```
+ *
+ * Resets the state of the given {@link Amity.Store} names within
+ * the {@link Amity.Cache} object of a {@link Amity.Client} instance
+ *
+ * @param stores an array of the stores names to be wiped
+ *
+ * @category Client API
+ */
+export const clearCache = (
+  stores: Amity.Domain[] = ['user', 'file', 'channel', 'message', 'community', 'post', 'comment']
+) => {
+  const client = getActiveClient()
+  client.log('client/api/enableCache')
+
+  stores.forEach(store => client.cache?.[store]?.erase())
+}