@amityco/ts-sdk 6.33.1 → 6.33.2-3719e72.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amityco/ts-sdk",
-  "version": "6.33.1",
+  "version": "6.33.2-3719e72.0",
   "license": "CC-BY-ND-4.0",
   "author": "amity.co <developers@amity.co> (https://amity.co)",
   "description": "Amity Social Cloud Typescript SDK",

package/src/@types/core/payload.ts

@@ -25,6 +25,7 @@ declare global {
       following: Amity.FollowingsPayload;
       blockUser: Amity.BlockedUserPayload;
       semanticSearchPost: Amity.SemanticSearchPostPayload;
+      semanticSearchCommunity: Amity.SemanticSearchCommunityPayload;
     };
 
     type UserPayload = {
@@ -336,6 +337,12 @@ declare global {
       polls: Amity.InternalPoll[];
     };
 
+    type SemanticSearchCommunityPayload = Amity.CommunityPayload & {
+      searchResult: { communityId: string; score: number }[];
+    };
+
+    type ProcessedSemanticSearchCommunityPayload = Amity.ProcessedCommunityPayload;
+
     type StoryBasePayload = {
       comments: Amity.InternalComment[];
       files: Amity.File[];

package/src/@types/domains/client.ts

@@ -36,8 +36,8 @@ declare global {
 
       log: Logger;
       http: AxiosInstance;
-      mqtt: Amity.MqttClient;
-      ws: SocketIOClient.Socket;
+      mqtt?: Amity.MqttClient;
+      ws?: SocketIOClient.Socket;
       emitter: Emitter<Amity.Events>;
 
       hasPermission: (permission: string) => Amity.PermissionChecker;

package/src/@types/domains/community.ts

@@ -1,3 +1,5 @@
+import { AmityCommunityMemberStatusFilter } from '~/communityRepository/constants';
+
 export const CommunityPostSettings = Object.freeze({
   ONLY_ADMIN_CAN_POST: 'ONLY_ADMIN_CAN_POST',
   ADMIN_REVIEW_POST_REQUIRED: 'ADMIN_REVIEW_POST_REQUIRED',
@@ -193,5 +195,27 @@ declare global {
       Amity.Community['communityId'],
       Pick<QuerySearchCommunityMembers, 'page'>
     >;
+
+    type QuerySemanticSearchCommunity = {
+      query: string;
+      categoryIds?: string[];
+      filter?: AmityCommunityMemberStatusFilter;
+      options?: {
+        limit?: number;
+        token?: string;
+      };
+      tags?: string[];
+    };
+
+    type SemanticSearchCommunityLiveCollection = Amity.LiveCollectionParams<
+      Omit<QuerySemanticSearchCommunity, 'page' | 'filter' | 'options'>
+    > & {
+      communityMembershipStatus?: AmityCommunityMemberStatusFilter;
+    };
+
+    type SemanticSearchCommunityLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.Community['communityId'], // communityId:score
+      QuerySemanticSearchCommunity
+    >;
   }
 }

package/src/client/api/createClient.ts

@@ -64,8 +64,18 @@ export const createClient = (
   const mqttEndpoint = apiEndpoint?.mqtt ?? computeUrl('mqtt', apiRegion);
 
   const http = createHttpTransport(httpEndpoint);
-  const ws = createWebsocketTransport(httpEndpoint);
-  const mqtt = createMqttTransport(mqttEndpoint);
+
+  const isGoogleBotOrInspectionTool =
+    typeof navigator !== 'undefined' &&
+    (/Googlebot/.test(navigator.userAgent) || /Google-InspectionTool/.test(navigator.userAgent));
+
+  let ws;
+  let mqtt;
+
+  if (!isGoogleBotOrInspectionTool) {
+    ws = createWebsocketTransport(httpEndpoint);
+    mqtt = createMqttTransport(mqttEndpoint);
+  }
 
   const emitter = createEventEmitter();
 

package/src/client/api/isConnected.ts

@@ -16,9 +16,12 @@ export const isConnected = (): boolean => {
   const client = getActiveClient();
   client.log('client/api/isConnected', client);
 
+  // if client is connected to ws, it means client is connected. If ws is undefined, it means ws is not used.
+  const isWsConnected = (client.ws && client.ws.connected) || !!client.ws;
+
   return !!(
     client.userId &&
     String(client.http.defaults.headers.common?.Authorization)?.length &&
-    client.ws.connected
+    isWsConnected
   );
 };

package/src/client/api/login.ts

@@ -125,7 +125,7 @@ export const login = async (
     // wire websocket events to our event emitter
     proxyWebsocketEvents(client.ws, client.emitter);
 
-    client.ws.open();
+    client.ws?.open();
 
     client.userId = user.userId;
 

package/src/client/api/logout.ts

@@ -22,11 +22,11 @@ export const logout = async (): Promise<boolean> => {
 
   client.log('client/api/disconnectClient');
 
-  if (client.mqtt.connected) {
+  if (client.mqtt && client.mqtt.connected) {
     client.mqtt.disconnect();
   }
 
-  if (client.ws.connected) {
+  if (client.ws && client.ws.connected) {
     client.ws.disconnect();
   }
 
@@ -47,8 +47,8 @@ export const logout = async (): Promise<boolean> => {
 
   client.emitter.all.clear();
   // FIXME: it removes listener in ws.ts, it breaks global ban event
-  client.ws.removeAllListeners();
-  client.mqtt.removeAllListeners();
+  client.ws?.removeAllListeners();
+  client.mqtt?.removeAllListeners();
   client.userId = undefined;
   client.token = undefined;
 
@@ -58,7 +58,8 @@ export const logout = async (): Promise<boolean> => {
     isGlobalBanned: false,
     isUserDeleted: false,
   };
-  client.ws.io.opts.query = { token: '' };
+
+  if (client.ws) client.ws.io.opts.query = { token: '' };
 
   if (typeof document !== 'undefined') {
     document.cookie = '_ascSession=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/;';

package/src/client/utils/modifyMqttConnection.ts

@@ -7,6 +7,8 @@ let mqttUserId: string;
 
 export async function modifyMqttConnection() {
   const { mqtt, emitter, token } = getActiveClient();
+  if (!mqtt) return;
+
   const accessToken = token?.accessToken ?? '';
 
   const user = getActiveUser();

package/src/client/utils/setClientToken.ts

@@ -31,7 +31,7 @@ export const setClientToken = async (params: Parameters<typeof getToken>[0]) =>
   };
 
   // manually setup the token for ws transport
-  client.ws.io.opts.query = { token: accessToken };
+  if (client.ws) client.ws.io.opts.query = { token: accessToken };
 
   client.token = { accessToken, issuedAt, expiresAt };
 

package/src/communityRepository/constants/index.ts

@@ -0,0 +1,5 @@
+export const enum AmityCommunityMemberStatusFilter {
+  ALL = 'all',
+  MEMBER = 'member',
+  NOT_MEMBER = 'notMember',
+}

package/src/communityRepository/index.ts

@@ -1,6 +1,7 @@
 export * from './api';
 export * from './events';
 export * from './observers';
+export * from './constants';
 
 export * as Moderation from './communityModeration';
 export * as Membership from './communityMembership';

package/src/communityRepository/observers/index.ts

@@ -5,3 +5,5 @@ export * from './getCommunities';
 export * from './getCommunity';
 export * from './getTrendingCommunities';
 export * from './getRecommendedCommunities';
+
+export * from './semanticSearchCommunities';

package/src/communityRepository/observers/semanticSearch/SemanticSearchCommunityLiveCollectionController.ts

@@ -0,0 +1,164 @@
+import hash from 'object-hash';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { SemanticSearchCommunityPaginationController } from './SemanticSearchCommunityPaginationController';
+import { SemanticSearchCommunityQueryStreamController } from './SemanticSearchCommunityQueryStreamController';
+import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionController';
+import {
+  onCommunityCreated,
+  onCommunityDeleted,
+  onCommunityUpdated,
+} from '~/communityRepository/events';
+
+import {
+  onCommunityJoined,
+  onCommunityLeft,
+  onLocalCommunityJoined,
+  onLocalCommunityLeft,
+  onCommunityUserChanged,
+} from '~/communityRepository/communityMembership';
+
+import { isNonNullable } from '~/utils';
+import { EnumCommunityActions } from './enums';
+import { prepareSemanticSearchCommunityPayload } from '~/communityRepository/utils/payload';
+
+import { getActiveClient } from '~/client';
+import { EnumCommunityMemberActions } from '~/communityRepository/communityMembership/observers/getMembers/enums';
+import { filterByCommunityMembership } from '~/core/query';
+
+export class SemanticSearchCommunityLiveCollectionController extends LiveCollectionController<
+  'semanticSearchCommunity',
+  Amity.SemanticSearchCommunityLiveCollection,
+  Amity.Community,
+  SemanticSearchCommunityPaginationController
+> {
+  private queryStreamController: SemanticSearchCommunityQueryStreamController;
+
+  private query: Amity.SemanticSearchCommunityLiveCollection;
+
+  constructor(
+    query: Amity.SemanticSearchCommunityLiveCollection,
+    callback: Amity.LiveCollectionCallback<Amity.Community>,
+  ) {
+    const queryStreamId = hash(query);
+    const cacheKey = ['community', 'collection', queryStreamId];
+    const paginationController = new SemanticSearchCommunityPaginationController(query);
+
+    super(paginationController, queryStreamId, cacheKey, callback);
+
+    this.query = query;
+
+    this.queryStreamController = new SemanticSearchCommunityQueryStreamController(
+      this.query,
+      this.cacheKey,
+      this.notifyChange.bind(this),
+      prepareSemanticSearchCommunityPayload,
+    );
+
+    this.callback = callback.bind(this);
+    this.loadPage({ initial: true });
+  }
+
+  protected setup() {
+    const collection = pullFromCache<Amity.SemanticSearchCommunityLiveCollectionCache>(
+      this.cacheKey,
+    )?.data;
+    if (!collection) {
+      pushToCache(this.cacheKey, {
+        data: [],
+        params: {},
+      });
+    }
+  }
+
+  protected async persistModel(
+    queryPayload: Amity.SemanticSearchCommunityPayload & Amity.Pagination,
+  ) {
+    await this.queryStreamController.saveToMainDB(queryPayload);
+  }
+
+  protected persistQueryStream({
+    response,
+    direction,
+    refresh,
+  }: Amity.LiveCollectionPersistQueryStreamParams<'semanticSearchCommunity'>) {
+    this.queryStreamController.appendToQueryStream(response, direction, refresh);
+  }
+
+  startSubscription() {
+    return this.queryStreamController.subscribeRTE([
+      { fn: onCommunityCreated, action: EnumCommunityActions.OnCommunityCreated },
+      { fn: onCommunityDeleted, action: EnumCommunityActions.OnCommunityDeleted },
+      { fn: onCommunityUpdated, action: EnumCommunityActions.OnCommunityUpdated },
+      { fn: onCommunityJoined, action: EnumCommunityMemberActions.OnCommunityJoined },
+      { fn: onCommunityLeft, action: EnumCommunityMemberActions.OnCommunityLeft },
+      { fn: onCommunityUserChanged, action: EnumCommunityMemberActions.OnMemberCountChanged },
+      { fn: onLocalCommunityJoined, action: EnumCommunityMemberActions.OnCommunityJoined },
+      { fn: onLocalCommunityLeft, action: EnumCommunityMemberActions.OnCommunityLeft },
+    ]);
+  }
+
+  notifyChange({ origin, loading, error }: Amity.LiveCollectionNotifyParams) {
+    const collection = pullFromCache<Amity.SemanticSearchCommunityLiveCollectionCache>(
+      this.cacheKey,
+    )?.data;
+    if (!collection) return;
+
+    const data = this.applyFilter(
+      collection.data
+        .map(communityIdWithScore => {
+          const [communityId, score] = communityIdWithScore.split(':');
+          return {
+            communityId,
+            score: parseFloat(score),
+          };
+        })
+        .sort((a, b) => b.score - a.score)
+        .map(
+          ({ communityId }) => pullFromCache<Amity.Community>(['community', 'get', communityId])!,
+        )
+        .filter(isNonNullable)
+        .map(({ data }) => data) ?? [],
+    );
+
+    if (!this.shouldNotify(data) && origin === 'event') return;
+
+    this.callback({
+      onNextPage: () => this.loadPage({ direction: Amity.LiveCollectionPageDirection.NEXT }),
+      data,
+      hasNextPage: !!this.paginationController.getNextToken(),
+      loading,
+      error,
+    });
+  }
+
+  applyFilter(data: Amity.Community[]) {
+    const { userId } = getActiveClient();
+
+    let communities = data;
+
+    if (this.query.categoryIds) {
+      communities = communities.filter(c =>
+        c.categoryIds?.some((id: string) => {
+          if (!this.query.categoryIds) return true;
+          if (this.query.categoryIds.length === 0) return true;
+
+          return this.query.categoryIds.includes(id);
+        }),
+      );
+    }
+
+    if (this.query.tags) {
+      communities = communities.filter(c => c.tags?.some(t => this.query.tags?.includes(t)));
+    }
+
+    if (this.query.communityMembershipStatus && userId) {
+      communities = filterByCommunityMembership(
+        communities,
+        this.query.communityMembershipStatus,
+        userId,
+      );
+    }
+
+    return communities;
+  }
+}

package/src/communityRepository/observers/semanticSearch/SemanticSearchCommunityPaginationController.ts

@@ -0,0 +1,36 @@
+import { AmityCommunityMemberStatusFilter } from '~/communityRepository/constants';
+import { PaginationController } from '~/core/liveCollection/PaginationController';
+import { COLLECTION_DEFAULT_PAGINATION_LIMIT } from '~/utils/constants';
+
+export class SemanticSearchCommunityPaginationController extends PaginationController<
+  'semanticSearchCommunity',
+  Amity.SemanticSearchCommunityLiveCollection
+> {
+  async getRequest(
+    queryParams: Amity.SemanticSearchCommunityLiveCollection,
+    token: string | undefined,
+  ) {
+    const {
+      limit = COLLECTION_DEFAULT_PAGINATION_LIMIT,
+      communityMembershipStatus,
+      ...params
+    } = queryParams;
+
+    const baseOptions = {
+      type: queryParams.limit ? 'pagination' : undefined,
+    };
+
+    const options = token ? { ...baseOptions, token } : { ...baseOptions, limit };
+
+    const { data: queryResponse } = await this.http.get<
+      Amity.SemanticSearchCommunityPayload & Amity.Pagination
+    >(`/api/v1/semantic-search/communities`, {
+      params: {
+        ...params,
+        filter: communityMembershipStatus ?? AmityCommunityMemberStatusFilter.ALL,
+        options,
+      },
+    });
+    return queryResponse;
+  }
+}

package/src/communityRepository/observers/semanticSearch/SemanticSearchCommunityQueryStreamController.ts

@@ -0,0 +1,86 @@
+import { QueryStreamController } from '~/core/liveCollection/QueryStreamController';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getActiveClient } from '~/client';
+// TODO: move emum to be the share value
+import { EnumCommunityActions } from './enums';
+import { EnumCommunityMemberActions } from '~/communityRepository/communityMembership/observers/getMembers/enums';
+import { prepareSemanticCommunitiesReferenceId } from './utils';
+
+export class SemanticSearchCommunityQueryStreamController extends QueryStreamController<
+  Amity.SemanticSearchCommunityPayload,
+  Amity.SemanticSearchCommunityLiveCollection
+> {
+  private notifyChange: (params: Amity.LiveCollectionNotifyParams) => void;
+
+  private preparePayload: (
+    response: Amity.SemanticSearchCommunityPayload,
+  ) => Amity.ProcessedSemanticSearchCommunityPayload;
+
+  constructor(
+    query: Amity.SemanticSearchCommunityLiveCollection,
+    cacheKey: string[],
+    notifyChange: (params: Amity.LiveCollectionNotifyParams) => void,
+    preparePayload: (
+      response: Amity.SemanticSearchCommunityPayload,
+    ) => Amity.ProcessedSemanticSearchCommunityPayload,
+  ) {
+    super(query, cacheKey);
+    this.notifyChange = notifyChange;
+    this.preparePayload = preparePayload;
+  }
+
+  async saveToMainDB(response: Amity.SemanticSearchCommunityPayload) {
+    const processedPayload = this.preparePayload(response);
+
+    const client = getActiveClient();
+    const cachedAt = client.cache && Date.now();
+
+    if (client.cache) {
+      ingestInCache(processedPayload, { cachedAt });
+    }
+  }
+
+  appendToQueryStream(
+    response: Amity.SemanticSearchCommunityPayload & Partial<Amity.Pagination>,
+    direction: Amity.LiveCollectionPageDirection,
+    refresh = false,
+  ) {
+    if (refresh) {
+      pushToCache(this.cacheKey, {
+        data: prepareSemanticCommunitiesReferenceId(response),
+      });
+    } else {
+      const collection = pullFromCache<Amity.CommunityLiveCollectionCache>(this.cacheKey)?.data;
+
+      const communities = collection?.data ?? [];
+
+      pushToCache(this.cacheKey, {
+        ...collection,
+        data: [...new Set([...communities, ...prepareSemanticCommunitiesReferenceId(response)])],
+      });
+    }
+  }
+
+  reactor(action: EnumCommunityActions | EnumCommunityMemberActions) {
+    return (community: Amity.Community) => {
+      const collection = pullFromCache<Amity.CommunityLiveCollectionCache>(this.cacheKey)?.data;
+      if (!collection) return;
+
+      collection.data = [...new Set([community.communityId, ...collection.data])];
+
+      pushToCache(this.cacheKey, collection);
+      this.notifyChange({ origin: Amity.LiveDataOrigin.EVENT, loading: false });
+    };
+    //
+  }
+
+  subscribeRTE(
+    createSubscriber: {
+      fn: (reactor: (community: Amity.Community) => void) => Amity.Unsubscriber;
+      action: EnumCommunityActions | EnumCommunityMemberActions;
+    }[],
+  ) {
+    return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+  }
+}

package/src/communityRepository/observers/semanticSearch/enums.ts

@@ -0,0 +1,5 @@
+export enum EnumCommunityActions {
+  OnCommunityCreated = 'onCommunityCreated',
+  OnCommunityDeleted = 'onCommunityDeleted',
+  OnCommunityUpdated = 'onCommunityUpdated',
+}

package/src/communityRepository/observers/semanticSearch/utils.ts

@@ -0,0 +1,16 @@
+export function prepareSemanticCommunitiesReferenceId(
+  response: Amity.SemanticSearchCommunityPayload,
+) {
+  return response.communities.map(community => {
+    const score = response.searchResult.find(
+      result => result.communityId === community.communityId,
+    )!;
+    return `${community.communityId}:${score}`;
+  });
+}
+
+export function getCommunityIdsFromCache(cacheData?: string[]) {
+  return (cacheData ?? []).map(communityIdWithScore => {
+    return communityIdWithScore.split(':')[0];
+  });
+}

package/src/communityRepository/observers/semanticSearchCommunities.ts

@@ -0,0 +1,42 @@
+import { getActiveClient } from '~/client/api';
+import { dropFromCache } from '~/cache/api';
+import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+import { SemanticSearchCommunityLiveCollectionController } from './semanticSearch/SemanticSearchCommunityLiveCollectionController';
+
+/**
+ * search posts by semantic search
+ *
+ * @returns the associated pinned post(s)
+ *
+ * @category Posts Live Collection
+ *
+ */
+export const semanticSearchCommunities = (
+  params: Amity.LiveCollectionParams<Amity.SemanticSearchCommunityLiveCollection>,
+  callback: Amity.LiveCollectionCallback<Amity.Community>,
+  config?: Amity.LiveCollectionConfig,
+) => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`semanticSearchCommunities(tmpid: ${timestamp}) > listen`);
+
+  const semanticSearchPostLiveCollection = new SemanticSearchCommunityLiveCollectionController(
+    params,
+    callback,
+  );
+  const disposers = semanticSearchPostLiveCollection.startSubscription();
+
+  const cacheKey = semanticSearchPostLiveCollection.getCacheKey();
+
+  disposers.push(() => dropFromCache(cacheKey));
+
+  return () => {
+    log(`semanticSearchCommunities(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/communityRepository/utils/payload.ts

@@ -101,3 +101,14 @@ export const prepareCommunityRequest = <
       typeof storySetting?.enableComment === 'boolean' ? storySetting.enableComment : true,
   };
 };
+
+export const prepareSemanticSearchCommunityPayload = ({
+  searchResult,
+  ...communityPayload
+}: Amity.SemanticSearchCommunityPayload): Amity.ProcessedSemanticSearchCommunityPayload => {
+  const processedCommunityPayload = prepareCommunityPayload(communityPayload);
+
+  return {
+    ...processedCommunityPayload,
+  };
+};

package/src/core/events.ts

@@ -50,7 +50,7 @@ export const createEventEmitter = () => {
  */
 export const proxyWebsocketEvents = (ws: Amity.Client['ws'], emitter: Amity.Client['emitter']) => {
   WS_EVENTS.forEach(event => {
-    ws.on(event, (param: Amity.Events[typeof event]) => {
+    ws?.on(event, (param: Amity.Events[typeof event]) => {
       emitter.emit(event, param);
     });
   });
@@ -61,7 +61,7 @@ export const proxyMqttEvents = (
   emitter: Amity.Client['emitter'],
 ) => {
   MQTT_EVENTS.forEach(event => {
-    mqttClient.on(event, (...params: any[]) => {
+    mqttClient?.on(event, (...params: any[]) => {
       emitter.emit(event, params.length === 1 ? params[0] : params);
     });
   });

package/src/core/subscription.ts

@@ -162,6 +162,8 @@ export function subscribeTopic(
   callback?: Amity.Listener<ASCError | void>,
 ): Amity.Unsubscriber {
   const { mqtt } = getActiveClient();
+  if (!mqtt) return () => null;
+
   modifyMqttConnection();
 
   return mqtt.subscribe(topic, callback);

package/src/core/transports/ws.ts

@@ -47,7 +47,7 @@ export const synchronousWSCall = async <T>(
   const { ws } = client;
 
   const value = await new Promise<T | undefined>((resolve, reject) => {
-    ws.emit(event, data, (response: Amity.Response<T>) => {
+    ws?.emit(event, data, (response: Amity.Response<T>) => {
       try {
         resolve(unwrapPayload(response));
       } catch (error) {