@amityco/ts-sdk 0.0.1-be4fc2f.0 → 0.0.1-beta.10

package/src/community/events/onCommunityUpdated.ts

@@ -8,7 +8,7 @@ import { createCommunityEventSubscriber } from './utils'
  * })
  * ```
  *
- * Fired when any {@link Amity.Community} have been updated
+ * Fired when a {@link Amity.Community} has been updated
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening

package/src/community/events/onCommunityUserAdded.ts

@@ -1,19 +1,19 @@
-import { createCommunityEventSubscriber } from './utils'
+import { createCommunityMemberEventSubscriber } from './utils'
 
 /**
  * ```js
  * import { onCommunityUserAdded } from '@amityco/ts-sdk'
- * const dispose = onCommunityUserAdded(community => {
+ * const dispose = onCommunityUserAdded((community, member) => {
  *   // ...
  * })
  * ```
  *
- * Fired when any {@link Amity.Community} have been updated
+ * Fired when a user has been added to a {@link Amity.Community}
  *
  * @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 onCommunityUserAdded = (callback: Amity.Listener<Amity.Community>) =>
-  createCommunityEventSubscriber('community.userAdded', callback)
+export const onCommunityUserAdded = (callback: (community: Amity.Community, member: Amity.Membership<'community'>) => void) =>
+  createCommunityMemberEventSubscriber('community.userAdded', callback)

package/src/community/events/onCommunityUserBanned.ts

@@ -1,19 +1,19 @@
-import { createCommunityEventSubscriber } from './utils'
+import { createCommunityMemberEventSubscriber } from './utils'
 
 /**
  * ```js
  * import { onCommunityUserBanned } from '@amityco/ts-sdk'
- * const dispose = onCommunityUserBanned(community => {
+ * const dispose = onCommunityUserBanned((community, member) => {
  *   // ...
  * })
  * ```
  *
- * Fired when any {@link Amity.Community} have been updated
+ * Fired when a user has been banned from a {@link Amity.Community}
  *
  * @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 onCommunityUserBanned = (callback: Amity.Listener<Amity.Community>) =>
-  createCommunityEventSubscriber('community.userUnbanned', callback)
+export const onCommunityUserBanned = (callback: (community: Amity.Community, member: Amity.Membership<'community'>) => void) =>
+  createCommunityMemberEventSubscriber('community.userBanned', callback)

package/src/community/events/onCommunityUserRemoved.ts

@@ -1,19 +1,19 @@
-import { createCommunityEventSubscriber } from './utils'
+import { createCommunityMemberEventSubscriber } from './utils'
 
 /**
  * ```js
  * import { onCommunityUserRemoved } from '@amityco/ts-sdk'
- * const dispose = onCommunityUserRemoved(community => {
+ * const dispose = onCommunityUserRemoved((community, member) => {
  *   // ...
  * })
  * ```
  *
- * Fired when any {@link Amity.Community} have been updated
+ * Fired when a user has been removed from a {@link Amity.Community}
  *
  * @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 onCommunityUserRemoved = (callback: Amity.Listener<Amity.Community>) =>
-  createCommunityEventSubscriber('community.userRemoved', callback)
+export const onCommunityUserRemoved = (callback: (community: Amity.Community, member: Amity.Membership<'community'>) => void) =>
+  createCommunityMemberEventSubscriber('community.userRemoved', callback)

package/src/community/events/onCommunityUserUnbanned.ts

@@ -1,19 +1,19 @@
-import { createCommunityEventSubscriber } from './utils'
+import { createCommunityMemberEventSubscriber } from './utils'
 
 /**
  * ```js
  * import { onCommunityUserUnbanned } from '@amityco/ts-sdk'
- * const dispose = onCommunityUserUnbanned(community => {
+ * const dispose = onCommunityUserUnbanned((community, member) => {
  *   // ...
  * })
  * ```
  *
- * Fired when any {@link Amity.Community} have been updated
+ * Fired when a user has been unbanned from a {@link Amity.Community}
  *
  * @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 onCommunityUserUnbanned = (callback: Amity.Listener<Amity.Community>) =>
-  createCommunityEventSubscriber('community.userUnbanned', callback)
+export const onCommunityUserUnbanned = (callback: (community: Amity.Community, member: Amity.Membership<'community'>) => void) =>
+  createCommunityMemberEventSubscriber('community.userUnbanned', callback)

package/src/community/events/utils.ts

@@ -1,7 +1,9 @@
+import isMatch from 'lodash.ismatch'
 import { getActiveClient } from '~/client/api'
-import { decoratePayload } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
+import { pullFromCache } from '~/cache/api'
+import { ingestInCache } from '~/cache/api/ingestInCache'
 import { createEventSubscriber } from '~/core/events'
+import { getResolver } from '~/core/model'
 
 export const createCommunityEventSubscriber = (
   event: keyof Amity.MqttCommunityMessageEvents,
@@ -10,9 +12,97 @@ export const createCommunityEventSubscriber = (
   const client = getActiveClient()
 
   const filter = (payload: Amity.CommunityPayload) => {
-    decoratePayload(payload)
+    if (!client.cache) {
+      callback(payload.communities[0])
+    } else {
+      const cached = pullFromCache<Amity.Community>(['community', 'get', payload.communities[0].communityId])
+
+      ingestInCache(payload)
+
+      const community = pullFromCache<Amity.Community>(['community', 'get', payload.communities[0].communityId])!
+
+      if (cached && isMatch(cached.data, community?.data)) {
+        return
+      }
+
+      callback(community.data)
+    }
+  }
+
+  return createEventSubscriber(
+    client,
+    event,
+    event,
+    filter
+  )
+}
+
+function hasPermission(member: Amity.Membership<'community'>, payload: Amity.CommunityPayload, permission: string) {
+  if (member.permissions.some(x => x === permission)) {
+    return true;
+  }
+
+  return payload.users!
+    .find(user => user.userId === member.userId)!
+    .permissions.some(x => x === permission)
+}
+
+
+function getEventRelatedMember(
+  event: keyof Amity.MqttCommunityUserMessageEvents,
+  payload: Amity.CommunityPayload
+)  {
+  if (event === 'community.joined' || event === 'community.left') {
+    return payload.communityUsers![0];
+  }
+
+  // NOTE: backend returns the one who took the action and the one on whom
+  // the action was taken. We need the 2nd one
+  if (event === 'community.userRemoved') {
+    return payload.communityUsers!.filter(x => x.communityMembership === 'none')[0]
+  }
+
+  if (event === 'community.userBanned') {
+    return payload.communityUsers!.filter(x => x.communityMembership === 'banned')[0]
+  }
+
+  // NOTE: it might be that in certain edge cases permission check won't be enough
+  if (event === 'community.userUnbanned') {
+    return payload.communityUsers!.filter(x => !hasPermission(x, payload, 'BAN_COMMUNITY_USER'))[0]
+  }
+
+  return payload.communityUsers!.filter(x => !hasPermission(x, payload, 'ADD_COMMUNITY_USER'))[0]
+}
+
+export const createCommunityMemberEventSubscriber = (
+  event: keyof Amity.MqttCommunityUserMessageEvents,
+  callback: (community: Amity.Community, member: Amity.Membership<'community'>) => void,
+) => {
+  const client = getActiveClient()
+
+  const filter = (payload: Amity.CommunityPayload) => {
+    const cachedCommunity = pullFromCache<Amity.Community>(['community', 'get', payload.communities[0].communityId])
+    const cachedMember = pullFromCache<Amity.Membership<'community'>>([
+      'communityUsers',
+      'get',
+      getResolver('communityUsers')(getEventRelatedMember(event, payload))
+    ])
+
     ingestInCache(payload)
-    callback(payload.communities[0])
+
+    const community = pullFromCache<Amity.Community>(['community', 'get', payload.communities[0].communityId])!
+    const member = pullFromCache<Amity.Membership<'community'>>([
+      'communityUsers',
+      'get',
+      getResolver('communityUsers')(getEventRelatedMember(event, payload))
+    ])!
+
+    if (cachedCommunity && isMatch(cachedCommunity.data, community.data)
+      && cachedMember && isMatch(cachedMember.data, member.data)) {
+      return
+    }
+
+    callback(community.data, member.data)
   }
 
   return createEventSubscriber(

package/src/community/observers/observeCommunity.ts

@@ -1,5 +1,4 @@
 import { createQuery, runQuery } from '~/core/query/query'
-import { getTopic, subscribe } from '~/core/subscription'
 
 import { getActiveClient } from '~/client/api'
 
@@ -34,7 +33,7 @@ import {
  */
 export const observeCommunity = <Events extends ['onFetch', 'onUpdate', 'onDelete', 'onJoin', 'onLeft', 'onUserAdded', 'onUserRemoved', 'onUserBanned', 'onUserUnbanned']>(
   communityId: string,
-  callback: Amity.ObjectListener<Amity.QueryResult<Amity.Community>, Events>
+  callback: Amity.ObjectListener<Amity.Snapshot<Amity.Community | undefined>, Events>
 ): Amity.Unsubscriber => {
   const { log } = getActiveClient()
 
@@ -43,41 +42,41 @@ export const observeCommunity = <Events extends ['onFetch', 'onUpdate', 'onDelet
 
   // wrapper function to make sure
   const router = (
-    result: Amity.QueryResult<Amity.Community>,
+    result: Amity.Snapshot<Amity.Community | undefined>,
     action: Events[number]
   ) => {
-    // filter function
-    if (result.data?.communityId !== communityId) return
+    if (callback instanceof Function) return callback(result)
 
-    if (action === 'onFetch') {
-      disposers.push(subscribe(getTopic(result.data)))
-    }
+    if (action !== 'onFetch') callback.onEvent?.(action, result)
 
-    if (callback instanceof Function)
-      return callback(result)
+    callback[action]?.(result)
+  }
 
-    if (action !== 'onFetch')
-      callback.onEvent?.(action, result)
+  const realtimeRouter = (
+    result: Amity.Snapshot<Amity.Community>,
+    action: Events[number]
+  ) => {
+    if (result.data?.communityId !== communityId) return
 
-    callback[action]?.(result)
+    router(result, action)
   }
 
   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')),
-    onCommunityUserAdded(data => router({ data }, 'onUserAdded')),
-    onCommunityUserRemoved(data => router({ data }, 'onUserRemoved')),
-    onCommunityUserBanned(data => router({ data }, 'onUserBanned')),
-    onCommunityUserUnbanned(data => router({ data }, 'onUserUnbanned')),
+    onCommunityUpdated(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onUpdate')),
+    onCommunityDeleted(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onDelete')),
+    onCommunityJoined(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onJoin')),
+    onCommunityLeft(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onLeft')),
+    onCommunityUserAdded(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onUserAdded')),
+    onCommunityUserRemoved(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onUserRemoved')),
+    onCommunityUserBanned(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onUserBanned')),
+    onCommunityUserUnbanned(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onUserUnbanned')),
   )
 
   runQuery(
     createQuery(getCommunity, communityId),
-    result => result.data && router(result, 'onFetch')
+    result => (result.data || result.error) && router(result, 'onFetch')
   )
 
   return () => {

package/src/core/model/idResolvers.ts

@@ -1,23 +1,14 @@
 /**
- * A resolver function is a function which, given a minimal version of a model T
- * can compute a string which is capable of identifying the given model uniquely
- * @hidden
+ * Manually computed type which links each key with a function
+ * used to return the object's unique id. The type is computed
+ * to avoid using any and give some typing security at the
+ * resolver's level.
  */
-type Resolver<T extends Amity.Domain> = (model: Amity.Minimal[T]) => string
-
-/**
- * Manually computed type to output a dictionary of { Domain: Amity.Resolver<Model> }
- * with proper typing based on T
- * @hidden
- */
-type Resolvers<T extends Amity.Domain[] = Amity.Domain[]> = {
-  [K in T[number]]: Resolver<K>
+ type Resolvers<T extends Amity.Domain[] = Amity.Domain[]> = {
+  [K in T[number]]: (model: Amity.Minimal[K]) => string
 }
 
-/**
- * Dictionary of resolver functions for each model
- * @hidden
- */
+/** @hidden */
 const idResolvers: Resolvers = {
   user: ({ userId }) => userId,
   file: ({ fileId }) => fileId,
@@ -39,29 +30,8 @@ const idResolvers: Resolvers = {
  * Retrieve the id resolver matching a domain name
  *
  * @param name the domain name for the resolve
- * @returns an idResolver for the given domain name
+ * @returns an idResolver function for the given domain name
  */
-export const getResolver = <T extends Amity.Domain>(name: T) => (
-  idResolvers[name] as Resolver<T>
+ export const getResolver = <T extends Amity.Domain>(name: T) => (
+  idResolvers[name]
 )
-
-/**
- * A map of v3 response keys to a store name.
- * @hidden
- */
-export const storeInterests: Record<string, Amity.Domain> = {
-  users: 'user',
-  files: 'file',
-  roles: 'role',
-
-  channels: 'channel',
-  channelUsers: 'channelUsers',
-  messages: 'message',
-
-  communities: 'community',
-  communityUsers: 'communityUsers',
-  posts: 'post',
-  postChildren: 'post',
-  comments: 'comment',
-  videoStreamings: 'stream',
-}

package/src/core/model/identifyModel.ts

@@ -1,21 +1,40 @@
-/** hidden */
-/** @hidden */
-const CRITERIAS: Record<Amity.Domain, string[]>  = {
-  'file': ['fileId', 'attributes'],
-  'user': ['userId', 'avatarFileId'],
-  'role': ['roleId'],
-  'channel': ['channelId', 'rateLimit'],
-  'channelUsers': ['channelId', 'userId', 'membership'],
-  'message': ['messageId'],
-  'community': ['communityId', 'onlyAdminCanPost'],
-  'communityUsers': ['userId', 'communityId', 'communityMembership'],
-  'post': ['postId', 'feedId'],
-  'comment': ['commentId', 'referenceId'],
-  'stream': ['streamId'],
+/**
+ * Manually computed type which links each key with array
+ * of matching keys as values. The type is computed rather
+ * than letting string[] to help identifying mistakes while
+ * adding new models.
+ * @hidden
+ */
+ type Criterias<T extends Amity.Domain[] = Amity.Domain[]> = {
+  [K in T[number]]: (keyof Amity.Model[K])[]
+}
+
+/**
+ * Identification criterias
+ *
+ * As key, the name of the identified model ;
+ * As value, the list of properties to consider a given model as of type
+ *
+ * Used as source of truth for {@link identifyModel}
+ *
+ * @hidden
+ */
+const CRITERIAS: Criterias  = {
+  file: ['fileId', 'attributes'],
+  user: ['userId', 'avatarFileId'],
+  role: ['roleId'],
+  channel: ['channelId', 'rateLimit'],
+  channelUsers: ['channelId', 'userId', 'membership'],
+  message: ['messageId'],
+  community: ['communityId', 'onlyAdminCanPost'],
+  communityUsers: ['userId', 'communityId', 'communityMembership'],
+  post: ['postId', 'feedId'],
+  comment: ['commentId', 'referenceId'],
+  stream: ['streamId'],
 }
 
 /** @hidden */
-const hasKeys = (object: { [k: string]: any }, needles: string[]) => {
+const hasKeys = (object: Record<string, unknown>, needles: string[]) => {
   const haystack = Object.keys(object)
   return needles.every(needle => haystack.includes(needle))
 }
@@ -26,7 +45,9 @@ const hasKeys = (object: { [k: string]: any }, needles: string[]) => {
  * @param model one of the {@link Amity.Model} to identify
  * @returns the name of the corresponding store
  */
-export const identifyModel = (model: Amity.Model[Amity.Domain]) => {
+export const identifyModel = (model: Record<string, unknown>) => {
+  // we cannot avoid "as" in here because Object.entries does not
+  // allow anything else than "string" as key in the iterator type
   const criterias = Object.entries(CRITERIAS) as [Amity.Domain, string[]][]
   return criterias.find(([_, keys]) => hasKeys(model, keys))?.[0]
 }

package/src/core/model/index.ts

@@ -1,3 +1,23 @@
-export * from './identifyModel'
 export * from './idResolvers'
-export * from './toRecord'
+export * from './identifyModel'
+
+/**
+ * A map of v3 response keys to a store name.
+ * @hidden
+ */
+ export const PAYLOAD2MODEL: Record<string, Amity.Domain> = {
+  users: 'user',
+  files: 'file',
+  roles: 'role',
+
+  channels: 'channel',
+  channelUsers: 'channelUsers',
+  messages: 'message',
+
+  communities: 'community',
+  communityUsers: 'communityUsers',
+  posts: 'post',
+  postChildren: 'post',
+  comments: 'comment',
+  videoStreamings: 'stream',
+}

package/src/core/query/index.ts

@@ -1,5 +1,4 @@
 export * from './query'
-export * from './decorate'
 export * from './filtering'
 export * from './sorting'
 export * from './paging'

package/src/core/query/paging.ts

@@ -25,15 +25,27 @@ export const isAfterBefore = (json: Object): json is Amity.AfterBeforePagination
   ['after', 'before', 'first', 'last'].some(prop => prop in json)
 )
 
+/**
+ * Type guard to find if the a given decoded backend token uses v4 or newer "after/before" pagination style
+ *
+ * @param json any json object as extracted from the backend
+ * @returns success boolean if the token has either "after" or "before" props
+ *
+ * @hidden
+ */
+export const isAfterBeforeRaw = (json: Object): json is Amity.AfterBeforeRawPagination => (
+  ['after', 'before'].some(prop => prop in json)
+)
+
 /**
  * Type guard to find if the a given object is wrapped around Amity.Paged<>
  *
  * @param payload any object as passed from query functions
- * @returns success boolean if the object is an array shaped as [Record<string, Amity.Syncable>, Amity.Pages]
+ * @returns success boolean if the object is an object shaped as { data: T[] } & Amity.Pages
  *
  * @hidden
  */
-export const isPaged = (payload: any): payload is Amity.Paged<any> => {
+export const isPaged = <T extends unknown>(payload: any): payload is Amity.Paged<T> => {
   return (
      payload?.hasOwnProperty('data')
   && payload?.hasOwnProperty('nextPage')
@@ -52,7 +64,7 @@ export const isPaged = (payload: any): payload is Amity.Paged<any> => {
  */
 export const toToken = (
   paging: Amity.Page | undefined,
-  style: 'skiplimit' | 'afterbefore',
+  style: 'skiplimit' | 'afterbefore' | 'afterbeforeraw',
 
 ): Amity.Token | undefined => {
   if (!paging || !Object.keys(paging).length)
@@ -84,8 +96,15 @@ export const toToken = (
         after: paging.after,
         first: paging.limit,
       }
+    } else if (!isNaN(paging?.limit!)) {
+      payload = {
+        last: paging.limit,
+      }
     }
   }
+  else if (style === 'afterbeforeraw') {
+    payload = paging
+  }
 
   // avoid sending {} as it seems backend flips when we do
   if (!Object.keys(payload).length)
@@ -131,6 +150,27 @@ export const toPage = (token?: Amity.Token): Amity.Page | null => {
   return null
 }
 
+/**
+ * Converts a b64 string token into a paging object
+ *
+ * @param token the backend's b64 encoded token
+ * @returns a sdk-friendly paging object
+ *
+ * @hidden
+ */
+export const toPageRaw = (token?: Amity.Token): Amity.PageRaw | null => {
+  if (!token) return null
+
+  // don't try catch, let it throw
+  const json = JSON.parse(decode(token))
+
+  if (isAfterBeforeRaw(json)) {
+    return json as Amity.PageRaw
+  }
+
+  return null
+}
+
 /**
  * Slices a collection according to its paging
  *