@amityco/ts-sdk 6.35.2 → 6.35.3-15135939.0

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,75 +0,0 @@
-export * from './idResolvers';
-export * from './identifyModel';
-export * from './localReferenceId';
-
-/**
- * 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',
-  videoStreamModerations: 'streamModeration',
-
-  follows: 'follow',
-  followCounts: 'followCount',
-
-  feeds: 'feed',
-  ads: 'ad',
-  advertisers: 'advertiser',
-
-  pinTargets: 'pinTarget',
-  pins: 'pin',
-};
-
-/** hidden */
-export const isOutdated = <T extends Amity.UpdatedAt>(prevData: T, nextData: T): boolean => {
-  if ('updatedAt' in nextData && 'updatedAt' in nextData) {
-    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/model/localReferenceId.ts

@@ -1,12 +0,0 @@
-/*
- * To check if an id is a local referenceId, the id must start with 'LOCAL_'.
- *
- * Example: LOCAL_155f5158-281a-4a9d-a445-9243138d2041
- *
- * @param id as string
- * @returns true if the id is a local referenceId, false otherwise
- */
-
-export const isLocalId = (id: string) => {
-  return id.startsWith('LOCAL_');
-};

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';

package/src/core/query/paging.ts

@@ -1,172 +0,0 @@
-import { decode, encode } from 'js-base64';
-
-/**
- * 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 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
- *
- * @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 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 object shaped as { data: T[] } & Amity.Pages
- *
- * @hidden
- */
-export const isPaged = <T extends unknown>(
-  payload: any,
-): payload is Amity.Paged<T, any> & { paging?: Amity.Pagination['paging'] } => {
-  return (
-    payload?.hasOwnProperty('data') &&
-    payload?.hasOwnProperty('nextPage') &&
-    payload?.hasOwnProperty('prevPage')
-  );
-};
-
-/**
- * Converts a paging object into a b64 string token
- *
- * @param paging the sdk-friendly paging object
- * @param style the style of token to produce
- * @returns a backend's b64 encoded token
- *
- * @hidden
- */
-export const toToken = (
-  paging: Amity.Page | Amity.PageRaw | undefined,
-  style: Amity.PaginationStyles,
-): Amity.Token | undefined => {
-  if (!paging || !Object.keys(paging).length) return;
-
-  let payload = {};
-
-  // TODO: refactor this clean
-  if (style === 'skiplimit') {
-    payload = {
-      skip: paging.after ?? 0,
-      limit: paging.limit,
-    };
-  } 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 (paging?.before) {
-      payload = {
-        ...payload,
-        before: paging.before,
-      };
-    }
-    if (paging?.after) {
-      payload = {
-        ...payload,
-        after: paging.after,
-      };
-    }
-    if (!Number.isNaN(Number(paging?.limit))) {
-      payload = {
-        ...payload,
-        limit: paging.limit,
-      };
-    }
-  } else if (style === 'afterbeforeraw') {
-    payload = paging;
-  }
-
-  // avoid sending {} as it seems backend flips when we do
-  if (!Object.keys(payload).length) return;
-
-  // don't try catch, let it throw
-  return encode(JSON.stringify(payload));
-};
-
-/**
- * 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 toPage = (token?: Amity.Token): Amity.Page | undefined => {
-  if (!token) return undefined;
-
-  // don't try catch, let it throw
-  const json = JSON.parse(decode(token));
-
-  if (isSkip(json)) {
-    return {
-      after: json.skip,
-      limit: json.limit!,
-    } as Amity.NextPage<number>;
-  }
-  if (isAfterBefore(json)) {
-    if ('before' in json) {
-      return {
-        before: json.before,
-        limit: json.last,
-      } as Amity.PrevPage<number>;
-    }
-
-    if ('after' in json) {
-      return {
-        after: json.after,
-        limit: json.first,
-      } as Amity.NextPage<number>;
-    }
-  }
-
-  return undefined;
-};
-
-/**
- * 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 | undefined => {
-  if (!token) return undefined;
-
-  // don't try catch, let it throw
-  const json = JSON.parse(decode(token));
-
-  if (isAfterBeforeRaw(json)) {
-    return json as Amity.PageRaw;
-  }
-
-  return undefined;
-};