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

package/src/community/api/leaveCommunity.ts

@@ -0,0 +1,41 @@
+import { getActiveClient } from '~/client/api'
+
+import { decoratePayload } from '~/core/query'
+import { ingestInCache } from '~/core/cache'
+import { fireEvent } from '~/core/events'
+
+/**
+ * ```js
+ * import { leaveCommunity } from '@amityco/ts-sdk'
+ * const isLeft = await leaveCommunity('foobar')
+ * ```
+ *
+ * Leaves a {@link Amity.Community} object
+ *
+ * @param communityId the {@link Amity.Community} to leave
+ * @returns A success boolean if {@link Amity.Community} was left
+ *
+ * @category Community API
+ * @async
+ */
+export const leaveCommunity = async (communityId: Amity.Community['communityId']) => {
+  const client = getActiveClient()
+  client.log('community/leaveCommunity', communityId)
+
+  const { data } = await client.http.delete<Amity.CommunityMembershipPayload>(
+    `/api/v3/communities/${communityId}/leave`,
+  )
+
+  decoratePayload(data)
+  ingestInCache(data)
+  fireEvent('v3.community.didJoin', {
+    communities: data.communities!,
+  })
+
+  const { communityUsers } = data
+
+  return !!communityUsers.find(communityUser => (
+    communityUser.communityId === communityId
+    && communityUser.communityMembership !== 'member'
+  ))
+}

package/src/community/api/queryCommunities.ts

@@ -0,0 +1,92 @@
+import { getActiveClient } from '~/client/api'
+
+import { decoratePayload, toPage, toToken } from '~/core/query'
+import { ingestInCache } from '~/core/cache'
+import { toRecord } from '~/core/model'
+
+/**
+ * ```js
+ * import { queryCommunities } from '@amityco/ts-sdk'
+ * const communities = await queryCommunities()
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Community} objects
+ * Search is performed by displayName such as `.startsWith(search)`
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Community} objects
+ *
+ * @category Community API
+ * @async
+ */
+export const queryCommunities = async (
+  query?: {
+    displayName?: string
+    membership?: 'all' | 'member' | 'notMember'
+    categoryId?: Amity.Category['categoryId'],
+    isDeleted?: Amity.Community['isDeleted'],
+    hasFlag?: boolean,
+    tags?: Amity.Taggable['tags'],
+    sortBy?: ('displayName' | 'firstCreated' | 'lastCreated')
+    page?: Amity.Page
+  }
+) => {
+  const client = getActiveClient()
+  client.log('channel/queryCommunities', 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.PagedResponse<CommunityPayload>>>(
+  const { data } = await client.http.get<Amity.CommunityPayload & Amity.Pagination>(
+    `/api/v3/communities`, { params: {
+      ...params,
+      keyword: displayName,
+      filter: membership,
+      options: {
+        token: toToken(page, 'skiplimit')
+      }
+    } }
+  )
+
+  // API-FIX: backend to response Amity.Response: const { paging, communities } = unwrapPayload(data)
+  const { paging, ...response } = data
+
+  decoratePayload(response as unknown as Record<string, object[]>)
+  ingestInCache(response as unknown as Record<string, object[]>)
+
+  const prevPage = toPage(paging?.previous)
+  const nextPage = toPage(paging?.next)
+
+  const { communities } = response
+  return { data: toRecord(communities), prevPage, nextPage }
+}
+
+/**
+ * ```js
+ * import { queryCommunities } from '@amityco/ts-sdk'
+ * const communities = queryCommunities.locally()
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Community} objects from cache
+ *
+ * @param query The query parameters
+ * @returns communities
+ *
+ * @category Community API
+ */
+queryCommunities.locally = (
+  query: Parameters<typeof queryCommunities>[0],
+) => {
+  const client = getActiveClient()
+  client.log('community/queryCommunities.locally', query)
+
+  // TODO
+}

package/src/community/api/queryCommunityMembers.ts

@@ -0,0 +1,78 @@
+import { getActiveClient } from '~/client/api'
+
+import { decoratePayload, toPage, toToken } from '~/core/query'
+import { ingestInCache } from '~/core/cache'
+
+import { toRecord } from '~/core/model'
+
+/**
+ * ```js
+ * import { queryCommunityMembers } from '@amityco/ts-sdk'
+ * const communityMembers = await queryCommunityMembers({ communityId: 'foo' })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.CommunityUser} objects
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.CommunityUser} objects
+ *
+ * @category Community API
+ * @async
+ **/
+export const queryCommunityMembers = async (query: {
+  communityId: string
+  membership?: ('banned' | 'member')[]
+  roles?: string[]
+  sortBy?: 'firstCreated' | 'lastCreated'
+  page?: Amity.Page
+}) => {
+  const client = getActiveClient()
+  client.log('community/queryCommunityMembers', query)
+
+  const { page, communityId, ...params } = query ?? {}
+
+  const { data } = await client.http.get<
+    Amity.CommunityMembershipPayload & Amity.Pagination
+  >(`/api/v3/communities/${communityId}/users`, {
+    params: {
+      ...params,
+      options: {
+        token: toToken(page, 'skiplimit'),
+      },
+    },
+  })
+
+  const { paging, ...response } = data
+
+  decoratePayload(response as unknown as Record<string, Object[]>)
+  ingestInCache(response as unknown as Record<string, Object[]>)
+
+  const { communityUsers } = response
+
+  const nextPage = toPage(paging.next)
+  const prevPage = toPage(paging.previous)
+
+  return { data: toRecord(communityUsers), nextPage, prevPage }
+}
+
+/**
+ * ```js
+ * import { queryCommunityMembers } from '@amityco/ts-sdk'
+ * const communityMembers = await queryCommunityMembers(query)
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Post} objects from cache
+ *
+ * @param query The query parameters
+ * @returns posts
+ *
+ * @category Post API
+ */
+queryCommunityMembers.locally = (
+  query: Parameters<typeof queryCommunityMembers>[0]
+) => {
+  const client = getActiveClient()
+  client.log('community/queryCommunityMembers', query)
+
+  // TODO
+}

package/src/community/api/removeCommunityMembers.ts

@@ -0,0 +1,46 @@
+import { getActiveClient } from '~/client/api'
+
+import { decoratePayload } from '~/core/query'
+import { ingestInCache } from '~/core/cache'
+import { fireEvent } from '~/core/events'
+
+/**
+ * ```js
+ * import { removeCommunityMembers } from '@amityco/ts-sdk'
+ * const updated = await removeCommunityMembers(communityId, ['foo', 'bar'])
+ * ```
+ *
+ * Removes a list of {@link Amity.User} from a {@link Amity.Channel}
+ *
+ * @param communityId The ID of the {@link Amity.Community} to edit
+ * @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.Community}
+ *
+ * @category Community API
+ * @async
+ */
+export const removeCommunityMembers = async (
+  communityId: Amity.Community['communityId'],
+  userIds: Amity.User['userId'][]
+) => {
+  const client = getActiveClient()
+  client.log('community/removeCommunityMembers', communityId, userIds)
+
+  const { data } = await client.http.delete<Amity.CommunityMembershipPayload>(
+    `/api/v3/communities/${communityId}/users`,
+    { data: { communityId, userIds } }
+  )
+
+  decoratePayload(data)
+  ingestInCache(data)
+  fireEvent('v3.community.didRemoveUsers', {
+    communities: data.communities!,
+  })
+
+  const { communityUsers } = data
+  return !!communityUsers.find(
+    communityUser =>
+      communityUser.communityId === communityId &&
+      communityUser.communityMembership !== 'member'
+  )
+}

package/src/community/api/removeCommunityMembersRole.ts

@@ -0,0 +1,43 @@
+import { getActiveClient } from '~/client/api'
+
+import { decoratePayload } from '~/core/query'
+import { ingestInCache } from '~/core/cache'
+
+/**
+ * ```js
+ * import { removeCommunityMembersRole } from '@amityco/ts-sdk'
+ * const updated = await removeCommunityMembersRole(communityId,  'foo', ['bar'])
+ * ```
+ *
+ * Removes an {@link Amity.Role} from a list of {@link Amity.User} on a {@link Amity.Community}
+ *
+ * @param communityId The ID of the {@link Amity.Community} to perform
+ * @param role 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.Community}
+ *
+ * @category Community API
+ * @async
+ */
+export const removeCommunityMembersRole = async (
+  communityId: Amity.Community['communityId'],
+  roleId: Amity.Role['roleId'],
+  userIds: Amity.User['userId'][]
+) => {
+  const client = getActiveClient()
+  client.log('community/removeCommunityMembersRole', communityId, roleId, userIds)
+
+  const { data } = await client.http.delete<Amity.CommunityMembershipPayload>(
+    `/api/v3/communities/${communityId}/users/roles`,
+    { data: { communityId, role: roleId, userIds } }
+  )
+
+  decoratePayload(data)
+  ingestInCache(data)
+
+  const { communityUsers } = data
+  return !!communityUsers.find(
+    communityUser =>
+    communityUser.communityId === communityId && !communityUser.roles.includes(roleId)
+  )
+}

package/src/community/api/updateCommunity.ts

@@ -0,0 +1,40 @@
+import { getActiveClient } from '~/client/api'
+
+import { decoratePayload } from '~/core/query'
+import { ingestInCache } from '~/core/cache'
+import { fireEvent } from '~/core/events'
+
+
+/**
+ * ```js
+ * import { updateCommunity } from '@amityco/ts-sdk'
+ * const updated = await updateCommunity(communityId, { displayName: 'foobar' })
+ * ```
+ *
+ * Updates an {@link Amity.Community}
+ *
+ * @param communityId The ID of the {@link Amity.Community} to edit
+ * @param patch The patch data to apply
+ * @returns the updated {@link Amity.Community} object
+ *
+ * @category Community API
+ * @async
+ */
+export const updateCommunity = async (
+  communityId: Amity.Community['communityId'],
+  patch: Patch<Amity.Community, 'displayName' | 'description' | 'avatarFileId' | 'tags' | 'metadata'>,
+) => {
+  const client = getActiveClient()
+  client.log('community/updateCommunity', communityId, patch)
+
+  const { data } = await client.http.put<Amity.CommunityPayload>(
+    `/api/v3/communities/${communityId}`, patch,
+  )
+
+  decoratePayload(data)
+  ingestInCache(data)
+  fireEvent('v3.community.didUpdate', data)
+
+  const { communities } = data
+  return communities.find(community => community.communityId === communityId)!
+}

package/src/community/events/index.ts

@@ -0,0 +1,6 @@
+export * from './onCommunityCreated'
+export * from './onCommunityUpdated'
+export * from './onCommunityDeleted'
+
+export * from './onCommunityJoined'
+export * from './onCommunityLeft'

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

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

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

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

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

package/src/community/observers/index.ts

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

package/src/community/observers/observeCommunity.ts

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

package/src/core/cache/drop.ts

@@ -0,0 +1,24 @@
+import { getActiveClient } from '~/client/api/activeClient'
+import { getResolver } from '../model/idResolvers'
+
+/**
+ * Pull objects from the cache layer
+ *
+ * @param name The name of the store to query
+ * @param keys A collection of unique keys for the store
+ * @returns The collection of objects matching the keys. Keys which don't match object will be omitted
+ *
+ * @category Cache
+ */
+export const dropFromCache = <T extends Amity.Domain>(name: T, partial: Amity.Minimal[T] & Partial<Amity.Model[T]>) => {
+  const { cache } = getActiveClient()
+  const store = cache?.[name] as unknown as Amity.Store<Amity.Model[T]>
+
+  if (!cache || !store) return []
+
+  const modelId = getResolver(name)(partial)
+  const localId = cache.lookup[`${name}#${modelId}`]
+
+  delete cache.lookup[`${name}#${modelId}`]
+  store.erase(localId)
+}

package/src/core/cache/index.ts

@@ -0,0 +1,24 @@
+export * from './pull'
+export * from './push'
+export * from './drop'
+export * from './sync'
+export * from './ingest'
+export * from './mutate'
+export * from './merge'
+
+/**
+ * Creates a cache instance. The cache instance will handle stores
+ * given to it as input, and will be used as the first source of cached data
+ * in the SDK.
+ *
+ * @param stores A partial collection of stores
+ * @returns A cache instance
+ *
+ * @category Cache
+ */
+export const createCache = (
+  stores: Partial<Amity.StoreCollection<Amity.Domain[]>>
+): Amity.Cache => {
+  const lookup: Record<string, string> = {}
+  return { lookup, ...stores }
+}