@amityco/ts-sdk 7.10.1-c2a9783.0 → 7.10.1-ec1ce4a3.0

package/src/core/liveCollection/PaginationController.ts

@@ -1,71 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,28 +0,0 @@
-/* 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

@@ -1,78 +0,0 @@
-/**
- * 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

@@ -1,81 +0,0 @@
-/**
- * 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

@@ -1,81 +0,0 @@
-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

@@ -1,229 +0,0 @@
-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

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