@amityco/ts-sdk-react-native 6.7.1-80c1951.0

package/src/core/events.ts

@@ -0,0 +1,133 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import mitt from 'mitt';
+
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { scheduleTask } from './microtasks';
+
+// need to sync up the list
+const WS_EVENTS = [
+  'disconnected',
+  'error',
+  'connect_error',
+  'reconnect_error',
+  'reconnect_failed',
+  'sessionStateChange',
+  // for internal use by accessTokenExpiryWatcher
+  'tokenExpired',
+] as const;
+
+const MQTT_EVENTS = [
+  'connect',
+  'message',
+  'disconnect',
+  'error',
+  'close',
+  'end',
+  'reconnect',
+
+  'user.didGlobalBan',
+] as const;
+
+/** @hidden */
+export const createEventEmitter = () => {
+  return mitt<Amity.Events>();
+};
+
+/**
+ * Wraps the websocket events into the client's event emitter for
+ * abstraction of transport.
+ *
+ * @param ws A websocket connection to listen from
+ * @param emitter An event emitter to wire the events to
+ *
+ * @category Transport
+ * @hidden
+ */
+export const proxyWebsocketEvents = (ws: Amity.Client['ws'], emitter: Amity.Client['emitter']) => {
+  WS_EVENTS.forEach(event => {
+    ws.on(event, (param: Amity.Events[typeof event]) => {
+      emitter.emit(event, param);
+    });
+  });
+};
+
+export const proxyMqttEvents = (
+  mqttClient: Amity.Client['mqtt'],
+  emitter: Amity.Client['emitter'],
+) => {
+  MQTT_EVENTS.forEach(event => {
+    mqttClient.on(event, (...params: any[]) => {
+      emitter.emit(event, params.length === 1 ? params[0] : params);
+    });
+  });
+
+  // @ts-ignore
+  mqttClient.on('message', (topic: string, payload: Buffer) => {
+    const message = JSON.parse(payload.toString());
+    emitter.emit(message.eventType, message.data);
+  });
+};
+
+/**
+ * Standardize the subscription of SSE through web sockets
+ *
+ * @param client The current client for which to subscribe the event to
+ * @param namespace A unique name for the logger
+ * @param event The websocket event name
+ * @param fn A wrapper for the callback.
+ * @returns A dispose function to unsubscribe to the event
+ *
+ * @category Transport
+ * @hidden
+ */
+export const createEventSubscriber = <T extends keyof Amity.Events>(
+  client: Amity.Client,
+  namespace: string,
+  event: T,
+  fn: Amity.Listener<Amity.Events[T]>,
+): Amity.Unsubscriber => {
+  const { log, emitter } = client;
+
+  const timestamp = Date.now();
+  log(`${namespace}(tmpid: ${timestamp}) > listen`);
+
+  const handler = (...payload: Parameters<typeof fn>) => {
+    log(`${namespace}(tmpid: ${timestamp}) > trigger`, payload);
+    fn(...payload);
+  };
+
+  emitter.on(event, handler);
+
+  return () => {
+    log(`${namespace}(tmpid: ${timestamp}) > dispose`);
+    emitter.off(event, handler);
+  };
+};
+
+export const createMqttMessageSubscriber = <T extends keyof Amity.Events>(
+  client: Amity.Client,
+  namespace: string,
+  event: T,
+  fn: (params: Record<string, unknown>) => void,
+): Amity.Unsubscriber => {
+  return createEventSubscriber(client, namespace, 'message', ([topic, message]) => {
+    const payload = JSON.parse(message.toString());
+
+    if (payload.eventType === event) {
+      fn(payload.data);
+    }
+  });
+};
+
+/**
+ * Wrapper around dispatch event
+ *
+ * @hidden
+ */
+export const fireEvent = <T extends keyof Amity.Events>(event: T, payload: Amity.Events[T]) => {
+  const { emitter } = getActiveClient();
+  scheduleTask(() => {
+    emitter.emit(event, payload);
+  });
+};

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,54 @@
+/**
+ * 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: ({ channelId }) => channelId,
+  subChannel: ({ subChannelId }) => subChannelId,
+  channelUsers: ({ channelId, userId }) => `${channelId}#${userId}`,
+  message: ({ messageId }) => messageId,
+
+  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,
+  poll: ({ pollId }) => pollId,
+  reaction: ({ referenceType, referenceId }) => `${referenceType}#${referenceId}`,
+  reactor: ({ reactionId }) => reactionId,
+
+  stream: ({ streamId }) => streamId,
+
+  follow: ({ from, to }) => `${from}#${to}`,
+  followInfo: ({ userId }) => userId,
+  followCount: ({ userId }) => userId,
+
+  feed: ({ targetId, feedId }) => `${targetId}#${feedId}`,
+};
+
+/**
+ * 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,59 @@
+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',
+  reactors: 'reactor',
+  reactions: 'reaction',
+
+  videoStreamings: 'stream',
+
+  follows: 'follow',
+  followCounts: 'followCount',
+
+  feeds: 'feed',
+};
+
+/** 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/query/filtering.ts

@@ -0,0 +1,233 @@
+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 => {
+    // 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[] => {
+  /*
+   * 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';