@amityco/ts-sdk 0.0.1-e5fb0d2.0 → 0.0.1-e643f6f.0

package/src/post/events/onPostCreated.ts

@@ -1,8 +1,4 @@
-import { getActiveClient } from '~/client/api'
-import { createEventSubscriber } from '~/core/events'
-
-import { decoratePayload } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
+import { createPostEventSubscriber } from './utils';
 
 /**
  * ```js
@@ -12,28 +8,12 @@ import { ingestInCache } from '~/core/cache'
  * })
  * ```
  *
- * Fired when an {@link Amity.Post} has been created
+ * Fired when a {@link Amity.Post} has been created
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
  * @category Post Events
  */
-export const onPostCreated = (
-  callback: Amity.Listener<Amity.Post>
-): Amity.Unsubscriber => {
-  const client = getActiveClient()
-
-  const filter = (payload: Amity.PostPayload) => {
-    decoratePayload(payload)
-    ingestInCache(payload)
-    callback(payload.posts[0])
-  }
-
-  return createEventSubscriber(
-    client,
-    'message/onPostCreated',
-    'v3.post.didCreate',
-    filter
-  )
-}
+export const onPostCreated = (callback: Amity.Listener<Amity.Post>): Amity.Unsubscriber =>
+  createPostEventSubscriber('post.created', callback);

package/src/post/events/onPostDeclined.ts

@@ -0,0 +1,19 @@
+import { createPostEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onPostDeclined } from '@amityco/ts-sdk'
+ * const dispose = onPostDeclined(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Post} has been updated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+export const onPostDeclined = (callback: Amity.Listener<Amity.Post>): Amity.Unsubscriber =>
+  createPostEventSubscriber('post.declined', callback);

package/src/post/events/onPostDeleted.ts

@@ -1,8 +1,4 @@
-import { getActiveClient } from '~/client/api'
-import { createEventSubscriber } from '~/core/events'
-
-import { decoratePayload } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
+import { createPostEventSubscriber } from './utils';
 
 /**
  * ```js
@@ -12,28 +8,12 @@ import { ingestInCache } from '~/core/cache'
  * })
  * ```
  *
- * Fired when an {@link Amity.Post} has been deleted
+ * Fired when a {@link Amity.Post} has been deleted
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
  * @category Post Events
  */
-export const onPostDeleted = (
-  callback: Amity.Listener<Amity.Post>
-): Amity.Unsubscriber => {
-  const client = getActiveClient()
-
-  const filter = (payload: Amity.PostPayload) => {
-    decoratePayload(payload)
-    ingestInCache(payload)
-    callback(payload.posts[0])
-  }
-
-  return createEventSubscriber(
-    client,
-    'message/onPostDeleted',
-    'v3.post.didDelete',
-    filter
-  )
-}
+export const onPostDeleted = (callback: Amity.Listener<Amity.Post>): Amity.Unsubscriber =>
+  createPostEventSubscriber('post.deleted', callback);

package/src/post/events/onPostFlagged.ts

@@ -0,0 +1,19 @@
+import { createPostEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onPostFlagged } from '@amityco/ts-sdk'
+ * const dispose = onPostFlagged(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Post} has been flagged
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+export const onPostFlagged = (callback: Amity.Listener<Amity.Post>): Amity.Unsubscriber =>
+  createPostEventSubscriber('post.flagged', callback);

package/src/post/events/onPostReactionAdded.ts

@@ -0,0 +1,42 @@
+import { getActiveClient } from '~/client/api';
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { createEventSubscriber } from '~/core/events';
+import { preparePayloadForCache } from '~/reaction/utils';
+
+/**
+ * ```js
+ * import { onPostReactionAdded } from '@amityco/ts-sdk'
+ * const dispose = onPostReactionAdded(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Post} has been reacted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+export const onPostReactionAdded = (callback: Amity.Listener<Amity.Post>): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.Events['post.addReaction']) => {
+    if (!client.cache) {
+      callback(payload.posts[0]);
+    } else {
+      preparePayloadForCache('post.addReaction', payload);
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      const { reactor, ...postPayload } = payload;
+
+      ingestInCache(postPayload as Amity.ProcessedPostPayload);
+
+      const post = pullFromCache<Amity.Post>(['post', 'get', payload.posts[0].postId])!;
+
+      callback(post.data);
+    }
+  };
+
+  return createEventSubscriber(client, 'post.addReaction', 'post.addReaction', filter);
+};

package/src/post/events/onPostReactionRemoved.ts

@@ -0,0 +1,42 @@
+import { getActiveClient } from '~/client/api';
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { createEventSubscriber } from '~/core/events';
+import { preparePayloadForCache } from '~/reaction/utils';
+
+/**
+ * ```js
+ * import { onPostReactionRemoved } from '@amityco/ts-sdk'
+ * const dispose = onPostReactionRemoved(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a reaction has been removed from a {@link Amity.Post}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+export const onPostReactionRemoved = (callback: Amity.Listener<Amity.Post>): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.Events['post.removeReaction']) => {
+    if (!client.cache) {
+      callback(payload.posts[0]);
+    } else {
+      preparePayloadForCache('post.removeReaction', payload);
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      const { reactor, ...postPayload } = payload;
+
+      ingestInCache(postPayload as Amity.ProcessedPostPayload);
+
+      const post = pullFromCache<Amity.Post>(['post', 'get', payload.posts[0].postId])!;
+
+      callback(post.data);
+    }
+  };
+
+  return createEventSubscriber(client, 'post.removeReaction', 'post.removeReaction', filter);
+};

package/src/post/events/onPostUnflagged.ts

@@ -0,0 +1,19 @@
+import { createPostEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onPostUnflagged } from '@amityco/ts-sdk'
+ * const dispose = onPostUnflagged(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a flag has been removed from a {@link Amity.Post}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+export const onPostUnflagged = (callback: Amity.Listener<Amity.Post>): Amity.Unsubscriber =>
+  createPostEventSubscriber('post.unflagged', callback);

package/src/post/events/onPostUpdated.ts

@@ -1,8 +1,4 @@
-import { getActiveClient } from '~/client/api'
-import { createEventSubscriber } from '~/core/events'
-
-import { decoratePayload } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
+import { createPostEventSubscriber } from './utils';
 
 /**
  * ```js
@@ -12,28 +8,12 @@ import { ingestInCache } from '~/core/cache'
  * })
  * ```
  *
- * Fired when an {@link Amity.Post} has been updated
+ * Fired when a {@link Amity.Post} has been updated
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
  * @category Post Events
  */
-export const onPostUpdated = (
-  callback: Amity.Listener<Amity.Post>
-): Amity.Unsubscriber => {
-  const client = getActiveClient()
-
-  const filter = (payload: Amity.PostPayload) => {
-    decoratePayload(payload)
-    ingestInCache(payload)
-    callback(payload.posts[0])
-  }
-
-  return createEventSubscriber(
-    client,
-    'message/onPostUpdated',
-    'v3.post.didUpdate',
-    filter
-  )
-}
+export const onPostUpdated = (callback: Amity.Listener<Amity.Post>): Amity.Unsubscriber =>
+  createPostEventSubscriber('post.updated', callback);

package/src/post/events/tests/onPostApproved.test.ts

@@ -0,0 +1,33 @@
+import { onPostApproved } from '../onPostApproved';
+import { client, connectClient, disconnectClient, postPayload, post11 } from '~/utils/tests';
+
+describe('onPostApproved', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  test('it should got event after post approved', () => {
+    const callback = jest.fn();
+    const unsub = onPostApproved(callback);
+    client.emitter.emit('post.approved', 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 = onPostApproved(callback);
+
+    unsub();
+
+    client.emitter.emit('post.approved', postPayload);
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,33 @@
+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/post/events/tests/onPostDeclined.test.ts

@@ -0,0 +1,33 @@
+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/post/events/tests/onPostDeleted.test.ts

@@ -0,0 +1,33 @@
+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/post/events/tests/onPostFlagged.test.ts

@@ -0,0 +1,33 @@
+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/post/events/tests/onPostReactionAdded.test.ts

@@ -0,0 +1,40 @@
+import { onPostReactionAdded } from '../onPostReactionAdded';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  postPayload,
+  post11,
+  reaction11,
+} from '~/utils/tests';
+
+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: reaction11 });
+
+    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 = onPostReactionAdded(callback);
+
+    unsub();
+
+    client.emitter.emit('post.addReaction', { ...postPayload, reactor: reaction11 });
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,40 @@
+import { onPostReactionRemoved } from '../onPostReactionRemoved';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  postPayload,
+  post11,
+  reaction11,
+} from '~/utils/tests';
+
+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: reaction11 });
+
+    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: reaction11 });
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,33 @@
+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/post/events/tests/onPostUpdated.test.ts

@@ -0,0 +1,33 @@
+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/post/events/utils.ts

@@ -0,0 +1,54 @@
+import { getActiveClient } from '~/client/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { createEventSubscriber, fireEvent } from '~/core/events';
+import { queryCache, upsertInCache, pullFromCache } from '~/cache/api';
+import { prepareMembershipPayload } from '~/group/utils';
+
+export const createPostEventSubscriber = (
+  event: keyof Amity.MqttPostEvents,
+  callback: Amity.Listener<Amity.Post>,
+) => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.PostPayload) => {
+    if (!client.cache) {
+      callback(payload.posts[0]);
+    } else {
+      const { communities, ...others } = payload;
+
+      const data = prepareMembershipPayload(others, 'communityUsers');
+
+      ingestInCache(data);
+
+      if (communities?.[0] && !['post.updated'].includes(event)) {
+        fireEvent('community.updated', {
+          communities,
+          categories: [],
+          communityUsers: [],
+          feeds: [],
+          files: [],
+          users: [],
+        });
+      }
+
+      const post = pullFromCache<Amity.Post>(['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 }));
+      }
+
+      callback(post.data);
+    }
+  };
+
+  return createEventSubscriber(client, event, event, filter);
+};

package/src/post/observers/index.ts

@@ -1,2 +1,4 @@
-export * from './observePosts'
-export * from './observePost'
+export * from './observePosts';
+export * from './observePost';
+export * from './livePost';
+export * from './livePosts';