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

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.InternalCommunity) => {
+      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.InternalCommunity) => 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/observers/tests/getCommunities.test.ts

@@ -0,0 +1,216 @@
+import { disableCache, enableCache } from '~/cache/api';
+import {
+  communityQueryResponse,
+  communityQueryResponsePage2,
+  client,
+  connectClient,
+  disconnectClient,
+  pause,
+  communityUser11,
+  emptyCommunityPayload,
+} from '~/utils/tests';
+
+import { getCommunities } from '../getCommunities';
+import { prepareCommunityPayload } from '../../utils';
+
+const getSnapshot = (params?: Record<string, any>) => {
+  return {
+    data: [] as Amity.Community[],
+    loading: true,
+    error: undefined as any,
+    ...params,
+  };
+};
+
+const { paging, ...payload } = communityQueryResponse.data;
+
+const community1 = prepareCommunityPayload(payload).communities[0];
+const community2 = prepareCommunityPayload(payload).communities[1];
+
+describe('getCommunities', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  test('it should return community collection', async () => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(communityQueryResponse);
+
+    getCommunities({ includeDeleted: true }, callback);
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenNthCalledWith(1, expect.objectContaining(getSnapshot()));
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining(
+        getSnapshot({
+          data: prepareCommunityPayload(payload).communities,
+          loading: false,
+        }),
+      ),
+    );
+  });
+
+  test('it should return data from cache', async () => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(communityQueryResponse);
+
+    getCommunities({ includeDeleted: true }, () => undefined);
+    await pause();
+    getCommunities({ includeDeleted: true }, callback);
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining(
+        getSnapshot({
+          data: prepareCommunityPayload(payload).communities,
+        }),
+      ),
+    );
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining(
+        getSnapshot({
+          data: prepareCommunityPayload(payload).communities,
+          loading: false,
+        }),
+      ),
+    );
+  });
+
+  const filters: [string, Amity.CommunityLiveCollection, Amity.Community[]][] = [
+    ['not deleted', { includeDeleted: false }, [community2]],
+    ['categoryId', { categoryId: 'test-category-id', includeDeleted: true }, [community1]],
+    ['tagged', { tags: ['test-community-tag'], includeDeleted: true }, [community1]],
+  ];
+
+  test.each(filters)('it should filter by %s communities', async (filter, params, expected) => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(communityQueryResponse);
+
+    getCommunities(params, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+    // check if cache data returned (should be empty)
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(getSnapshot()));
+
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenCalledWith(
+      expect.objectContaining(
+        getSnapshot({
+          loading: false,
+          data: expected,
+        }),
+      ),
+    );
+  });
+
+  test('it should return method to fetch next page', async () => {
+    const callback = jest.fn();
+    client.http.get = jest
+      .fn()
+      .mockResolvedValue(communityQueryResponse)
+      .mockResolvedValueOnce(communityQueryResponsePage2);
+
+    getCommunities({ includeDeleted: true }, callback);
+    await pause();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback.mock.lastCall).toHaveLength(1);
+
+    const { onNextPage, hasNextPage } = callback.mock.lastCall[0];
+
+    expect(hasNextPage).toBe(true);
+    expect(onNextPage).toBeTruthy();
+
+    onNextPage();
+    await pause();
+
+    // 4 -> because 1 local & server call each per call (2)
+    expect(callback).toHaveBeenCalledTimes(4);
+    expect(callback).toHaveBeenNthCalledWith(
+      4,
+      expect.objectContaining(
+        getSnapshot({
+          loading: false,
+          data: prepareCommunityPayload(payload).communities,
+        }),
+      ),
+    );
+  });
+
+  describe('events', () => {
+    const newCommunityPayload = {
+      ...communityQueryResponse.data.communities[0],
+      communityId: 'new-community',
+      isDeleted: false,
+    };
+
+    const newCommunity = prepareCommunityPayload({
+      ...emptyCommunityPayload,
+      communities: [newCommunityPayload],
+    }).communities[0];
+
+    const communityPayload = {
+      ...emptyCommunityPayload,
+      communities: [communityQueryResponse.data.communities[0]],
+      communityUsers: [communityUser11],
+    };
+
+    const cases: [string, keyof Amity.Events, Amity.CommunityPayload, Amity.Community[]][] = [
+      [
+        'it should add new community to collection onCreate',
+        'community.created',
+        {
+          ...emptyCommunityPayload,
+          communities: [newCommunityPayload],
+        },
+        [newCommunity, community2],
+      ],
+      [
+        'it should update community in collection onUpdate',
+        'community.updated',
+        {
+          ...emptyCommunityPayload,
+          communities: [{ ...newCommunityPayload, communityId: community1.communityId }],
+        },
+        [{ ...newCommunity, communityId: community1.communityId }, community2],
+      ],
+      [
+        'it should remove community from collection onDelete',
+        'community.deleted',
+        communityPayload,
+        [community2],
+      ],
+    ];
+
+    test.each(cases)('%s', async (test, event, communityPayload, expected) => {
+      const callback = jest.fn();
+      client.http.get = jest.fn().mockResolvedValue(communityQueryResponse);
+
+      getCommunities({ includeDeleted: false }, callback);
+      await pause();
+
+      client.emitter.emit(event, communityPayload);
+      await pause();
+
+      expect(callback).toHaveBeenNthCalledWith(
+        3,
+        expect.objectContaining(
+          getSnapshot({
+            data: expected,
+            loading: false,
+          }),
+        ),
+      );
+    });
+  });
+});

package/src/communityRepository/observers/tests/getCommunity.test.ts

@@ -0,0 +1,147 @@
+import { disableCache, enableCache } from '~/cache/api';
+import {
+  pause,
+  client,
+  connectClient,
+  disconnectClient,
+  community11,
+  user11,
+  communityUser11,
+  communityUser12,
+} from '~/utils/tests';
+import { getFutureDate } from '~/core/model';
+
+import { getCommunity } from '../getCommunity';
+
+const { communityId } = community11;
+const response = {
+  data: {
+    communities: [community11],
+    communityUsers: [communityUser11],
+    files: [],
+    users: [user11],
+    categories: [],
+    feeds: [],
+  },
+};
+
+describe('getCommunity events', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  beforeEach(enableCache);
+  afterEach(disableCache);
+
+  const events: [string, keyof Amity.MqttCommunityEvents][] = [
+    ['it should get update on community.updated event', 'community.updated'],
+    ['it should get update on community.deleted event', 'community.deleted'],
+  ];
+
+  test.each(events)('%s', async (test, event) => {
+    const update =
+      event === 'community.updated'
+        ? {
+            ...community11,
+            displayName: 'updated-name',
+            updatedAt: getFutureDate(community11.updatedAt),
+          }
+        : {
+            ...community11,
+            isDeleted: true,
+            updatedAt: getFutureDate(community11.updatedAt),
+          };
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    const unsub = getCommunity(communityId, callback);
+    await pause();
+
+    client.emitter.emit(event, {
+      communities: [update],
+      communityUsers: [],
+      categories: [],
+      feeds: [],
+      users: [user11],
+      files: [],
+    });
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(3);
+    expect(callback).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({
+        data: update,
+        loading: false,
+      }),
+    );
+
+    unsub();
+  });
+
+  const communityUserEvents: [string, keyof Amity.MqttCommunityUserEvents][] = [
+    ['it should add user on community.joined event', 'community.joined'],
+    ['it should get update on community.left event', 'community.left'],
+    ['it should get update on community.userChanged event', 'community.userChanged'],
+    ['it should get update on community.userBanned event', 'community.userBanned'],
+    ['it should get update on community.userUnbanned event', 'community.userUnbanned'],
+  ];
+
+  test.each(communityUserEvents)('%s', async (test, event) => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    const community = {
+      ...community11,
+      updatedAt: getFutureDate(community11.updatedAt),
+    };
+    let communityUsers: Amity.RawMembership<'community'>[];
+    let communities: Amity.RawCommunity[];
+
+    switch (event) {
+      case 'community.userChanged':
+      case 'community.left':
+        communityUsers = [communityUser11];
+        communities = [{ ...community, isJoined: true }];
+        break;
+
+      case 'community.userBanned':
+        communities = [{ ...community, isJoined: true }];
+        communityUsers = [{ ...communityUser11, communityMembership: 'banned' }];
+        break;
+
+      case 'community.userUnbanned':
+        communityUsers = [communityUser11];
+        communities = [{ ...community, isJoined: true }];
+        break;
+
+      // community.joined
+      default:
+        communities = [community];
+        communityUsers = [communityUser12];
+    }
+
+    const unsub = getCommunity(communityId, callback);
+    await pause();
+
+    client.emitter.emit(event, {
+      communities,
+      communityUsers,
+      categories: [],
+      feeds: [],
+      users: [user11],
+      files: [],
+    });
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(3);
+    expect(callback).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({
+        data: communities[0],
+      }),
+    );
+
+    unsub();
+  });
+});

package/src/communityRepository/utils/communityQueryFilter.ts

@@ -0,0 +1,47 @@
+import {
+  filterByCommunityMembership,
+  filterByPropEquality,
+  sortByFirstCreated,
+  sortByLastCreated,
+} from '~/core/query';
+
+export const communityQueryFilter = (
+  data: Amity.Community[],
+  params: Amity.CommunityLiveCollection,
+  userId: string,
+): Amity.Community[] => {
+  let communities = data;
+
+  if (!params.includeDeleted) {
+    communities = filterByPropEquality(communities, 'isDeleted', false);
+  }
+
+  if (params.categoryId) {
+    communities = communities.filter(c => c.categoryIds?.includes(params.categoryId!));
+  }
+
+  if (params.tags) {
+    communities = communities.filter(c => c.tags?.some(t => params.tags?.includes(t)));
+  }
+
+  if (params.membership && userId) {
+    communities = filterByCommunityMembership(communities, params.membership, userId);
+  }
+
+  const sortBy = params.sortBy || 'lastCreated';
+
+  if (sortBy === 'lastCreated' || sortBy === 'firstCreated') {
+    communities = communities.sort(
+      sortBy === 'lastCreated' ? sortByLastCreated : sortByFirstCreated,
+    );
+  }
+
+  /*
+   * The server returns communities with empty | null displayName's first before
+   * returning sorted list of communities with displayNames
+   *
+   * This section needs to be updated as displayNames can be null as well
+   */
+
+  return communities;
+};

package/src/communityRepository/utils/communityWithMembership.ts

@@ -0,0 +1,52 @@
+import { pullFromCache } from '~/cache/api';
+import { getActiveUser } from '~/client/api/activeUser';
+
+/*
+ * verifies membership status
+ */
+function isMember(membership: Amity.Membership<'community'>['communityMembership']): boolean {
+  return membership !== 'none';
+}
+
+/*
+ * checks if currently logged in user is part of the community
+ */
+function isCurrentUserPartOfCommunity(
+  c: Amity.InternalCommunity,
+  m: Amity.Membership<'community'>,
+): boolean {
+  const { userId } = getActiveUser();
+
+  return c.communityId === m.communityId && m.userId === userId;
+}
+
+/*
+ * For mqtt events server will not send user specific data as it's broadcasted
+ * to multiple users and it also does not include communityUser
+ *
+ * Client SDK needs to check for the existing isJoined field in cache data before calculating.
+ * Althought this can be calculated, it's not scalable.
+ */
+export function updateMembershipStatus(
+  communities: Amity.RawCommunity[],
+  communityUsers: Amity.Membership<'community'>[],
+): Amity.InternalCommunity[] {
+  return communities.map(c => {
+    const cachedCommunity = pullFromCache<Amity.InternalCommunity>([
+      'community',
+      'get',
+      c.communityId,
+    ]);
+    if (cachedCommunity?.data && cachedCommunity?.data.hasOwnProperty('isJoined')) {
+      return {
+        ...cachedCommunity.data,
+        ...c,
+      };
+    }
+
+    const isJoined = communityUsers.some(
+      m => isCurrentUserPartOfCommunity(c, m) && isMember(m.communityMembership),
+    );
+    return { ...c, isJoined };
+  });
+}

package/src/communityRepository/utils/index.ts

@@ -0,0 +1 @@
+export * from './payload';