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

package/src/postRepository/events/tests/onPostCreated.test.ts

@@ -1,33 +0,0 @@
-import { onPostCreated } from '../onPostCreated';
-import { client, connectClient, disconnectClient, postPayload, post11 } from '~/utils/tests';
-
-describe('onPostCreated', () => {
-  beforeAll(async () => {
-    await connectClient();
-  });
-
-  afterAll(async () => {
-    await disconnectClient();
-  });
-
-  test('it should got event after post created', () => {
-    const callback = jest.fn();
-    const unsub = onPostCreated(callback);
-    client.emitter.emit('post.created', postPayload);
-
-    unsub();
-
-    expect(callback).toHaveBeenCalled();
-    expect(callback).toHaveBeenCalledWith(post11);
-  });
-
-  test('it should got nothing if we did unsubscribe before got event', () => {
-    const callback = jest.fn();
-    const unsub = onPostCreated(callback);
-
-    unsub();
-
-    client.emitter.emit('post.created', postPayload);
-    expect(callback).not.toHaveBeenCalled();
-  });
-});

package/src/postRepository/events/tests/onPostDeclined.test.ts

@@ -1,33 +0,0 @@
-import { onPostDeclined } from '../onPostDeclined';
-import { client, connectClient, disconnectClient, postPayload, post11 } from '~/utils/tests';
-
-describe('onPostDeclined', () => {
-  beforeAll(async () => {
-    await connectClient();
-  });
-
-  afterAll(async () => {
-    await disconnectClient();
-  });
-
-  test('it should got event after post declined', () => {
-    const callback = jest.fn();
-    const unsub = onPostDeclined(callback);
-    client.emitter.emit('post.declined', postPayload);
-
-    unsub();
-
-    expect(callback).toHaveBeenCalled();
-    expect(callback).toHaveBeenCalledWith(post11);
-  });
-
-  test('it should got nothing if we did unsubscribe before got event', () => {
-    const callback = jest.fn();
-    const unsub = onPostDeclined(callback);
-
-    unsub();
-
-    client.emitter.emit('post.declined', postPayload);
-    expect(callback).not.toHaveBeenCalled();
-  });
-});

package/src/postRepository/events/tests/onPostDeleted.test.ts

@@ -1,33 +0,0 @@
-import { onPostDeleted } from '../onPostDeleted';
-import { client, connectClient, disconnectClient, postPayload, post11 } from '~/utils/tests';
-
-describe('onPostDeleted', () => {
-  beforeAll(async () => {
-    await connectClient();
-  });
-
-  afterAll(async () => {
-    await disconnectClient();
-  });
-
-  test('it should got event after post deleted', () => {
-    const callback = jest.fn();
-    const unsub = onPostDeleted(callback);
-    client.emitter.emit('post.deleted', postPayload);
-
-    unsub();
-
-    expect(callback).toHaveBeenCalled();
-    expect(callback).toHaveBeenCalledWith(post11);
-  });
-
-  test('it should got nothing if we did unsubscribe before got event', () => {
-    const callback = jest.fn();
-    const unsub = onPostDeleted(callback);
-
-    unsub();
-
-    client.emitter.emit('post.deleted', postPayload);
-    expect(callback).not.toHaveBeenCalled();
-  });
-});

package/src/postRepository/events/tests/onPostFlagged.test.ts

@@ -1,33 +0,0 @@
-import { onPostFlagged } from '../onPostFlagged';
-import { client, connectClient, disconnectClient, postPayload, post11 } from '~/utils/tests';
-
-describe('onPostFlagged', () => {
-  beforeAll(async () => {
-    await connectClient();
-  });
-
-  afterAll(async () => {
-    await disconnectClient();
-  });
-
-  test('it should got event after post flagged', () => {
-    const callback = jest.fn();
-    const unsub = onPostFlagged(callback);
-    client.emitter.emit('post.flagged', postPayload);
-
-    unsub();
-
-    expect(callback).toHaveBeenCalled();
-    expect(callback).toHaveBeenCalledWith(post11);
-  });
-
-  test('it should got nothing if we did unsubscribe before got event', () => {
-    const callback = jest.fn();
-    const unsub = onPostFlagged(callback);
-
-    unsub();
-
-    client.emitter.emit('post.flagged', postPayload);
-    expect(callback).not.toHaveBeenCalled();
-  });
-});

package/src/postRepository/events/tests/onPostReactionAdded.test.ts

@@ -1,41 +0,0 @@
-import {
-  client,
-  connectClient,
-  disconnectClient,
-  postPayload,
-  post11,
-  reactor11,
-} from '~/utils/tests';
-
-import { onPostReactionAdded } from '../onPostReactionAdded';
-
-describe('onPostReactionAdded', () => {
-  beforeAll(async () => {
-    await connectClient();
-  });
-
-  afterAll(async () => {
-    await disconnectClient();
-  });
-
-  test('it should got event after add reaction to post', () => {
-    const callback = jest.fn();
-    const unsub = onPostReactionAdded(callback);
-    client.emitter.emit('post.addReaction', { ...postPayload, reactor: reactor11 });
-
-    unsub();
-
-    expect(callback).toHaveBeenCalled();
-    expect(callback).toHaveBeenCalledWith({ ...post11, myReactions: [reactor11.reactionName] });
-  });
-
-  test('it should got nothing if we did unsubscribe before got event', () => {
-    const callback = jest.fn();
-    const unsub = onPostReactionAdded(callback);
-
-    unsub();
-
-    client.emitter.emit('post.addReaction', { ...postPayload, reactor: reactor11 });
-    expect(callback).not.toHaveBeenCalled();
-  });
-});

package/src/postRepository/events/tests/onPostReactionRemoved.test.ts

@@ -1,41 +0,0 @@
-import {
-  client,
-  connectClient,
-  disconnectClient,
-  postPayload,
-  post11,
-  reactor11,
-} from '~/utils/tests';
-
-import { onPostReactionRemoved } from '../onPostReactionRemoved';
-
-describe('onPostReactionRemoved', () => {
-  beforeAll(async () => {
-    await connectClient();
-  });
-
-  afterAll(async () => {
-    await disconnectClient();
-  });
-
-  test('it should got event after reaction got removed from post', () => {
-    const callback = jest.fn();
-    const unsub = onPostReactionRemoved(callback);
-    client.emitter.emit('post.removeReaction', { ...postPayload, reactor: reactor11 });
-
-    unsub();
-
-    expect(callback).toHaveBeenCalled();
-    expect(callback).toHaveBeenCalledWith(post11);
-  });
-
-  test('it should got nothing if we did unsubscribe before got event', () => {
-    const callback = jest.fn();
-    const unsub = onPostReactionRemoved(callback);
-
-    unsub();
-
-    client.emitter.emit('post.removeReaction', { ...postPayload, reactor: reactor11 });
-    expect(callback).not.toHaveBeenCalled();
-  });
-});

package/src/postRepository/events/tests/onPostUnflagged.test.ts

@@ -1,33 +0,0 @@
-import { onPostUnflagged } from '../onPostUnflagged';
-import { client, connectClient, disconnectClient, postPayload, post11 } from '~/utils/tests';
-
-describe('onPostUnflagged', () => {
-  beforeAll(async () => {
-    await connectClient();
-  });
-
-  afterAll(async () => {
-    await disconnectClient();
-  });
-
-  test('it should got event after post unflagged', () => {
-    const callback = jest.fn();
-    const unsub = onPostUnflagged(callback);
-    client.emitter.emit('post.unflagged', postPayload);
-
-    unsub();
-
-    expect(callback).toHaveBeenCalled();
-    expect(callback).toHaveBeenCalledWith(post11);
-  });
-
-  test('it should got nothing if we did unsubscribe before got event', () => {
-    const callback = jest.fn();
-    const unsub = onPostUnflagged(callback);
-
-    unsub();
-
-    client.emitter.emit('post.unflagged', postPayload);
-    expect(callback).not.toHaveBeenCalled();
-  });
-});

package/src/postRepository/events/tests/onPostUpdated.test.ts

@@ -1,33 +0,0 @@
-import { onPostUpdated } from '../onPostUpdated';
-import { client, connectClient, disconnectClient, postPayload, post11 } from '~/utils/tests';
-
-describe('onPostUpdated', () => {
-  beforeAll(async () => {
-    await connectClient();
-  });
-
-  afterAll(async () => {
-    await disconnectClient();
-  });
-
-  test('it should got event after post updated', () => {
-    const callback = jest.fn();
-    const unsub = onPostUpdated(callback);
-    client.emitter.emit('post.updated', postPayload);
-
-    unsub();
-
-    expect(callback).toHaveBeenCalled();
-    expect(callback).toHaveBeenCalledWith(post11);
-  });
-
-  test('it should got nothing if we did unsubscribe before got event', () => {
-    const callback = jest.fn();
-    const unsub = onPostUpdated(callback);
-
-    unsub();
-
-    client.emitter.emit('post.updated', postPayload);
-    expect(callback).not.toHaveBeenCalled();
-  });
-});

package/src/postRepository/events/utils.ts

@@ -1,163 +0,0 @@
-import { getActiveClient } from '~/client/api';
-import { ingestInCache } from '~/cache/api/ingestInCache';
-import { createEventSubscriber, fireEvent } from '~/core/events';
-import {
-  dropFromCache,
-  mergeInCache,
-  pullFromCache,
-  pushToCache,
-  queryCache,
-  upsertInCache,
-} from '~/cache/api';
-import { isInTombstone } from '~/cache/api/isInTombstone';
-import { preparePostPayload } from '~/postRepository/utils/payload';
-
-const processDeleteChildPost = (payload: Amity.PostPayload) => {
-  const post = payload.posts[0];
-  if (!post.parentId) {
-    // post is parent post => should mark child post as delete as well
-    post.children.forEach(childrenId =>
-      mergeInCache(['post', 'get', childrenId], {
-        isDeleted: true,
-      }),
-    );
-  } else {
-    // child post in a parent post
-    const parentPost = pullFromCache<Amity.InternalPost>(['post', 'get', post.parentPostId])?.data;
-
-    if (!parentPost) return;
-
-    pushToCache(['post', 'get', parentPost.postId], {
-      ...parentPost,
-      children: parentPost.children.filter(childId => childId !== post.postId),
-    });
-  }
-};
-
-const processCreateChildPost = (payload: Amity.PostPayload) => {
-  const post = payload.posts[0];
-  if (!post.parentId) return;
-
-  const parentPost = pullFromCache<Amity.InternalPost>(['post', 'get', post.parentPostId])?.data;
-
-  if (!parentPost) return;
-
-  pushToCache(['post', 'get', parentPost.postId], {
-    ...parentPost,
-    children: [...new Set([post.postId, ...parentPost.children])],
-  });
-};
-
-export const createPostEventSubscriber = (
-  event: keyof Amity.MqttPostEvents,
-  callback: Amity.Listener<Amity.InternalPost>,
-) => {
-  const client = getActiveClient();
-
-  const filter = (payload: Amity.PostPayload) => {
-    if (!client.cache) {
-      callback(payload.posts[0]);
-    } else {
-      const data = preparePostPayload(payload);
-
-      const { communities } = data;
-
-      // NOTE: The event data should be merge with existing cache rather than replace it
-      ingestInCache(data, undefined, false);
-
-      if (communities?.[0] && !['post.updated'].includes(event)) {
-        fireEvent('community.updated', {
-          communities,
-          categories: [],
-          communityUsers: data.communityUsers,
-          feeds: [],
-          files: [],
-          users: [],
-        });
-      }
-
-      if (event === 'post.deleted') {
-        const { postId, postedUserId } = payload.posts[0];
-
-        processDeleteChildPost(payload);
-
-        try {
-          isInTombstone('post', postId);
-        } catch (e) {
-          // Already in tombstone, skip to update client
-          return;
-        }
-
-        // If this post NOT BELONG to current user, let **put it to tombstone in all cases**
-        // For the case incoming post belong to current user, If from **different device will treat it as SOFT DELETE**
-        // But for same device if it is soft delete it just need to handle as update cache
-        // But if it is hard delete, it will pushed into tombstone before fire an event to BE. it means it will stay in tombstone already
-        // and will got skip to notify in a previous code block
-        if (postedUserId !== client.userId) {
-          dropFromCache(['post', 'get', postId]);
-        }
-
-        return callback(payload.posts[0]);
-      }
-
-      const post = pullFromCache<Amity.InternalPost>(['post', 'get', payload.posts[0].postId])!;
-
-      if (['post.created', 'post.approved', 'post.declined'].includes(event)) {
-        let queries = queryCache(['post', 'query'])
-          // @ts-ignore
-          ?.filter(({ key }) => key[2]?.targetId === post.data.targetId);
-
-        if (event === 'post.declined') {
-          // @ts-ignore
-          queries = queries?.filter(({ key }) => key[2]?.feedType === 'reviewing');
-        }
-
-        queries?.map(({ key, data }) => upsertInCache(key, data as any, { cachedAt: -1 }));
-      }
-
-      if (event === 'post.created') processCreateChildPost(payload);
-
-      callback(post.data);
-    }
-  };
-
-  return createEventSubscriber(client, event, event, filter);
-};
-
-export const createLocalPostEventSubscriber = (
-  event: keyof Omit<Amity.LocalPostEvents, 'local.post.addReaction' | 'local.post.removeReaction'>,
-  callback: Amity.Listener<Amity.InternalPost>,
-) => {
-  const client = getActiveClient();
-
-  const filter = (payload: Amity.PostPayload) => {
-    if (!client.cache) {
-      callback(payload.posts[0]);
-    } else {
-      const data = preparePostPayload(payload);
-
-      const { communities } = data;
-
-      ingestInCache(data);
-
-      if (communities?.[0] && !['local.post.updated'].includes(event)) {
-        fireEvent('community.updated', {
-          communities,
-          categories: [],
-          communityUsers: data.communityUsers,
-          feeds: [],
-          files: [],
-          users: [],
-        });
-      }
-
-      const post = pullFromCache<Amity.InternalPost>(['post', 'get', payload.posts[0].postId])!;
-
-      if (event === 'local.post.deleted') processDeleteChildPost(payload);
-
-      callback(post.data);
-    }
-  };
-
-  return createEventSubscriber(client, event, event, filter);
-};

package/src/postRepository/index.ts

@@ -1,3 +0,0 @@
-export * from './api';
-export * from './events';
-export * from './observers';

package/src/postRepository/internalApi/getPost.ts

@@ -1,65 +0,0 @@
-import { getActiveClient } from '~/client/api';
-
-import { pullFromCache } from '~/cache/api';
-import { ingestInCache } from '~/cache/api/ingestInCache';
-import { isInTombstone } from '~/cache/api/isInTombstone';
-import { checkIfShouldGoesToTombstone } from '~/cache/utils';
-import { pushToTombstone } from '~/cache/api/pushToTombstone';
-import { prepareMembershipPayload } from '~/group/utils';
-
-export const getPost = async (
-  postId: Amity.InternalPost['postId'],
-): Promise<Amity.Cached<Amity.InternalPost>> => {
-  const client = getActiveClient();
-  client.log('post/getPost', postId);
-
-  isInTombstone('post', postId);
-
-  let payload: Amity.PostPayload;
-
-  try {
-    // API-FIX: endpoint should not be /list, parameters should be querystring.
-    const response = await client.http.get<Amity.PostPayload>(
-      `/api/v3/posts/${encodeURIComponent(postId)}`,
-    );
-    payload = response.data;
-  } catch (error) {
-    if (checkIfShouldGoesToTombstone((error as Amity.ErrorResponse)?.code)) {
-      pushToTombstone('post', postId);
-    }
-
-    throw error;
-  }
-
-  const data = prepareMembershipPayload(payload, 'communityUsers');
-
-  const cachedAt = client.cache && Date.now();
-  if (client.cache) ingestInCache(data, { cachedAt });
-
-  const { posts } = data;
-
-  const result = posts.find(post => post.postId === postId)!;
-
-  return {
-    data: result,
-    cachedAt,
-  };
-};
-
-getPost.locally = (
-  postId: Amity.InternalPost['postId'],
-): Amity.Cached<Amity.InternalPost> | undefined => {
-  const client = getActiveClient();
-  client.log('post/getPost.locally', postId);
-
-  if (!client.cache) return;
-
-  const cached = pullFromCache<Amity.InternalPost>(['post', 'get', postId]);
-
-  if (!cached) return;
-
-  return {
-    data: cached.data,
-    cachedAt: cached.cachedAt,
-  };
-};

package/src/postRepository/internalApi/index.ts

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

package/src/postRepository/observers/enums.ts

@@ -1,11 +0,0 @@
-export enum EnumPostActions {
-  OnPostCreated = 'onPostCreated',
-  OnPostUpdated = 'onPostUpdated',
-  OnPostDeleted = 'onPostDeleted',
-  OnPostFlagged = 'onPostFlagged',
-  OnPostUnflagged = 'onPostUnflagged',
-  OnPostReactionAdded = 'onPostReactionAdded',
-  OnPostReactionRemoved = 'onPostReactionRemoved',
-  OnPostApproved = 'onPostApproved',
-  OnPostDeclined = 'onPostDeclined',
-}

package/src/postRepository/observers/getGlobalPinnedPosts/GlobalPinnedPostLiveCollectionController.ts

@@ -1,101 +0,0 @@
-import hash from 'object-hash';
-import { pullFromCache, pushToCache } from '~/cache/api';
-import { GlobalPinnedPostPaginationController } from './GlobalPinnedPostPaginationController';
-import { GlobalPinnedPostQueryStreamController } from './GlobalPinnedPostQueryStreamController';
-import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionController';
-import { isNonNullable } from '~/utils';
-import { LinkedObject } from '~/utils/linkedObject';
-import { onPostDeleted } from '~/postRepository/events';
-import { EnumPostActions } from '../enums';
-import { onLocalPostDeleted } from '~/postRepository/events/onLocalPostDeleted';
-import { generateCommentSubscriptions } from '../utils';
-
-export class GlobalPinnedPostLiveCollectionController extends LiveCollectionController<
-  'pinnedPost',
-  Amity.GlobalPinnedPostLiveCollection,
-  Amity.PinnedPost,
-  GlobalPinnedPostPaginationController
-> {
-  private queryStreamController: GlobalPinnedPostQueryStreamController;
-
-  private query: Amity.GlobalPinnedPostLiveCollection;
-
-  constructor(
-    query: Amity.GlobalPinnedPostLiveCollection,
-    callback: Amity.LiveCollectionCallback<Amity.PinnedPost>,
-  ) {
-    const queryStreamId = hash(query);
-    const cacheKey = ['pinnedPosts', 'collection', queryStreamId];
-    const paginationController = new GlobalPinnedPostPaginationController(query);
-
-    super(paginationController, queryStreamId, cacheKey, callback);
-
-    this.query = query;
-    this.queryStreamController = new GlobalPinnedPostQueryStreamController(
-      this.query,
-      this.cacheKey,
-      this.notifyChange.bind(this),
-      response => response,
-    );
-
-    this.callback = callback.bind(this);
-    this.loadPage({ initial: true });
-  }
-
-  protected setup() {
-    const collection = pullFromCache<Amity.PostLiveCollectionCache>(this.cacheKey)?.data;
-    if (!collection) {
-      pushToCache(this.cacheKey, {
-        data: [],
-        params: {},
-      });
-    }
-  }
-
-  protected async persistModel(queryPayload: Amity.PinnedPostPayload & Amity.Pagination) {
-    await this.queryStreamController.saveToMainDB(queryPayload);
-  }
-
-  protected persistQueryStream({
-    response,
-    direction,
-    refresh,
-  }: Amity.LiveCollectionPersistQueryStreamParams<'pinnedPost'>) {
-    this.queryStreamController.appendToQueryStream(response, direction, refresh);
-  }
-
-  // eslint-disable-next-line class-methods-use-this
-  startSubscription() {
-    return this.queryStreamController.subscribeRTE([
-      { fn: onLocalPostDeleted, action: EnumPostActions.OnPostDeleted },
-      {
-        fn: onPostDeleted,
-        action: EnumPostActions.OnPostDeleted,
-      },
-      ...generateCommentSubscriptions({
-        cacheKey: this.cacheKey,
-        resolveId: id => `global#${id}`,
-      }),
-    ]);
-  }
-
-  notifyChange({ origin, loading, error }: Amity.LiveCollectionNotifyParams) {
-    const collection = pullFromCache<Amity.PinnedPostLiveCollectionCache>(this.cacheKey)?.data;
-    if (!collection) return;
-
-    const data = (
-      collection.data
-        .map(id => pullFromCache<Amity.InternalPin>(['pin', 'get', id])!)
-        .filter(isNonNullable)
-        .map(({ data }) => data) ?? []
-    ).map(LinkedObject.pinnedPost);
-
-    if (!this.shouldNotify(data) && origin === 'event') return;
-
-    this.callback({
-      data,
-      loading,
-      error,
-    });
-  }
-}

package/src/postRepository/observers/getGlobalPinnedPosts/GlobalPinnedPostPaginationController.ts

@@ -1,19 +0,0 @@
-import { PaginationController } from '~/core/liveCollection/PaginationController';
-import { COLLECTION_DEFAULT_PAGINATION_LIMIT } from '~/utils/constants';
-
-export class GlobalPinnedPostPaginationController extends PaginationController<
-  'pinnedPost',
-  Amity.GlobalPinnedPostLiveCollection
-> {
-  async getRequest(queryParams: Amity.GlobalPinnedPostLiveCollection, token: string | undefined) {
-    const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, ...params } = queryParams;
-
-    const path = '/api/v1/pinned-posts/global';
-
-    const { data: queryResponse } = await this.http.get<Amity.PinnedPostPayload & Amity.Pagination>(
-      path,
-    );
-
-    return queryResponse;
-  }
-}