@amityco/ts-sdk 0.0.1-cb052d5.0 → 0.0.1-cb5cdb1.0

package/src/subChannel/api/tests/deleteSubChannel.test.ts

@@ -0,0 +1,112 @@
+import { deleteSubChannel } from '../deleteSubChannel';
+import { onSubChannelDeleted } from '../../events';
+
+import { client, generateRawSubChannel } from '~/utils/tests';
+
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { ASCApiError } from '~/core/errors';
+
+const subChannelId = 'channelId11--sub-channel-id';
+
+describe('createSubChannel', () => {
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  // integration_test_id: 43ba1273-4560-4cea-93ce-cf5728b2a475
+  test('it should delete sub channel', async () => {
+    const rawSubChannel = generateRawSubChannel();
+    const rawDeleteSubChannel = generateRawSubChannel({ isDeleted: true });
+
+    // Mock for getSubChannel
+    client.http.get = jest.fn().mockResolvedValue({
+      data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] },
+    });
+
+    client.http.delete = jest.fn().mockResolvedValue({
+      data: {
+        messageFeeds: [rawDeleteSubChannel],
+        messages: [],
+        users: [],
+        files: [],
+      },
+    });
+
+    const result = await deleteSubChannel(subChannelId);
+    expect(result.isDeleted).toEqual(true);
+  });
+
+  // integration_test_id: 57ba785f-484b-4f19-aa38-18e0bd4ec433
+  test('it should return error 400400 when try to delete subChannel from invalid subChannelId', async () => {
+    const apiError = new ASCApiError(
+      'Feed not found',
+      Amity.ServerError.ITEM_NOT_FOUND,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    client.http.get = jest.fn().mockRejectedValue({
+      status: 404,
+      data: apiError,
+    });
+
+    try {
+      await deleteSubChannel(subChannelId);
+    } catch ({ status = null, data = null }) {
+      expect(status).toEqual(404);
+      expect(data).toEqual(apiError);
+    }
+  });
+
+  test('it should return a valid sub channel from cache', async () => {
+    const rawSubChannel = generateRawSubChannel();
+    const rawDeleteSubChannel = generateRawSubChannel({ isDeleted: true });
+
+    // Mock for getSubChannel
+    client.http.get = jest.fn().mockResolvedValue({
+      data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] },
+    });
+
+    client.http.delete = jest.fn().mockResolvedValue({
+      data: {
+        messageFeeds: [rawDeleteSubChannel],
+        messages: [],
+        users: [],
+        files: [],
+      },
+    });
+
+    await deleteSubChannel(subChannelId);
+
+    const cache = pullFromCache(['subChannel', 'get', subChannelId]);
+
+    expect(cache?.data).toEqual(expect.objectContaining({ isDeleted: true }));
+  });
+
+  test('should fire event `onChannelDeleted`', async () => {
+    let dispose;
+    const rawSubChannel = generateRawSubChannel();
+    const rawDeleteSubChannel = generateRawSubChannel({ isDeleted: true });
+
+    // Mock for getSubChannel
+    client.http.get = jest.fn().mockResolvedValue({
+      data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] },
+    });
+
+    client.http.delete = jest.fn().mockResolvedValue({
+      data: {
+        messageFeeds: [rawDeleteSubChannel],
+        messages: [],
+        users: [],
+        files: [],
+      },
+    });
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onSubChannelDeleted(resolve);
+    }).finally(dispose);
+
+    await deleteSubChannel(subChannelId);
+
+    await expect(callbackPromise).resolves.toEqual(expect.objectContaining({ isDeleted: true }));
+  });
+});

package/src/subChannel/api/tests/getSubChannel.test.ts

@@ -0,0 +1,97 @@
+import { getSubChannel } from '../getSubChannel';
+import { client, generateRawSubChannel } from '~/utils/tests';
+
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { ASCApiError } from '~/core/errors';
+import { onSubChannelFetched } from '../../events/onSubChannelFetched';
+
+const subChannelId = 'channelId11--sub-channel-id';
+
+const subChannelPayload = {
+  channelId: 'channelId11',
+  displayName: 'sub channel name',
+};
+
+describe('createSubChannel', () => {
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  // integration_test_id: 6f019056-921e-43e2-a426-dd5a96f2fdcf
+  test('it should return a valid sub channel', async () => {
+    const rawSubChannel = generateRawSubChannel();
+    client.http.get = jest.fn().mockResolvedValue({
+      data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] },
+    });
+
+    const { data } = await getSubChannel(subChannelId);
+
+    expect(data.channelId).toEqual(subChannelPayload.channelId);
+    expect(data.displayName).toEqual(subChannelPayload.displayName);
+    expect(data.subChannelId).toEqual(subChannelId);
+  });
+
+  // integration_test_id: 0dc440b6-b2bb-41fb-bbe8-1b2a4c71bffc
+  test('it should return error 400400 when try to get subChannel from invalid subChannelId', async () => {
+    const apiError = new ASCApiError(
+      'Feed not found',
+      Amity.ServerError.ITEM_NOT_FOUND,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    client.http.put = jest.fn().mockRejectedValue({
+      status: 404,
+      data: apiError,
+    });
+
+    try {
+      await getSubChannel(subChannelId);
+    } catch ({ status = null, data = null }) {
+      expect(status).toEqual(404);
+      expect(data).toEqual(apiError);
+    }
+  });
+
+  test('it should return a valid sub channel from cache', async () => {
+    const rawSubChannel = generateRawSubChannel();
+    client.http.put = jest.fn().mockResolvedValue({
+      data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] },
+    });
+
+    const { data } = await getSubChannel(subChannelId);
+
+    const cache = pullFromCache(['subChannel', 'get', subChannelId]);
+
+    expect(cache?.data).toEqual(data);
+  });
+
+  test('it should return a valid sub channel from locally cache', async () => {
+    const rawSubChannel = generateRawSubChannel();
+    client.http.put = jest.fn().mockResolvedValue({
+      data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] },
+    });
+
+    await getSubChannel(subChannelId);
+
+    const cache = pullFromCache(['subChannel', 'get', subChannelId]);
+    const locallyData = await getSubChannel.locally(subChannelId);
+
+    expect(cache?.data).toEqual(locallyData?.data);
+  });
+
+  test('should fire event `onSubChannelFetched`', async () => {
+    let dispose;
+    const rawSubChannel = generateRawSubChannel();
+    client.http.put = jest.fn().mockResolvedValue({
+      data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] },
+    });
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onSubChannelFetched(resolve);
+    }).finally(dispose);
+
+    const { data } = await getSubChannel(subChannelId);
+
+    await expect(callbackPromise).resolves.toMatchObject(data);
+  });
+});

package/src/subChannel/api/tests/getSubChannels.test.ts

@@ -0,0 +1,97 @@
+import { getSubChannels } from '../getSubChannels';
+import { client, generateRawSubChannel } from '~/utils/tests';
+
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { ASCApiError } from '~/core/errors';
+import { onSubChannelFetched } from '../../events/onSubChannelFetched';
+
+const subChannelId = 'channelId11--sub-channel-id';
+
+const subChannelPayload = {
+  channelId: 'channelId11',
+  displayName: 'sub channel name',
+};
+
+describe('createSubChannel', () => {
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  // integration_test_id: dc771f42-14b9-420e-999d-858151e8ce41
+  test('it should return a valid sub channel', async () => {
+    const rawSubChannel = generateRawSubChannel();
+    client.http.get = jest.fn().mockResolvedValue({
+      data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] },
+    });
+
+    const { data } = await getSubChannels([subChannelId]);
+
+    expect(data[0].channelId).toEqual(subChannelPayload.channelId);
+    expect(data[0].displayName).toEqual(subChannelPayload.displayName);
+    expect(data[0].subChannelId).toEqual(subChannelId);
+  });
+
+  // integration_test_id: 28710df0-e5b6-4e46-b1aa-440d5ea01995
+  test('it should return error 400400 when try to get subChannel from invalid subChannelId', async () => {
+    const apiError = new ASCApiError(
+      'Feed not found',
+      Amity.ServerError.ITEM_NOT_FOUND,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    client.http.get = jest.fn().mockRejectedValue({
+      status: 404,
+      data: apiError,
+    });
+
+    try {
+      await getSubChannels([subChannelId]);
+    } catch ({ status = null, data = null }) {
+      expect(status).toEqual(404);
+      expect(data).toEqual(apiError);
+    }
+  });
+
+  test('it should return a valid sub channel from cache', async () => {
+    const rawSubChannel = generateRawSubChannel();
+    client.http.get = jest.fn().mockResolvedValue({
+      data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] },
+    });
+
+    const { data } = await getSubChannels([subChannelId]);
+
+    const cache = pullFromCache(['subChannel', 'get', subChannelId]);
+
+    expect(cache?.data).toEqual(data[0]);
+  });
+
+  test('it should return a valid sub channel from locally cache', async () => {
+    const rawSubChannel = generateRawSubChannel();
+    client.http.get = jest.fn().mockResolvedValue({
+      data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] },
+    });
+
+    await getSubChannels([subChannelId]);
+
+    const cache = pullFromCache(['subChannel', 'get', subChannelId]);
+    const locallyData = await getSubChannels.locally([subChannelId]);
+
+    expect(cache?.data).toEqual(locallyData?.data[0]);
+  });
+
+  test('should fire event `onSubChannelFetched`', async () => {
+    let dispose;
+    const rawSubChannel = generateRawSubChannel();
+    client.http.get = jest.fn().mockResolvedValue({
+      data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] },
+    });
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onSubChannelFetched(resolve);
+    }).finally(dispose);
+
+    const { data } = await getSubChannels([subChannelId]);
+
+    await expect(callbackPromise).resolves.toMatchObject(data[0]);
+  });
+});

package/src/subChannel/api/tests/updateSubChannel.test.ts

@@ -0,0 +1,86 @@
+import { updateSubChannel } from '../updateSubChannel';
+import { client, generateRawSubChannel } from '~/utils/tests';
+
+import { onSubChannelUpdated } from '~/subChannel/events';
+
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { ASCApiError } from '~/core/errors';
+
+const subChannelId = 'channelId11--sub-channel-id';
+
+const subChannelPayload = {
+  channelId: 'channelId11',
+  displayName: 'sub channel name',
+};
+
+describe('createSubChannel', () => {
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  // integration_test_id: 9f50fa02-c26c-4666-8e8b-2d9076a3edd3
+  test('it should return a valid sub channel', async () => {
+    const rawSubChannel = generateRawSubChannel();
+    client.http.put = jest.fn().mockResolvedValue({
+      data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] },
+    });
+
+    const { data } = await updateSubChannel(subChannelId, subChannelPayload);
+
+    expect(data.channelId).toEqual(subChannelPayload.channelId);
+    expect(data.displayName).toEqual(subChannelPayload.displayName);
+    expect(data.subChannelId).toEqual(subChannelId);
+  });
+
+  // integration_test_id: 118f410c-5476-4c4e-9199-ac166da30840
+  test('it should return error 400400 when try to update subChannel from wrong sub channel Id', async () => {
+    const apiError = new ASCApiError(
+      'Feed not found',
+      Amity.ServerError.ITEM_NOT_FOUND,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    client.http.put = jest.fn().mockRejectedValue({
+      status: 404,
+      data: apiError,
+    });
+
+    try {
+      await updateSubChannel(subChannelId, {
+        displayName: 'sub channel name',
+      });
+    } catch ({ status = null, data = null }) {
+      expect(status).toEqual(404);
+      expect(data).toEqual(apiError);
+    }
+  });
+
+  test('it should return a valid sub channel from cache', async () => {
+    const rawSubChannel = generateRawSubChannel();
+    client.http.put = jest.fn().mockResolvedValue({
+      data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] },
+    });
+
+    const { data } = await updateSubChannel(subChannelId, subChannelPayload);
+
+    const cache = pullFromCache(['subChannel', 'get', subChannelId]);
+
+    expect(cache?.data).toEqual(data);
+  });
+
+  test('should fire event `onSubChannelUpdated`', async () => {
+    let dispose;
+    const rawSubChannel = generateRawSubChannel();
+    client.http.put = jest.fn().mockResolvedValue({
+      data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] },
+    });
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onSubChannelUpdated(resolve);
+    }).finally(dispose);
+
+    const { data } = await updateSubChannel(subChannelId, subChannelPayload);
+
+    await expect(callbackPromise).resolves.toMatchObject(data);
+  });
+});

package/src/subChannel/api/updateSubChannel.ts

@@ -0,0 +1,47 @@
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getActiveClient } from '~/client/api';
+import { fireEvent } from '~/core/events';
+import { prepareSubChannelPayload } from '../utils';
+
+/* begin_public_function
+  id: subchannel.update
+*/
+/**
+ * ```js
+ * import { updateSubChannel } from '@amityco/ts-sdk'
+ * const updated = await updateSubChannel(subChannelId, { name: 'foobar' })
+ * ```
+ *
+ * Updates an {@link Amity.SubChannel}
+ *
+ * @param subChannelId The ID of the {@link Amity.SubChannel} to edit
+ * @param patch The patch data to apply
+ * @returns the updated {@link Amity.SubChannel} object
+ *
+ * @category Channel API
+ * @async
+ */
+export const updateSubChannel = async (
+  subChannelId: Amity.SubChannel['subChannelId'],
+  patch: Patch<Amity.SubChannel, 'displayName'>,
+): Promise<Amity.Cached<Amity.SubChannel>> => {
+  const client = getActiveClient();
+  client.log('channel/updateSubChannel', subChannelId, patch);
+
+  const response = await client.http.put<Amity.SubChannelPayload>(
+    `/api/v5/message-feeds/${encodeURIComponent(subChannelId)}`,
+    { name: patch.displayName },
+  );
+  const data = prepareSubChannelPayload(response.data);
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  fireEvent('message-feed.updated', response.data);
+
+  return {
+    data: data.messageFeeds[0],
+    cachedAt,
+  };
+};
+/* end_public_function */

package/src/subChannel/events/index.ts

@@ -0,0 +1,3 @@
+export * from './onSubChannelCreated';
+export * from './onSubChannelUpdated';
+export * from './onSubChannelDeleted';

package/src/subChannel/events/onSubChannelCreated.ts

@@ -0,0 +1,32 @@
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+import { prepareSubChannelPayload } from '../utils';
+
+/**
+ * ```js
+ * import { onChannelSubCreated } from '@amityco/ts-sdk'
+ * const dispose = onSubChannelCreated(subChannel => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.SubChannel} have been created
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+export const onSubChannelCreated = (callback: Amity.Listener<Amity.SubChannel>) => {
+  const client = getActiveClient();
+
+  const filter = (rawPayload: Amity.SubChannelPayload) => {
+    const payload = prepareSubChannelPayload(rawPayload);
+
+    ingestInCache(payload);
+    callback(payload.messageFeeds[0]);
+  };
+
+  return createEventSubscriber(client, 'onSubChannelCreated', 'message-feed.created', filter);
+};

package/src/subChannel/events/onSubChannelDeleted.ts

@@ -0,0 +1,44 @@
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+import { prepareSubChannelPayload } from '../utils';
+
+/**
+ * ```js
+ * import { onSubChannelDeleted } from '@amityco/ts-sdk'
+ * const dispose = onSubChannelDeleted(subChannel => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.SubChannel} have been deleted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+export const onSubChannelDeleted = (callback: Amity.Listener<Amity.SubChannel>) => {
+  const client = getActiveClient();
+
+  const filter = (rawPayload: Amity.SubChannelPayload) => {
+    const payload = prepareSubChannelPayload(rawPayload);
+
+    ingestInCache(payload);
+    callback(payload.messageFeeds[0]);
+  };
+
+  const disposers = [
+    createEventSubscriber(client, 'onSubChannelDeleted', 'message-feed.deleted', filter),
+    createEventSubscriber(
+      client,
+      'local.message-feed.deleted',
+      'local.message-feed.deleted',
+      payload => callback(payload.messageFeeds[0]),
+    ),
+  ];
+
+  return () => {
+    disposers.forEach(fn => fn());
+  };
+};

package/src/subChannel/events/onSubChannelFetched.ts

@@ -0,0 +1,12 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+/** @hidden */
+export const onSubChannelFetched = (callback: Amity.Listener<Amity.SubChannel>) => {
+  return createEventSubscriber(
+    getActiveClient(),
+    'onSubChannelFetched',
+    'local.message-feed.fetched',
+    payload => callback(payload.messageFeeds[0]),
+  );
+};

package/src/subChannel/events/onSubChannelUpdated.ts

@@ -0,0 +1,32 @@
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+import { prepareSubChannelPayload } from '../utils';
+
+/**
+ * ```js
+ * import { onSubChannelUpdated } from '@amityco/ts-sdk'
+ * const dispose = onSubChannelUpdated(subChannel => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.SubChannel} have been updated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+export const onSubChannelUpdated = (callback: Amity.Listener<Amity.SubChannel>) => {
+  const client = getActiveClient();
+
+  const filter = (rawPayload: Amity.SubChannelPayload) => {
+    const payload = prepareSubChannelPayload(rawPayload);
+
+    ingestInCache(payload);
+    callback(payload.messageFeeds[0]);
+  };
+
+  return createEventSubscriber(client, 'onSubChannelUpdated', 'message-feed.updated', filter);
+};

package/src/subChannel/observers/index.ts

@@ -0,0 +1,2 @@
+export * from './liveSubChannel';
+export * from './liveSubChannels';

package/src/subChannel/observers/liveSubChannel.ts

@@ -0,0 +1,34 @@
+import { liveObject } from '~/utils/liveObject';
+import { getSubChannel } from '../api';
+import { onSubChannelDeleted, onSubChannelUpdated } from '../events';
+import { onSubChannelFetched } from '../events/onSubChannelFetched';
+
+/**
+ * ```js
+ * import { liveSubChannel } from '@amityco/ts-sdk';
+ *
+ * let subChannel;
+ *
+ * const unsubscribe = liveSubChannel(subChannelId, response => {
+ *   subChannel = response.data;
+ * });
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.SubChannel}
+ *
+ * @param subChannelId the ID of the message to observe
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the sub channel
+ *
+ * @category SubChannel Live Object
+ */
+export const liveSubChannel = (
+  subChannelId: Amity.SubChannel['subChannelId'],
+  callback: Amity.LiveObjectCallback<Amity.SubChannel>,
+): Amity.Unsubscriber => {
+  return liveObject(subChannelId, callback, 'subChannelId', getSubChannel, [
+    onSubChannelFetched,
+    onSubChannelUpdated,
+    onSubChannelDeleted,
+  ]);
+};