@amityco/ts-sdk 0.0.1-beta.2 → 0.0.1-beta.20

package/src/follow/events/utils.ts

@@ -0,0 +1,33 @@
+import { getActiveClient } from '~/client/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { createEventSubscriber } from '~/core/events';
+import { queryCache, upsertInCache } from '~/cache/api';
+
+export const createFollowEventSubscriber = (
+  event: keyof Amity.MqttFollowMessageEvents,
+  callback: Amity.Listener<Amity.FollowStatus>,
+) => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.FollowStatus) => {
+    if (!client.cache) {
+      callback(payload);
+    } else {
+      ingestInCache({ follows: [payload] });
+
+      const queries = [
+        ...(queryCache(['followers', 'query']) ?? []),
+        ...(queryCache(['followings', 'query']) ?? []),
+      ];
+
+      queries
+        // @ts-ignore
+        .filter(({ key }) => key[2].userId === payload.from || key[2].userId === payload.to)
+        .forEach(({ key, data }) => upsertInCache(key, data as any, { cachedAt: -1 }));
+
+      callback(payload);
+    }
+  };
+
+  return createEventSubscriber(client, event, event, filter);
+};

package/src/follow/observers/index.ts

@@ -0,0 +1,3 @@
+export * from './observeFollowInfo';
+export * from './observeFollowers';
+export * from './observeFollowings';

package/src/follow/observers/observeFollowInfo.ts

@@ -0,0 +1,64 @@
+import { getActiveClient } from '~/client/api';
+import { createQuery, runQuery, queryOptions } from '~/core/query';
+import { getFollowInfo } from '../api';
+import { onFollowInfoUpdated } from '../events';
+
+/**
+ * ```js
+ * import { observeFollowInfo } from '@amityco/ts-sdk'
+ *
+ * let followInfo = {}
+ * const dispose = observeFollowInfo(userId, updated => followInfo = updated)
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.FollowInfo}
+ *
+ * @param userId the ID of the user 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 post
+ *
+ * @category Follow Observer
+ */
+export const observeFollowInfo = <Events extends ['onFetch', 'onUpdate']>(
+  userId: Amity.User['userId'],
+  callback: Amity.ObjectListener<Amity.Snapshot<Amity.FollowInfo>, Events>,
+  policy: Amity.QueryPolicy = 'cache_then_server',
+): Amity.Unsubscriber => {
+  const { log } = getActiveClient();
+
+  const timestamp = Date.now();
+  log(`observeFollowInfo(tmpid: ${timestamp}) > listen`);
+
+  const router = (result: Amity.Snapshot<Amity.FollowInfo>, action: Events[number]) => {
+    if (callback instanceof Function) return callback(result);
+
+    if (action !== 'onFetch') callback.onEvent?.(action, result);
+
+    callback[action]?.(result);
+  };
+
+  const realtimeRouter = (result: Amity.Snapshot<Amity.FollowInfo>, action: Events[number]) => {
+    if (result.data?.userId !== userId) return;
+
+    router(result, action);
+  };
+
+  const disposers: Amity.Unsubscriber[] = [];
+
+  disposers.push(
+    onFollowInfoUpdated(data =>
+      realtimeRouter({ data, loading: false, origin: 'event' }, 'onUpdate'),
+    ),
+  );
+
+  runQuery(
+    createQuery(getFollowInfo, userId),
+    result => (result.data || result.error) && router(result, 'onFetch'),
+    queryOptions(policy),
+  );
+
+  return () => {
+    log(`observeFollowInfo(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/follow/observers/observeFollowers.ts

@@ -0,0 +1,77 @@
+import { getActiveClient } from '~/client/api';
+
+import {
+  onFollowerRequested,
+  onFollowRequestAccepted,
+  onFollowRequestDeclined,
+  onFollowRequestCanceled,
+  onUserFollowed,
+  onUserUnfollowed,
+  onFollowerDeleted,
+} from '../events';
+
+/**
+ * ```js
+ * import { observeFollowers } from '@amityco/ts-sdk'
+ *
+ * let followers = []
+ * const unsub = observeFollowers('userId', follower => merge(followers, follower))
+ * ```
+ *
+ * Observe all mutations on a list of followers {@link Amity.FollowStatus} for a given user
+ *
+ * @param userId the ID of the {@link Amity.User}
+ * @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 messages
+ *
+ * @category Follow Observer
+ */
+export const observeFollowers = <
+  Events extends [
+    'onRequested',
+    'onAccepted',
+    'onDeclined',
+    'onCanceled',
+    'onFollowed',
+    'onUnfollowed',
+    'onDeleted',
+  ],
+>(
+  userId: Amity.User['userId'],
+  callback: Amity.ObjectListener<Amity.FollowStatus, Events>,
+): Amity.Unsubscriber => {
+  const { log } = getActiveClient();
+
+  const timestamp = Date.now();
+  log(`observeFollowers(tmpid: ${timestamp}) > listen`);
+
+  const disposers: Amity.Unsubscriber[] = [];
+
+  const router = (status: Amity.FollowStatus, action: Events[number]) => {
+    if (status.from !== userId) {
+      return;
+    }
+
+    if (callback instanceof Function) {
+      return callback(status);
+    }
+
+    callback.onEvent?.(action, status);
+    callback[action]?.(status);
+  };
+
+  disposers.push(
+    onFollowerRequested(x => router(x, 'onRequested')),
+    onFollowRequestAccepted(x => router(x, 'onAccepted')),
+    onFollowRequestDeclined(x => router(x, 'onDeclined')),
+    onFollowRequestCanceled(x => router(x, 'onCanceled')),
+    onUserFollowed(x => router(x, 'onFollowed')),
+    onUserUnfollowed(x => router(x, 'onUnfollowed')),
+    onFollowerDeleted(x => router(x, 'onDeleted')),
+  );
+
+  return () => {
+    log(`observeFollowers(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/follow/observers/observeFollowings.ts

@@ -0,0 +1,77 @@
+import { getActiveClient } from '~/client/api';
+
+import {
+  onFollowerRequested,
+  onFollowRequestAccepted,
+  onFollowRequestDeclined,
+  onFollowRequestCanceled,
+  onUserFollowed,
+  onUserUnfollowed,
+  onFollowerDeleted,
+} from '../events';
+
+/**
+ * ```js
+ * import { observeFollowings } from '@amityco/ts-sdk'
+ *
+ * let followings = []
+ * const unsub = observeFollowers('userId', follower => merge(followings, following))
+ * ```
+ *
+ * Observe all mutations on a list of followings {@link Amity.FollowStatus} for a given user
+ *
+ * @param userId the ID of the {@link Amity.User}
+ * @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 messages
+ *
+ * @category Follow Observer
+ */
+export const observeFollowings = <
+  Events extends [
+    'onRequested',
+    'onAccepted',
+    'onDeclined',
+    'onCanceled',
+    'onFollowed',
+    'onUnfollowed',
+    'onDeleted',
+  ],
+>(
+  userId: Amity.User['userId'],
+  callback: Amity.ObjectListener<Amity.FollowStatus, Events>,
+): Amity.Unsubscriber => {
+  const { log } = getActiveClient();
+
+  const timestamp = Date.now();
+  log(`observeFollowings(tmpid: ${timestamp}) > listen`);
+
+  const disposers: Amity.Unsubscriber[] = [];
+
+  const router = (status: Amity.FollowStatus, action: Events[number]) => {
+    if (status.to !== userId) {
+      return;
+    }
+
+    if (callback instanceof Function) {
+      return callback(status);
+    }
+
+    callback.onEvent?.(action, status);
+    callback[action]?.(status);
+  };
+
+  disposers.push(
+    onFollowerRequested(x => router(x, 'onRequested')),
+    onFollowRequestAccepted(x => router(x, 'onAccepted')),
+    onFollowRequestDeclined(x => router(x, 'onDeclined')),
+    onFollowRequestCanceled(x => router(x, 'onCanceled')),
+    onUserFollowed(x => router(x, 'onFollowed')),
+    onUserUnfollowed(x => router(x, 'onUnfollowed')),
+    onFollowerDeleted(x => router(x, 'onDeleted')),
+  );
+
+  return () => {
+    log(`observeFollowings(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/index.ts

@@ -0,0 +1,67 @@
+// types
+import './@types';
+
+export * from './version';
+
+// sdk core
+export * from './core/query';
+export * from './core/subscription';
+export * from './cache/api';
+
+export * from './client/api';
+export * from './client/events';
+export { API_REGIONS } from './client/utils/endpoints';
+
+// asc core
+export * from './user/api';
+export * from './user/events';
+export * from './user/observers';
+
+export * from './file/api';
+export * from './file/observers';
+
+export * from './role/api';
+
+// // asc partials
+export * from './reaction/api';
+export * from './reaction/events';
+
+export * from './report/api';
+
+// // asc messaging
+export * from './channel/api';
+export * from './channel/events';
+export * from './channel/observers';
+
+export * from './message/api';
+export * from './message/events';
+export * from './message/observers';
+
+// // asc social
+export * from './community/api';
+export * from './community/events';
+export * from './community/observers';
+
+export * from './category/api';
+
+export * from './feed/api';
+
+export * from './follow/api';
+export * from './follow/events';
+export * from './follow/observers';
+
+export * from './post/api';
+export * from './post/events';
+export * from './post/observers';
+
+export * from './comment/api';
+export * from './comment/events';
+export * from './comment/observers';
+
+export * from './poll/api';
+
+export * from './stream/api';
+export * from './stream/events';
+
+// // external apis
+export * from './external/api';

package/src/message/api/createMessage.ts

@@ -0,0 +1,96 @@
+import { getActiveClient } from '~/client/api';
+
+import { upsertInCache, pullFromCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+
+/**
+ * ```js
+ * import { createMessage } from '@amityco/ts-sdk'
+ * const created = await createMessage({
+ *   channelId: 'foobar',
+ *   data: { text: 'hello world' }
+ * })
+ * ```
+ *
+ * Creates an {@link Amity.Message}
+ *
+ * @param bundle The data necessary to create a new {@link Amity.Message}
+ * @returns The newly created {@link Amity.Message}
+ *
+ * @category Message API
+ * @async
+ */
+export const createMessage = async <T extends Amity.MessageContentType>(
+  bundle: Pick<
+    Amity.Message<T>,
+    'channelId' | 'parentId' | 'type' | 'data' | 'metadata' | 'mentionees'
+  >,
+): Promise<Amity.Cached<Amity.Message>> => {
+  const client = getActiveClient();
+  client.log('user/createMessage', bundle);
+
+  const { data } = await client.http.post<Amity.MessagePayload>('/api/v3/messages', bundle);
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+  // no need for event, fired by server
+
+  const { messages } = data;
+
+  return {
+    data: messages[0],
+    cachedAt,
+  };
+};
+
+/**
+ * ```js
+ * import { createMessage } from '@amityco/ts-sdk'
+ * const created = createMessage.locally({
+ *   channelId: 'foobar',
+ *   data: { text: 'hello world' }
+ * })
+ * ```
+ *
+ * Creates an {@link Amity.Message} in cache
+ *
+ * @param bundle The data necessary to create a new {@link Amity.Message}
+ * @returns The newly created {@link Amity.Message}
+ *
+ * @category Message API
+ */
+createMessage.optimistically = (
+  bundle: Pick<
+    Amity.Message,
+    'channelId' | 'parentId' | 'type' | 'data' | 'metadata' | 'mentionees'
+  >,
+): Amity.Cached<Amity.Message> | undefined => {
+  const client = getActiveClient();
+  client.log('user/createMessage.locally', bundle);
+
+  if (!client.cache) return;
+
+  const channel = pullFromCache<Amity.Channel>(['channel', 'get', bundle.channelId]);
+
+  upsertInCache(['channel', 'get', bundle.channelId], {
+    ...channel?.data,
+    messageCount: (channel?.data.messageCount ?? 0) + 1,
+  });
+
+  const message = {
+    messageId: Math.random().toString(16),
+    userId: client.userId,
+    channelSegment: (channel?.data.messageCount ?? 0) + 1,
+    createdAt: new Date().toISOString(),
+    ...bundle,
+  } as Amity.Message;
+
+  pushToCache(['message', 'get', message.messageId], message, { cachedAt: -1 });
+  fireEvent('v3.message.didCreate', { messages: [message] });
+
+  return {
+    data: message,
+    cachedAt: -1,
+  };
+};

package/src/message/api/deleteMessage.ts

@@ -0,0 +1,76 @@
+import { getActiveClient } from '~/client/api';
+
+import { getMessage } from './getMessage';
+
+import { pullFromCache, upsertInCache } from '~/cache/api';
+import { fireEvent } from '~/core/events';
+
+/**
+ * ```js
+ * import { deleteMessage } from '@amityco/ts-sdk'
+ * const success = await deleteMessage('foobar')
+ * ```
+ *
+ * Delete a {@link Amity.Message}
+ *
+ * @param The ID of the {@link Amity.Message} to delete
+ * @return A success boolean if the {@link Amity.Message} was deleted
+ *
+ * @category Message API
+ * @async
+ */
+export const deleteMessage = async (
+  messageId: Amity.Message['messageId'],
+): Promise<Amity.Message> => {
+  const client = getActiveClient();
+  client.log('message/deleteMessage', messageId);
+
+  // API-FIX: This endpoint has not been implemented yet.
+  await client.http.delete<{ success: boolean }>(
+    `/api/v3/messages/${encodeURIComponent(messageId)}`,
+  );
+
+  const deleted = await getMessage(messageId);
+  // no need for event, fired by server
+
+  return deleted.data;
+};
+
+/**
+ * ```js
+ * import { deleteMessage } from '@amityco/ts-sdk'
+ * const success = deleteMessage.locally('foobar')
+ * ```
+ *
+ * Deletes a {@link Amity.Message}
+ *
+ * @param messageId The {@link Amity.Message} ID to delete
+ * @return A success boolean if the {@link Amity.Message} was deleted
+ *
+ * @category Message API
+ */
+deleteMessage.optimistically = (
+  messageId: Amity.Message['messageId'],
+): Amity.Cached<Amity.Message> | undefined => {
+  const client = getActiveClient();
+  client.log('message/deleteMessage', messageId);
+
+  const message = pullFromCache<Amity.Message>(['message', 'get', messageId]);
+
+  if (!message) return;
+
+  const cachedAt = -1;
+  const deleted: Amity.Message = {
+    ...message.data,
+    isDeleted: true,
+    updatedAt: new Date().toISOString(),
+  };
+
+  upsertInCache(['message', 'get', messageId], deleted, { cachedAt });
+  fireEvent('v3.message.didDelete', { messages: [deleted] });
+
+  return {
+    data: deleted,
+    cachedAt,
+  };
+};

package/src/message/api/getMessage.ts

@@ -0,0 +1,71 @@
+import { getActiveClient } from '~/client/api';
+
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { getMessage } from '@amityco/ts-sdk'
+ * const message = await getMessage('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Message} object
+ *
+ * @param messageId the ID of the {@link Amity.Message} to fetch
+ * @returns the associated {@link Amity.Message} object
+ *
+ * @category Message API
+ * @async
+ */
+export const getMessage = async (
+  messageId: Amity.Message['messageId'],
+): Promise<Amity.Cached<Amity.Message>> => {
+  const client = getActiveClient();
+  client.log('message/getMessage', messageId);
+
+  // API-FIX: endpoint should not be /list, parameters should be querystring.
+  const { data } = await client.http.get<Amity.MessagePayload>(
+    `/api/v3/messages/${encodeURIComponent(messageId)}`,
+  );
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const { messages } = data;
+
+  return {
+    data: messages.find(message => message.messageId === messageId)!,
+    cachedAt,
+  };
+};
+
+/**
+ * ```js
+ * import { getMessage } from '@amityco/ts-sdk'
+ * const message = getMessage.locally('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Message} object
+ *
+ * @param messageId the ID of the {@link Amity.Message} to fetch
+ * @returns the associated {@link Amity.Message} object
+ *
+ * @category Message API
+ */
+getMessage.locally = (
+  messageId: Amity.Message['messageId'],
+): Amity.Cached<Amity.Message> | undefined => {
+  const client = getActiveClient();
+  client.log('message/getMessage.locally', messageId);
+
+  if (!client.cache) return;
+
+  const cached = pullFromCache<Amity.Message>(['message', 'get', messageId]);
+
+  if (!cached) return;
+
+  return {
+    data: cached.data,
+    cachedAt: cached.cachedAt,
+  };
+};

package/src/message/api/getMessages.ts

@@ -0,0 +1,74 @@
+import { getActiveClient } from '~/client/api';
+
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { getMessages } from '@amityco/ts-sdk'
+ * const messages = await getMessages(['foo', 'bar'])
+ * ```
+ *
+ * Fetches a collection of {@link Amity.Message} objects
+ *
+ * @param messageIds the IDs of the {@link Amity.Message} to fetch
+ * @returns the associated collection of {@link Amity.Message} objects
+ *
+ * @category Message API
+ * @async
+ */
+export const getMessages = async (
+  messageIds: Amity.Message['messageId'][],
+): Promise<Amity.Cached<Amity.Message[]>> => {
+  const client = getActiveClient();
+  client.log('message/getMessages', messageIds);
+
+  // API-FIX: endpoint should not be /list, parameters should be querystring.
+  const { data } = await client.http.get<Amity.MessagePayload>(`/api/v3/messages/list`, {
+    params: { messageIds },
+  });
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  return {
+    data: data.messages,
+    cachedAt,
+  };
+};
+
+/**
+ * ```js
+ * import { getMessages } from '@amityco/ts-sdk'
+ * const messages = getMessages.locally(['foo', 'bar']) ?? []
+ * ```
+ *
+ * Fetches a collection of {@link Amity.Message} objects from cache
+ *
+ * @param messageIds the IDs of the {@link Amity.Message} to fetch
+ * @returns the associated collection of {@link Amity.Message} objects
+ *
+ * @category Message API
+ */
+getMessages.locally = (
+  messageIds: Amity.Message['messageId'][],
+): Amity.Cached<Amity.Message[]> | undefined => {
+  const client = getActiveClient();
+  client.log('message/getMessages.locally', messageIds);
+
+  if (!client.cache) return;
+
+  const cached = messageIds
+    .map(messageId => pullFromCache<Amity.Message>(['message', 'get', messageId])!)
+    .filter(Boolean);
+
+  const messages = cached.map(({ data }) => data);
+  const oldest = cached.sort((a, b) => (a.cachedAt! < b.cachedAt! ? -1 : 1))?.[0];
+
+  if (cached?.length < messageIds.length) return;
+
+  return {
+    data: messages,
+    cachedAt: oldest.cachedAt,
+  };
+};