@amityco/ts-sdk 0.0.1-003998f.0

package/src/file/api/deleteFile.ts

@@ -0,0 +1,31 @@
+import { getActiveClient } from '~/client/api';
+
+import { dropFromCache } from '~/cache/api';
+
+/**
+ * ```js
+ * import { deleteFile } from '@amityco/ts-sdk'
+ * const success = await deleteFile('foo')
+ * ```
+ *
+ * Deletes a {@link Amity.File}
+ *
+ * @param fileId The {@link Amity.File} ID to delete
+ * @return A success boolean if the {@link Amity.File} was deleted
+ *
+ * @category File API
+ * @async
+ */
+export const deleteFile = async (
+  fileId: Amity.File<any>['fileId'],
+): Promise<{ success: boolean }> => {
+  const client = getActiveClient();
+  client.log('file/deleteFile', fileId);
+
+  // API-FIX: payload is different than swagger docs!!
+  await client.http.delete<{ fileId: string }>(`/api/v3/files/${fileId}`);
+
+  dropFromCache(['file', 'get', fileId], true);
+
+  return { success: true };
+};

package/src/file/api/fileUrlWithSize.ts

@@ -0,0 +1,13 @@
+/**
+ * Allow to query a file url with a selected size
+ *
+ * @param fileUrl the file Url to decorate
+ * @param size one of the selected sizes
+ * @returns the computed url for the selected size
+ */
+export const fileUrlWithSize = (
+  fileUrl: Amity.File['fileUrl'],
+  size: 'small' | 'medium' | 'large' | 'full',
+) => {
+  return `${fileUrl}?size=${size}`;
+};

package/src/file/api/getFile.ts

@@ -0,0 +1,67 @@
+import { getActiveClient } from '~/client/api';
+
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { getFile } from '@amityco/ts-sdk'
+ * const file = await getFile('foo')
+ * ```
+ *
+ * Fetches a {@link Amity.File} object
+ *
+ * @param fileId the ID of the {@link Amity.File} to fetch
+ * @returns the associated {@link Amity.File} object
+ *
+ * @category File API
+ * @async
+ */
+export const getFile = async <T extends Amity.FileType = any>(
+  fileId: Amity.File<any>['fileId'],
+): Promise<Amity.Cached<Amity.File>> => {
+  const client = getActiveClient();
+  client.log('file/getFile', fileId);
+
+  const { data } = await client.http.get<Amity.FilePayload<T>>(`/api/v3/files/${fileId}`);
+
+  // API-FIX: backend bad serializer issue. it should be:
+  // const { files } = data
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache({ files: [data] }, { cachedAt });
+
+  return {
+    data,
+    cachedAt,
+  };
+};
+
+/**
+ * ```js
+ * import { getFile } from '@amityco/ts-sdk'
+ * const file = getFile.locally('foo')
+ * ```
+ *
+ * Fetches a {@link Amity.File} object from cache
+ *
+ * @param fileId the ID of the {@link Amity.File} to fetch
+ * @returns the associated {@link Amity.File} object
+ *
+ * @category File API
+ */
+getFile.locally = (fileId: Amity.File<any>['fileId']): Amity.Cached<Amity.File> | undefined => {
+  const client = getActiveClient();
+  client.log('file/getFile.locally', fileId);
+
+  if (!client.cache) return;
+
+  const cached = pullFromCache<Amity.File>(['file', 'get', fileId]);
+
+  if (!cached) return;
+
+  return {
+    data: cached.data,
+    cachedAt: cached.cachedAt,
+  };
+};

package/src/file/api/index.ts

@@ -0,0 +1,6 @@
+export * from './getFile';
+export * from './createFile';
+export * from './deleteFile';
+export * from './fileUrlWithSize';
+export * from './createVideo';
+export * from './createImage';

package/src/file/observers/index.ts

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

package/src/file/observers/observeFile.ts

@@ -0,0 +1,49 @@
+import { createQuery, runQuery } from '~/core/query/query';
+
+import { getActiveClient } from '~/client/api';
+
+import { getFile } from '../api';
+
+/**
+ * ```js
+ * import { observeFile } from '@amityco/ts-sdk'
+ *
+ * let file = {}
+ * const dispose = observeFile(fileId, updated => file = updated)
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.File}
+ *
+ * @param fileId the ID of the file 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 file
+ *
+ * @category File Observer
+ */
+export const observeFile = <Events extends ['onFetch']>(
+  fileId: string,
+  callback: Amity.ObjectListener<Amity.Snapshot<Amity.File>, Events>,
+): Amity.Unsubscriber => {
+  const { log } = getActiveClient();
+
+  const timestamp = Date.now();
+  log(`observeFile(tmpid: ${timestamp}) > listen`);
+
+  // wrapper function to make sure
+  const router = (result: Amity.Snapshot<Amity.File>, action: Events[number]) => {
+    // filter function
+    if (result.data?.fileId !== fileId) return;
+
+    if (callback instanceof Function) return callback(result);
+
+    if (action !== 'onFetch') callback.onEvent?.(action, result);
+
+    callback[action]?.(result);
+  };
+
+  runQuery(createQuery(getFile, fileId), result => result.data && router(result, 'onFetch'));
+
+  return () => {
+    log(`observeFile(tmpid: ${timestamp}) > dispose`);
+  };
+};

package/src/follow/api/acceptFollower.ts

@@ -0,0 +1,34 @@
+import { getActiveClient } from '~/client/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+
+/**
+ * ```js
+ * import { acceptFollower } from '@amityco/ts-sdk'
+ * await acceptFollower('foobar')
+ * ```
+ *
+ * Accept the follow request
+ *
+ * @param userId the ID of the {@link Amity.User} follower
+ * @returns A success boolean if the follow request was accepted
+ *
+ * @category Follow API
+ * @async
+ */
+export const acceptFollower = async (userId: Amity.User['userId']): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('follow/acceptFollower', userId);
+
+  const { data } = await client.http.post<Amity.FollowStatusPayload>(
+    `/api/v4/me/followers/${userId}`,
+  );
+
+  if (client.cache) {
+    ingestInCache(data);
+  }
+
+  fireEvent('follow.accepted', data);
+
+  return true;
+};

package/src/follow/api/declineFollower.ts

@@ -0,0 +1,34 @@
+import { getActiveClient } from '~/client/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+
+/**
+ * ```js
+ * import { declineFollower } from '@amityco/ts-sdk'
+ * await declineFollower('foobar')
+ * ```
+ *
+ * Decline the follow request or delete the follower
+ *
+ * @param userId the ID of the {@link Amity.User} follower
+ * @returns A success boolean if the follow request was decline
+ *
+ * @category Follow API
+ * @async
+ */
+export const declineFollower = async (userId: Amity.User['userId']): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('follow/declineFollower', userId);
+
+  const { data } = await client.http.delete<{ follows: Amity.FollowStatus[] }>(
+    `/api/v4/me/followers/${userId}`,
+  );
+
+  if (client.cache) {
+    ingestInCache(data);
+  }
+
+  fireEvent('follow.requestDeclined', data);
+
+  return true;
+};

package/src/follow/api/follow.ts

@@ -0,0 +1,41 @@
+import { getActiveClient } from '~/client/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+
+/**
+ * ```js
+ * import { follow } from '@amityco/ts-sdk'
+ * const status = await follow('foobar')
+ * ```
+ *
+ * Follow the user
+ *
+ * @param userId the ID of the {@link Amity.User}
+ * @returns the status {@link Amity.FollowStatus}
+ *
+ * @category Follow API
+ * @async
+ */
+export const follow = async (
+  userId: Amity.User['userId'],
+): Promise<Amity.Cached<Amity.FollowStatus>> => {
+  const client = getActiveClient();
+  client.log('follow/follow', userId);
+
+  const { data } = await client.http.post<Amity.FollowStatusPayload>(
+    `/api/v4/me/following/${userId}`,
+  );
+
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache) {
+    ingestInCache(data, { cachedAt });
+  }
+
+  fireEvent(data.follows[0].status === 'accepted' ? 'follow.created' : 'follow.requested', data);
+
+  return {
+    data: data.follows[0],
+    cachedAt,
+  };
+};

package/src/follow/api/getFollowInfo.ts

@@ -0,0 +1,86 @@
+import { getActiveClient } from '~/client/api';
+import { pullFromCache, pushToCache } from '~/cache/api';
+
+const getCacheKey = (userId: Amity.User['userId']) => [
+  'followInfo',
+  'get',
+  `${getActiveClient().userId}#${userId}`,
+];
+
+/**
+ * ```js
+ * import { getFollowInfo } from '@amityco/ts-sdk'
+ * const { data: followInfo } = await getFollowInfo('foobar')
+ * ```
+ *
+ * Fetches the number of followers, followings, pending requests and the follow status for current user
+ *
+ * @param userId the ID of the {@link Amity.User}
+ * @returns the associated {@link Amity.FollowInfo} object
+ *
+ * @category Follow API
+ * @async
+ */
+export const getFollowInfo = async (
+  userId: Amity.User['userId'],
+): Promise<Amity.Cached<Amity.FollowInfo>> => {
+  const client = getActiveClient();
+  client.log('follow/getFollowInfo', userId);
+
+  const { data } = await client.http.get<Amity.FollowInfoMePayload | Amity.FollowInfoPayload>(
+    client.userId === userId ? `/api/v4/me/followInfo` : `/api/v4/users/${userId}/followInfo`,
+  );
+
+  const cachedAt = client.cache && Date.now();
+  const followInfo =
+    'follows' in data
+      ? {
+          ...data.followCounts[0],
+          status: data.follows?.[0]?.status,
+        }
+      : data.followCounts[0];
+
+  if (client.cache) {
+    pushToCache(getCacheKey(userId), followInfo, { cachedAt });
+  }
+
+  return {
+    data: followInfo,
+    cachedAt,
+  };
+};
+
+/**
+ * ```js
+ * import { getFollowInfo } from '@amityco/ts-sdk'
+ * const { data: followInfo } = getFollowInfo.locally('foobar')
+ * ```
+ *
+ * Fetches the number of followers, followings, pending requests and the follow status for current user from cache
+ *
+ * @param userId the ID of the {@link Amity.User}
+ * @returns the associated {@link Amity.FollowInfo} object
+ *
+ * @category Follow API
+ */
+getFollowInfo.locally = (
+  userId: Amity.User['userId'],
+): Amity.Cached<Amity.FollowInfo> | undefined => {
+  const client = getActiveClient();
+  client.log('follow/getFollowInfo.locally', userId);
+
+  if (!client.cache) {
+    return;
+  }
+
+  const cached = pullFromCache<Amity.FollowInfo>(getCacheKey(userId));
+
+  if (!cached) {
+    return;
+  }
+
+  return {
+    data: cached.data,
+    cachedAt: cached.cachedAt,
+  };
+};

package/src/follow/api/index.ts

@@ -0,0 +1,8 @@
+export * from './queryFollowers';
+export * from './queryFollowings';
+export * from './getFollowInfo';
+
+export * from './follow';
+export * from './unfollow';
+export * from './acceptFollower';
+export * from './declineFollower';

package/src/follow/api/queryFollowers.ts

@@ -0,0 +1,38 @@
+import { queryFollows } from './utils';
+
+/**
+ * ```js
+ * import { queryFollowers } from '@amityco/ts-sdk'
+ * const { data: followers, prevPage, nextPage } = await queryFollowers({ userId })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.FollowStatus}
+ *
+ * @param query The query parameters
+ * @returns followers
+ *
+ * @category Follow API
+ * @async
+ */
+export const queryFollowers = async (
+  query: Amity.QueryFollowers,
+): Promise<Amity.Cached<Amity.Paged<Amity.FollowStatus, Amity.PageRaw>>> =>
+  queryFollows('followers', query);
+
+/**
+ * ```js
+ * import { queryFollowers } from '@amityco/ts-sdk'
+ * const { data: followers, prevPage, nextPage } = queryFollowers.locally({ userId })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.FollowStatus} objects from cache
+ *
+ * @param query The query parameters
+ * @returns followers
+ *
+ * @category Post API
+ */
+queryFollowers.locally = (
+  query: Parameters<typeof queryFollowers>[0],
+): Amity.Cached<Amity.Paged<Amity.FollowStatus, Amity.PageRaw>> | undefined =>
+  queryFollows.locally('followers', query);

package/src/follow/api/queryFollowings.ts

@@ -0,0 +1,38 @@
+import { queryFollows } from './utils';
+
+/**
+ * ```js
+ * import { queryFollowings } from '@amityco/ts-sdk'
+ * const { data: followings, prevPage, nextPage } = await queryFollowings({ userId })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.FollowStatus}
+ *
+ * @param query The query parameters
+ * @returns followings
+ *
+ * @category Follow API
+ * @async
+ */
+export const queryFollowings = async (
+  query: Amity.QueryFollowings,
+): Promise<Amity.Cached<Amity.Paged<Amity.FollowStatus, Amity.PageRaw>>> =>
+  queryFollows('following', query);
+
+/**
+ * ```js
+ * import { queryFollowings } from '@amityco/ts-sdk'
+ * const { data: followings, prevPage, nextPage } = queryFollowings.locally({ userId })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.FollowStatus} objects from cache
+ *
+ * @param query The query parameters
+ * @returns followings
+ *
+ * @category Post API
+ */
+queryFollowings.locally = (
+  query: Parameters<typeof queryFollowings>[0],
+): Amity.Cached<Amity.Paged<Amity.FollowStatus, Amity.PageRaw>> | undefined =>
+  queryFollows.locally('following', query);

package/src/follow/api/unfollow.ts

@@ -0,0 +1,34 @@
+import { getActiveClient } from '~/client/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+
+/**
+ * ```js
+ * import { unfollow } from '@amityco/ts-sdk'
+ * await unfollow('foobar')
+ * ```
+ *
+ * Cancel the follow request or unfollow the user
+ *
+ * @param userId the ID of the {@link Amity.User}
+ * @returns A success boolean if the user {@link Amity.User} was unfollowed
+ *
+ * @category Follow API
+ * @async
+ */
+export const unfollow = async (userId: Amity.User['userId']): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('follow/unfollow', userId);
+
+  const { data } = await client.http.delete<Amity.FollowStatusPayload>(
+    `/api/v4/me/following/${userId}`,
+  );
+
+  if (client.cache) {
+    ingestInCache(data);
+  }
+
+  fireEvent('follow.unfollowed', data);
+
+  return true;
+};

package/src/follow/api/utils.ts

@@ -0,0 +1,86 @@
+import { getActiveClient } from '~/client/api';
+import { toPageRaw, toToken } from '~/core/query';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { getResolver } from '~/core/model';
+
+export const queryFollows = async (
+  key: 'followers' | 'following',
+  query: {
+    userId: Amity.User['userId'];
+    status?: Exclude<Amity.FollowStatusType, 'none'>;
+    page?: Amity.PageRaw;
+  },
+): Promise<Amity.Cached<Amity.Paged<Amity.FollowStatus, Amity.PageRaw>>> => {
+  const client = getActiveClient();
+  client.log(`follow/queryF${key.substring(1)}`, query);
+
+  const { userId, page, ...params } = query;
+
+  const { data } = await client.http.get<Amity.FollowersPayload & Amity.Pagination>(
+    client.userId === userId ? `/api/v4/me/${key}` : `/api/v4/users/${userId}/${key}`,
+    {
+      params: {
+        ...params,
+        token: toToken(page, 'afterbeforeraw'),
+      },
+    },
+  );
+
+  const { paging, ...payload } = data;
+  const { follows } = payload;
+
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache) {
+    ingestInCache(payload as Amity.FollowersPayload, { cachedAt });
+
+    const cacheKey = [
+      'follow',
+      'query',
+      { ...params, userId, options: { ...page }, type: key } as Amity.Serializable,
+    ];
+    pushToCache(cacheKey, { follows: follows.map(getResolver('follow')), paging });
+  }
+
+  const nextPage = toPageRaw(paging.next);
+  const prevPage = toPageRaw(paging.previous);
+
+  return { data: follows, cachedAt, prevPage, nextPage };
+};
+
+queryFollows.locally = (
+  key: Parameters<typeof queryFollows>[0],
+  query: Parameters<typeof queryFollows>[1],
+): Amity.Cached<Amity.Paged<Amity.FollowStatus, Amity.PageRaw>> | undefined => {
+  const client = getActiveClient();
+  client.log(`follow/queryF${key.substring(1)}.locally`, query);
+
+  if (!client.cache) return;
+
+  const { page, ...params } = query;
+
+  const queryKey = [
+    'follow',
+    'query',
+    { ...params, options: { ...page }, type: key } as Amity.Serializable,
+  ];
+  const { data, cachedAt } =
+    pullFromCache<{ follows: string[] } & Amity.Pagination>(queryKey) ?? {};
+
+  if (!data?.follows.length) {
+    return;
+  }
+
+  const follows: Amity.FollowStatus[] = data.follows
+    .map(key => pullFromCache<Amity.FollowStatus>(['follow', 'get', key])!)
+    .filter(Boolean)
+    .map(({ data }) => data);
+
+  const prevPage = toPageRaw(data?.paging.previous);
+  const nextPage = toPageRaw(data?.paging.next);
+
+  return follows.length === data?.follows?.length
+    ? { data: follows, cachedAt, prevPage, nextPage }
+    : undefined;
+};

package/src/follow/events/index.ts

@@ -0,0 +1,10 @@
+export * from './onUserFollowed';
+export * from './onUserUnfollowed';
+export * from './onFollowerDeleted';
+
+export * from './onFollowerRequested';
+export * from './onFollowRequestCanceled';
+export * from './onFollowRequestAccepted';
+export * from './onFollowRequestDeclined';
+
+export * from './onFollowInfoUpdated';

package/src/follow/events/onFollowInfoUpdated.ts

@@ -0,0 +1,45 @@
+import { createFollowEventSubscriber } from './utils';
+import { getFollowInfo } from '~/follow/api';
+
+/**
+ * ```js
+ * import { onFollowInfoUpdated } from '@amityco/ts-sdk'
+ * const dispose = onFollowInfoUpdated(followInfo => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.FollowInfo} has been updated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Follow Events
+ */
+export const onFollowInfoUpdated = (
+  callback: Amity.Listener<Amity.FollowInfo>,
+): Amity.Unsubscriber => {
+  const handler = async (payload: Amity.FollowStatus) => {
+    const [{ data: followInfoFrom }, { data: followInfoTo }] = await Promise.all([
+      getFollowInfo(payload.from),
+      getFollowInfo(payload.to),
+    ]);
+
+    callback(followInfoFrom);
+    callback(followInfoTo);
+  };
+
+  const disposers = [
+    createFollowEventSubscriber('follow.created', handler),
+    createFollowEventSubscriber('follow.requested', handler),
+    createFollowEventSubscriber('follow.accepted', handler),
+    createFollowEventSubscriber('follow.unfollowed', handler),
+    createFollowEventSubscriber('follow.requestCanceled', handler),
+    createFollowEventSubscriber('follow.requestDeclined', handler),
+    createFollowEventSubscriber('follow.followerDeleted', handler),
+  ];
+
+  return () => {
+    disposers.forEach(fn => fn());
+  };
+};

package/src/follow/events/onFollowRequestAccepted.ts

@@ -0,0 +1,20 @@
+import { createFollowEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onFollowRequestAccepted } from '@amityco/ts-sdk'
+ * const dispose = onFollowRequestAccepted(status => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a follow request has been accepted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Follow Events
+ */
+export const onFollowRequestAccepted = (
+  callback: Amity.Listener<Amity.FollowStatus>,
+): Amity.Unsubscriber => createFollowEventSubscriber('follow.accepted', callback);

package/src/follow/events/onFollowRequestCanceled.ts

@@ -0,0 +1,20 @@
+import { createFollowEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onFollowRequestCanceled } from '@amityco/ts-sdk'
+ * const dispose = onFollowRequestCanceled(status => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a follow request has been canceled
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Follow Events
+ */
+export const onFollowRequestCanceled = (
+  callback: Amity.Listener<Amity.FollowStatus>,
+): Amity.Unsubscriber => createFollowEventSubscriber('follow.requestCanceled', callback);