@amityco/ts-sdk 1.0.0-8aae813.0 → 6.0.0-beta01

package/src/core/model/identifyModel.ts

@@ -1,32 +1,80 @@
-/** 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]?: (keyof Amity.Models[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'],
+  subChannel: ['subChannelId'],
+  channelUsers: ['channelId', 'userId', 'membership'],
+  message: ['messageId'],
+  community: ['communityId', 'postSetting'],
+  category: ['categoryId'],
+  communityUsers: ['userId', 'communityId', 'communityMembership'],
+  post: ['postId', 'feedId'],
+  comment: ['commentId', 'referenceId'],
+  poll: ['pollId'],
+  reaction: ['reactionId'],
+  stream: ['streamId'],
+  follow: ['from', 'to'],
+  feed: ['feedId', 'feedType'],
+  followInfo: ['userId', 'status'],
+  followCount: ['userId', 'followerCount'],
+};
 
 /** @hidden */
-const hasKeys = (object: { [k: string]: any }, needles: string[]) => {
-  const haystack = Object.keys(object)
-  return needles.every(needle => haystack.includes(needle))
-}
+const hasKeys = (object: Record<string, unknown>, needles: string[]) => {
+  const haystack = Object.keys(object);
+  return needles.every(needle => haystack.includes(needle));
+};
 
 /**
  * Finds the name of the store for a given unknown model
  *
- * @param model one of the {@link Amity.Model} to identify
+ * @param model one of the {@link Amity.Models} to identify
  * @returns the name of the corresponding store
  */
-export const identifyModel = (model: Amity.Model[Amity.Domain]) => {
-  const criterias = Object.entries(CRITERIAS) as [Amity.Domain, string[]][]
-  return criterias.find(([_, keys]) => hasKeys(model, keys))?.[0]
-}
+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[]][];
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  return criterias.find(([_, keys]) => hasKeys(model, keys))?.[0];
+};
+
+/*
+ * Identify the modal key for a model
+ * Used to get args for optimistic updates
+ * Example: createMessage: get messageId on optimistic message creation
+ *
+ * @param model to be recognized
+ * @returns model key array if one if found or undefined
+ */
+export const identifyModelKey = (model: Record<string, unknown>): string | undefined => {
+  const modalKey = identifyModel(model);
+
+  if (!modalKey) {
+    return undefined;
+  }
+
+  return CRITERIAS[modalKey]?.[0];
+};

package/src/core/model/index.ts

@@ -1,3 +1,63 @@
-export * from './identifyModel'
-export * from './idResolvers'
-export * from './toRecord'
+export * from './idResolvers';
+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',
+  messageFeeds: 'subChannel',
+  channelUsers: 'channelUsers',
+  messages: 'message',
+
+  userEntityMarkers: 'channelMarker',
+  userFeedMarkers: 'subChannelMarker',
+  contentMarkers: 'messageMarker',
+  feedMarkers: 'feedMarker',
+  userMarkers: 'userMarker',
+
+  communities: 'community',
+  categories: 'category',
+  communityUsers: 'communityUsers',
+  posts: 'post',
+  postChildren: 'post',
+  comments: 'comment',
+  polls: 'poll',
+  reactions: 'reaction',
+
+  videoStreamings: 'stream',
+
+  follows: 'follow',
+  followCounts: 'followCount',
+
+  feeds: 'feed',
+};
+
+/** hidden */
+export const hasUpdates = <T extends Amity.Model>(prevData: T, nextData: T): boolean => {
+  if ('updatedAt' in prevData && 'updatedAt' in nextData) {
+    return new Date(prevData.updatedAt!) < new Date(nextData.updatedAt!);
+  }
+
+  /*
+   * hasUpdates is used to identify the latest object among many. If the object
+   * does not extend ${Amity.UpdatedAt}, then there is no way to differentiate.
+   * So it is considered by default that the object hasUpdates
+   */
+  return true;
+};
+
+/** hidden */
+export function getFutureDate(date: string | undefined = new Date().toISOString()): string {
+  return new Date(new Date(date).getTime() + 1).toISOString();
+}
+
+/** hidden */
+export function getPastDate(date: string | undefined = new Date().toISOString()): string {
+  return new Date(new Date(date).getTime() - 1).toISOString();
+}

package/src/core/query/filtering.ts

@@ -1,3 +1,5 @@
+import { getResolver } from '~/core/model';
+import { pullFromCache } from '~/cache/api';
 // Note:
 // this file should contain a suite of filtering utilities to help the
 // local version of the query functions.
@@ -12,6 +14,186 @@
  *
  * @hidden
  */
-export const filterByPropEquality = <T = {}>(collection: T[], key: keyof T, value: any) => (
-  value !== undefined ? collection.filter(item => item[key] === value) : collection
-)
+export const filterByPropEquality = <T = Record<string, unknown>>(
+  collection: T[],
+  key: keyof T,
+  value: any,
+) => (value !== undefined ? collection.filter(item => item[key] === value) : collection);
+
+export const filterByPropInclusion = <T = Record<string, unknown>>(
+  collection: T[],
+  key: keyof T,
+  value: any[] | undefined,
+) => (value !== undefined ? collection.filter(item => value.includes(item[key])) : collection);
+
+/**
+ * Filter a channel collection by membership of the userId
+ *
+ * @param collection the channel collection to filter
+ * @param membership the membership to be filtered by
+ * @param userId user id to be filtered by
+ * @returns a filtered collection with items only matching the criteria
+ *
+ * @hidden
+ */
+export const filterByChannelMembership = (
+  collection: Amity.Channel[],
+  membership: Amity.ChannelLiveCollection['membership'],
+  userId: Amity.Membership<'channel'>['userId'],
+): Amity.Channel[] => {
+  if (membership === 'all') {
+    return collection;
+  }
+
+  return collection.filter(c => {
+    // get resolver for the channel by user
+    const channelUserCacheKey = getResolver('channelUsers')({
+      channelId: c.channelId,
+      userId,
+    });
+
+    const channelUser = pullFromCache<Amity.Membership<'channel'>>([
+      'channelUsers',
+      'get',
+      channelUserCacheKey,
+    ])?.data;
+
+    if (membership === 'member') {
+      return channelUser && channelUser.membership !== 'none';
+    }
+
+    // only membership value remainging is 'notMember'
+    return !channelUser || channelUser.membership === 'none';
+  });
+};
+
+/**
+ * Filter a channel collection by membership of the userId
+ *
+ * @param collection the channel collection to filter
+ * @param feedType to be filtered by
+ * @returns a filtered collection with items only matching the criteria
+ *
+ * @hidden
+ */
+export const filterByFeedType = <T extends Amity.Post>(
+  collection: T[],
+  feedType: Amity.Feed['feedType'],
+): T[] => {
+  /*
+   * It is possible that the targetId & feedId are the same for most of the posts
+   * But since cache is in-memory, i've avoided memoizing, to avoid premature
+   * optimization. Can be revisited if performance issues arise
+   */
+  return collection.filter(({ targetId, feedId }) => {
+    const feed = pullFromCache<Amity.Feed>([
+      'feed',
+      'get',
+      getResolver('feed')({ targetId, feedId }),
+    ])?.data!;
+
+    return feed && feed.feedType === feedType;
+  });
+};
+
+/**
+ * Filter a community collection by membership of the userId
+ *
+ * @param collection the community to filter
+ * @param membership the membership to be filtered by
+ * @param userId user id to be filtered by
+ * @returns a filtered collection with items only matching the criteria
+ *
+ * @hidden
+ */
+export const filterByCommunityMembership = <T extends Amity.Community>(
+  collection: T[],
+  membership: Amity.CommunityLiveCollection['membership'],
+  userId: Amity.Membership<'community'>['userId'],
+): T[] => {
+  if (membership === 'all') {
+    return collection;
+  }
+
+  return collection.filter(c => {
+    // get resolver for the community by user
+    const communityUserCacheKey = getResolver('communityUsers')({
+      communityId: c.communityId,
+      userId,
+    });
+
+    const communityUser = pullFromCache<Amity.Membership<'community'>>([
+      'communityUsers',
+      'get',
+      communityUserCacheKey,
+    ])?.data;
+
+    if (membership === 'member') {
+      return communityUser && communityUser.communityMembership === 'member';
+    }
+
+    // only membership value remainging is 'notMember'
+    return !communityUser || communityUser.communityMembership !== 'none';
+  });
+};
+
+/**
+ * Filter a post collection by dataType
+ *
+ * @param collection the post to filter
+ * @param dataTypes of the post to be filtered by
+ * @returns a filtered collection with items only matching the criteria
+ *
+ * @hidden
+ */
+export const filterByPostDataTypes = <T extends Amity.Post>(
+  collection: T[],
+  dataTypes: Amity.PostLiveCollection['dataTypes'],
+): T[] => {
+  const filteredPosts: T[] = [];
+
+  collection.forEach(c => {
+    /*
+     * A text post with no children is just a text post
+     */
+    if (c.dataType === 'text' && !c.children.length) return;
+
+    if (c.children.length) {
+      const childPost = pullFromCache<Amity.Post>(['post', 'get', c.children[0]])?.data;
+
+      if (childPost && dataTypes?.includes(childPost?.dataType)) {
+        // @ts-ignore
+        filteredPosts.push(childPost);
+      }
+
+      return;
+    }
+
+    if (dataTypes?.includes(c.dataType)) filteredPosts.push(c);
+  });
+
+  return filteredPosts;
+};
+
+/**
+ * Filter a collection by search term
+ * Check if userId matches first if not filter by displayName
+ *
+ * @param collection to be filtered
+ * @param searchTerm to filter collection by
+ * @returns a filtered collection with items only matching the search term
+ *
+ * @hidden
+ */
+export const filterBySearchTerm = <T extends { userId: Amity.User['userId']; user?: Amity.User }>(
+  collection: T[],
+  searchTerm: string,
+): T[] => {
+  const containsMatcher = new RegExp(searchTerm);
+
+  return collection.filter(m => {
+    if (m.userId.match(containsMatcher)) return true;
+
+    return m.user && m.user.displayName?.match(containsMatcher);
+  });
+};

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'
+export * from './query';
+export * from './filtering';
+export * from './sorting';
+export * from './paging';

package/src/core/query/paging.ts

@@ -1,17 +1,15 @@
-// @ts-ignore
-import { encode, decode } from 'js-base64'
+import { decode, encode } from 'js-base64';
 
 /**
- * Type guard to find if the a given decoded backend token uses "skip/limit" pagination style
+ * Type guard to find if the a given decoded backend token uses "skip" pagination style
  *
  * @param json any json object as extracted from the backend
  * @returns success boolean if the token has either "skip" or "limit" props
  *
  * @hidden
  */
-export const isSkipLimit = (json: Object): json is Amity.SkipLimitPagination => (
-  ['skip', 'limit'].some(prop => prop in json)
-)
+export const isSkip = (json: Record<string, unknown>): json is Amity.SkipLimitPagination =>
+  ['skip'].some(prop => prop in json);
 
 /**
  * Type guard to find if the a given decoded backend token uses "after/before" pagination style
@@ -21,25 +19,36 @@ export const isSkipLimit = (json: Object): json is Amity.SkipLimitPagination =>
  *
  * @hidden
  */
-export const isAfterBefore = (json: Object): json is Amity.AfterBeforePagination => (
-  ['after', 'before', 'first', 'last'].some(prop => prop in json)
-)
+export const isAfterBefore = (json: Record<string, unknown>): json is Amity.AfterBeforePagination =>
+  ['after', 'before', 'first', 'last', 'limit'].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: Record<string, unknown>,
+): json is Amity.AfterBeforeRawPagination => 'limit' 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, any> => {
   return (
-     payload?.hasOwnProperty('data')
-  && payload?.hasOwnProperty('nextPage')
-  && payload?.hasOwnProperty('prevPage')
-  )
-}
+    payload?.hasOwnProperty('data') &&
+    payload?.hasOwnProperty('nextPage') &&
+    payload?.hasOwnProperty('prevPage')
+  );
+};
 
 /**
  * Converts a paging object into a b64 string token
@@ -51,49 +60,51 @@ export const isPaged = (payload: any): payload is Amity.Paged<any> => {
  * @hidden
  */
 export const toToken = (
-  paging: Amity.Page | undefined,
-  style: 'skiplimit' | 'afterbefore',
-
+  paging: Amity.Page | Amity.PageRaw | undefined,
+  style: Amity.PaginationStyles,
 ): Amity.Token | undefined => {
-  if (!paging || !Object.keys(paging).length)
-    return
+  if (!paging || !Object.keys(paging).length) return;
 
-  let payload = {}
+  let payload = {};
 
   // TODO: refactor this clean
   if (style === 'skiplimit') {
     payload = {
       skip: paging.after ?? 0,
       limit: paging.limit,
-    }
-  }
-  else if (style === 'afterbefore') {
+    };
+  } else if (style === 'afterbefore' && isAfterBefore(paging)) {
     /*
       Caution: this testing style is only valid because
       our backend expects nothing else than a number as
       "before" or "after" value. if that would change,
       we'd need to move toward a more simple: `!paging.before`
     */
-    if (!isNaN(paging?.before!)) {
+    if (!Number.isNaN(Number(paging?.before!))) {
       payload = {
         before: paging.before,
         last: paging.limit,
-      }
-    } else if (!isNaN(paging?.after!)) {
+      };
+    } else if (!Number.isNaN(Number(paging?.after!))) {
       payload = {
         after: paging.after,
         first: paging.limit,
-      }
+      };
+    } else if (!Number.isNaN(Number(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)
-    return
+  if (!Object.keys(payload).length) return;
 
   // don't try catch, let it throw
-  return encode(JSON.stringify(payload))
-}
+  return encode(JSON.stringify(payload));
+};
 
 /**
  * Converts a b64 string token into a paging object
@@ -103,64 +114,54 @@ export const toToken = (
  *
  * @hidden
  */
-export const toPage = (token?: Amity.Token): Amity.Page | null => {
-  if (!token) return null
+export const toPage = (token?: Amity.Token): Amity.Page | undefined => {
+  if (!token) return undefined;
 
   // don't try catch, let it throw
-  const json = JSON.parse(decode(token))
+  const json = JSON.parse(decode(token));
 
-  if (isSkipLimit(json)) {
+  if (isSkip(json)) {
     return {
       after: json.skip,
       limit: json.limit!,
-    } as Amity.NextPage
-  } else if (isAfterBefore(json)) {
+    } as Amity.NextPage<number>;
+  }
+  if (isAfterBefore(json)) {
     if ('before' in json) {
       return {
         before: json.before,
         limit: json.last,
-      } as Amity.PrevPage
-    } else if ('after' in json) {
+      } as Amity.PrevPage<number>;
+    }
+
+    if ('after' in json) {
       return {
         after: json.after,
         limit: json.first,
-      } as Amity.NextPage
+      } as Amity.NextPage<number>;
     }
   }
 
-  return null
-}
+  return undefined;
+};
 
 /**
- * Slices a collection according to its paging
+ * Converts a b64 string token into a paging object
  *
- * @param type the type of collection (for unique id identification with after/before)
- * @param collection the collection to slice
- * @param paging the paging object
- * @returns the sliced collection according to the paging definition
+ * @param token the backend's b64 encoded token
+ * @returns a sdk-friendly paging object
  *
  * @hidden
  */
-export const sliceByPaging = <K extends Amity.Domain, T extends Amity.Model[K]>(
-  type: K, collection: T[], page?: Amity.Page
-) => {
-  console.log('slice by paging', page)
-  if (!page) return collection.slice()
-
-  let start: number | undefined = 0
-  let end: number | undefined = undefined
-
-  // next page behavior
-  if (page.after) {
-    start = page.after
-    end = start + page.limit
-  // prev page behavior
-  } else if (page.before) {
-    end = page.before + 1
-    start = end > page.limit ? end - page.limit : 0
-  }
+export const toPageRaw = (token?: Amity.Token): Amity.PageRaw | undefined => {
+  if (!token) return undefined;
 
-  const paged = collection.slice(start, end)
+  // don't try catch, let it throw
+  const json = JSON.parse(decode(token));
+
+  if (isAfterBeforeRaw(json)) {
+    return json as Amity.PageRaw;
+  }
 
-  return paged.length === page.limit ? paged : undefined
-}
+  return undefined;
+};