@amityco/ts-sdk 7.10.1-86aa7706.0 → 7.10.1-9fe9d33d.0

package/src/core/liveCollection/PaginationController.ts

@@ -0,0 +1,71 @@
+import { AxiosInstance } from 'axios';
+import { getActiveClient } from '~/client/api/activeClient';
+
+export abstract class PaginationController<
+  TPayloadDomain extends keyof Amity.Payloads,
+  TQueryParams,
+> {
+  private queryParams: Amity.LiveCollectionParams<TQueryParams>;
+
+  protected http: AxiosInstance;
+
+  private previousToken: string | undefined;
+
+  private nextToken: string | undefined;
+
+  constructor(queryParams: Amity.LiveCollectionParams<TQueryParams>) {
+    const { http } = getActiveClient();
+
+    this.queryParams = queryParams;
+    this.http = http;
+  }
+
+  loadFirstPage(): Promise<(Amity.Payloads[TPayloadDomain] & Amity.Pagination) | undefined> {
+    return this.onFetch(Amity.LiveCollectionPageDirection.FIRST);
+  }
+
+  loadNextPage(): Promise<(Amity.Payloads[TPayloadDomain] & Amity.Pagination) | undefined> {
+    return this.onFetch(Amity.LiveCollectionPageDirection.NEXT);
+  }
+
+  loadPreviousPage(): Promise<(Amity.Payloads[TPayloadDomain] & Amity.Pagination) | undefined> {
+    return this.onFetch(Amity.LiveCollectionPageDirection.PREV);
+  }
+
+  async onFetch(
+    direction: Amity.LiveCollectionPageDirection = Amity.LiveCollectionPageDirection.FIRST,
+  ) {
+    if (direction === 'prev' && !this.previousToken) return;
+    if (direction === 'next' && !this.nextToken) return;
+
+    let token: string | undefined;
+
+    if (direction === 'prev') token = this.previousToken;
+    if (direction === 'next') token = this.nextToken;
+
+    const queryResponse = await this.getRequest(this.queryParams, token);
+
+    if (direction === 'first') {
+      this.nextToken = queryResponse.paging?.next;
+      this.previousToken = queryResponse.paging?.previous;
+    }
+
+    if (direction === 'prev') this.previousToken = queryResponse.paging?.previous;
+    if (direction === 'next') this.nextToken = queryResponse.paging?.next;
+
+    return queryResponse;
+  }
+
+  abstract getRequest(
+    queryParams: TQueryParams,
+    token: string | undefined,
+  ): Promise<Amity.Payloads[TPayloadDomain] & Amity.Pagination>;
+
+  getNextToken(): string | undefined {
+    return this.nextToken;
+  }
+
+  getPrevToken(): string | undefined {
+    return this.previousToken;
+  }
+}

package/src/core/liveCollection/PaginationNoPageController.ts

@@ -0,0 +1,26 @@
+import { AxiosInstance } from 'axios';
+import { getActiveClient } from '~/client/api/activeClient';
+
+export abstract class PaginationNoPageController<
+  TPayloadDomain extends keyof Amity.Payloads,
+  TQueryParams,
+> {
+  private queryParams: TQueryParams;
+
+  protected http: AxiosInstance;
+
+  constructor(queryParams: TQueryParams) {
+    const { http } = getActiveClient();
+
+    this.queryParams = queryParams;
+    this.http = http;
+  }
+
+  async onFetch() {
+    const queryResponse = await this.getRequest(this.queryParams);
+
+    return queryResponse;
+  }
+
+  abstract getRequest(queryParams: TQueryParams): Promise<Amity.Payloads[TPayloadDomain]>;
+}

package/src/core/liveCollection/QueryStreamController.ts

@@ -0,0 +1,21 @@
+export abstract class QueryStreamController<
+  TQueryResponse extends ValueOf<Amity.Payloads>,
+  TQueryParams,
+> {
+  protected query: Amity.LiveCollectionParams<TQueryParams>;
+
+  protected cacheKey: string[];
+
+  constructor(query: Amity.LiveCollectionParams<TQueryParams>, cacheKey: string[]) {
+    this.query = query;
+    this.cacheKey = cacheKey;
+  }
+
+  abstract saveToMainDB(response: TQueryResponse): Promise<void> | void;
+
+  abstract appendToQueryStream(
+    response: TQueryResponse & Amity.Pagination,
+    direction: Amity.LiveCollectionPageDirection,
+    refresh: boolean | undefined,
+  ): void;
+}

package/src/core/microtasks.ts

@@ -0,0 +1,28 @@
+/* eslint-disable @typescript-eslint/ban-types */
+let tasks: Function[] = [];
+let timer: NodeJS.Timeout;
+
+/**
+ * Add a function to run just before the next tick
+ *
+ * @param task function to schedule for later execution
+ */
+export const scheduleTask = (task: Function) => {
+  clearTimeout(timer);
+  tasks.push(task);
+
+  timer = setTimeout(() => {
+    tasks.forEach(fn => fn());
+    tasks = [];
+  }, 0);
+};
+
+/**
+ * Cancel the scheduling operation
+ *
+ * @param task function to be removed from later execution
+ */
+export const cancelTask = (task: Function) => {
+  tasks = tasks.filter(fn => fn !== task);
+  if (!tasks.length) clearTimeout(timer);
+};

package/src/core/model/idResolvers.ts

@@ -0,0 +1,78 @@
+/**
+ * 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;
+type Resolvers<T extends Amity.Domain = Amity.Domain> = {
+  [K in T]: Resolver<K>;
+};
+
+/** @hidden */
+const idResolvers: Resolvers = {
+  user: ({ userId }) => userId,
+  file: ({ fileId }) => fileId,
+  role: ({ roleId }) => roleId,
+
+  channel: ({ channelInternalId }) => channelInternalId,
+  subChannel: ({ subChannelId }) => subChannelId,
+  channelUsers: ({ channelId, userId }) => `${channelId}#${userId}`,
+  message: ({ messageId, referenceId }) => referenceId ?? messageId,
+
+  messagePreviewChannel: ({ channelId }) => `${channelId}`,
+  messagePreviewSubChannel: ({ subChannelId }) => `${subChannelId}`,
+
+  channelUnreadInfo: ({ channelId }) => channelId,
+  subChannelUnreadInfo: ({ subChannelId }) => subChannelId,
+
+  channelUnread: ({ channelId }) => channelId,
+
+  channelMarker: ({ entityId, userId }) => `${entityId}#${userId}`,
+  subChannelMarker: ({ entityId, feedId, userId }) => `${entityId}#${feedId}#${userId}`,
+  messageMarker: ({ feedId, contentId, creatorId }) => `${feedId}#${contentId}#${creatorId}`,
+  feedMarker: ({ feedId, entityId }) => `${feedId}#${entityId}`,
+
+  userMarker: ({ userId }) => userId,
+
+  community: ({ communityId }) => communityId,
+  category: ({ categoryId }) => categoryId,
+  communityUsers: ({ communityId, userId }) => `${communityId}#${userId}`,
+  post: ({ postId }) => postId,
+  comment: ({ commentId }) => commentId,
+  commentChildren: ({ commentId }) => commentId,
+  poll: ({ pollId }) => pollId,
+  reaction: ({ referenceType, referenceId }) => `${referenceType}#${referenceId}`,
+  reactor: ({ reactionId }) => reactionId,
+
+  stream: ({ streamId }) => streamId,
+  streamModeration: ({ streamId }) => streamId,
+
+  follow: ({ from, to }) => `${from}#${to}`,
+  followInfo: ({ userId }) => userId,
+  followCount: ({ userId }) => userId,
+
+  feed: ({ targetId, feedId }) => `${targetId}#${feedId}`,
+  story: ({ referenceId }) => referenceId!,
+  storyTarget: ({ targetId }) => targetId,
+
+  ad: ({ adId }) => adId,
+  advertiser: ({ advertiserId }) => advertiserId,
+
+  pin: ({ placement, referenceId }) => `${placement}#${referenceId}`,
+  pinTarget: ({ targetId }) => targetId,
+
+  notificationTrayItem: ({ _id }) => _id,
+  notificationTraySeen: ({ userId }) => userId,
+
+  invitation: ({ _id }) => _id,
+  joinRequest: ({ joinRequestId }) => joinRequestId,
+};
+
+/**
+ * Retrieve the id resolver matching a domain name
+ *
+ * @param name the domain name for the resolve
+ * @returns an idResolver function for the given domain name
+ */
+export const getResolver = <T extends Amity.Domain>(name: T): Resolver<T> => idResolvers[name];

package/src/core/model/identifyModel.ts

@@ -0,0 +1,81 @@
+/**
+ * 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', 'roles', 'permissions'],
+  role: ['roleId'],
+  channel: ['channelId', 'defaultSubChannelId'],
+  subChannel: ['subChannelId', 'latestMessageId'],
+  channelUsers: ['channelId', 'userId', 'membership'],
+  message: ['messageId'],
+  community: ['communityId', 'postSetting'],
+  category: ['categoryId'],
+  communityUsers: ['userId', 'communityId', 'communityMembership'],
+  post: ['postId', 'feedId'],
+  comment: ['commentId', 'referenceId'],
+  poll: ['pollId'],
+  reaction: ['referenceId', 'referenceType', 'reactors'],
+  reactor: ['reactionId'],
+  stream: ['streamId'],
+  follow: ['from', 'to'],
+  feed: ['feedId', 'feedType'],
+  followInfo: ['userId', 'status'],
+  followCount: ['userId', 'followerCount'],
+};
+
+/** @hidden */
+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.Models} to identify
+ * @returns the name of the corresponding store
+ */
+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

@@ -0,0 +1,81 @@
+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',
+  stories: 'story',
+  storyTargets: 'storyTarget',
+
+  channels: 'channel',
+  messageFeeds: 'subChannel',
+  channelUsers: 'channelUsers',
+  messages: 'message',
+
+  messagePreviewChannel: 'messagePreviewChannel',
+  messagePreviewSubChannel: 'messagePreviewSubChannel',
+
+  channelUnreadInfo: 'channelUnreadInfo',
+  subChannelUnreadInfo: 'subChannelUnreadInfo',
+
+  userEntityMarkers: 'channelMarker',
+  userFeedMarkers: 'subChannelMarker',
+  contentMarkers: 'messageMarker',
+  feedMarkers: 'feedMarker',
+  userMarkers: 'userMarker',
+
+  communities: 'community',
+  categories: 'category',
+  communityUsers: 'communityUsers',
+  posts: 'post',
+  postChildren: 'post',
+  comments: 'comment',
+  commentChildren: 'comment',
+  polls: 'poll',
+  reactors: 'reactor',
+  reactions: 'reaction',
+
+  videoStreamings: 'stream',
+  videoStreamingChildren: 'stream',
+  videoStreamModerations: 'streamModeration',
+
+  follows: 'follow',
+  followCounts: 'followCount',
+
+  feeds: 'feed',
+  ads: 'ad',
+  advertisers: 'advertiser',
+
+  pinTargets: 'pinTarget',
+  pins: 'pin',
+
+  notificationTrayItems: 'notificationTrayItem',
+
+  invitations: 'invitation',
+  joinRequests: 'joinRequest',
+};
+
+/** hidden */
+export const isOutdated = <T extends Amity.UpdatedAt>(prevData: T, nextData: T): boolean => {
+  // Check if the new value is outdated.
+  if ('updatedAt' in nextData && 'updatedAt' in prevData) {
+    return new Date(nextData.updatedAt!) < new Date(prevData.updatedAt!);
+  }
+
+  return false;
+};
+
+/** 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

@@ -0,0 +1,229 @@
+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.
+
+/**
+ * Filter a given collection with strict equality against a param
+ *
+ * @param collection the collection to filter
+ * @param key the key of the collection's items to challenge
+ * @param value the expected value
+ * @returns a filtered collection with items only matching the criteria
+ *
+ * @hidden
+ */
+export const filterByPropEquality = <T = Record<string, unknown>>(
+  collection: T[],
+  key: keyof T,
+  value: any,
+) =>
+  value !== undefined
+    ? collection.filter(item => JSON.stringify(item[key]) === JSON.stringify(value))
+    : collection;
+
+export const filterByStringComparePartially = <T = Record<string, unknown>>(
+  collection: T[],
+  key: keyof T,
+  value: any,
+) =>
+  value !== undefined
+    ? collection.filter(item => {
+        if (typeof item[key] === 'string' && typeof value === 'string') {
+          return String(item[key]).toLowerCase().match(value.toLowerCase());
+        }
+        return false;
+      })
+    : 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);
+
+export const filterByPropIntersection = <T extends Record<string, unknown>>(
+  collection: T[],
+  key: keyof T,
+  values: any[] | undefined,
+) => {
+  if (!values?.length) return collection;
+
+  return collection.filter(
+    item =>
+      Array.isArray(item[key]) && values.some(value => (item[key] as unknown[]).includes(value)),
+  );
+};
+
+/**
+ * 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 => {
+    // if channel is a community, only member user must receive realtime event
+    if (c.type === 'community') return true;
+
+    // get resolver for the channel by user
+    const channelUserCacheKey = getResolver('channelUsers')({
+      channelId: c.channelPublicId,
+      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.InternalPost>(
+  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.InternalPost>(
+  collection: T[],
+  dataTypes: Amity.PostLiveCollection['dataTypes'],
+): T[] => {
+  return collection.reduce((acc: T[], post: T) => {
+    // Check dataType for current post
+    if (dataTypes?.includes(post.dataType)) {
+      return [...acc, post];
+    }
+
+    if ((post?.children || []).length > 0) {
+      const childPost = pullFromCache<Amity.InternalPost>(['post', 'get', post.children[0]])?.data;
+      if (!dataTypes?.includes(childPost?.dataType)) return [...acc, post];
+      return acc;
+    }
+
+    return acc;
+  }, []);
+};
+
+/**
+ * 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.InternalUser['userId']; user?: Amity.InternalUser },
+>(
+  collection: T[],
+  searchTerm: string,
+): T[] => {
+  /*
+   * Search term should match regardless of the case.
+   * Hence, the flag "i", is passed to the created regex
+   */
+  const containsMatcher = new RegExp(searchTerm, 'i');
+
+  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

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