@amityco/ts-sdk 0.0.1-beta.3 → 0.0.1-beta.30

package/src/stream/events/onStreamStarted.ts

@@ -1,8 +1,7 @@
-import { getActiveClient } from '~/client/api'
-import { createEventSubscriber } from '~/core/events'
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
 
-import { decoratePayload } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
+import { ingestInCache } from '~/cache/api/ingestInCache';
 
 /**
  * ```js
@@ -19,21 +18,18 @@ import { ingestInCache } from '~/core/cache'
  *
  * @category Stream Events
  */
-export const onStreamStarted = (
-  callback: Amity.Listener<Amity.Stream>
-): Amity.Unsubscriber => {
-  const client = getActiveClient()
+export const onStreamStarted = (callback: Amity.Listener<Amity.Stream>): Amity.Unsubscriber => {
+  const client = getActiveClient();
 
   const filter = (payload: Amity.StreamPayload) => {
-    decoratePayload(payload)
-    ingestInCache(payload)
-    callback(payload.videoStreamings[0])
-  }
+    ingestInCache(payload);
+    callback(payload.videoStreamings[0]);
+  };
 
   return createEventSubscriber(
     client,
     'stream/onStreamStarted',
     'video-streaming.didStart',
     filter,
-  )
-}
+  );
+};

package/src/stream/events/onStreamStopped.ts

@@ -1,8 +1,7 @@
-import { getActiveClient } from '~/client/api'
-import { createEventSubscriber } from '~/core/events'
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
 
-import { decoratePayload } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
+import { ingestInCache } from '~/cache/api/ingestInCache';
 
 /**
  * ```js
@@ -19,21 +18,13 @@ import { ingestInCache } from '~/core/cache'
  *
  * @category Stream Events
  */
-export const onStreamStopped = (
-  callback: Amity.Listener<Amity.Stream>
-): Amity.Unsubscriber => {
-  const client = getActiveClient()
+export const onStreamStopped = (callback: Amity.Listener<Amity.Stream>): Amity.Unsubscriber => {
+  const client = getActiveClient();
 
   const filter = (payload: Amity.StreamPayload) => {
-    decoratePayload(payload)
-    ingestInCache(payload)
-    callback(payload.videoStreamings[0])
-  }
+    ingestInCache(payload);
+    callback(payload.videoStreamings[0]);
+  };
 
-  return createEventSubscriber(
-    client,
-    'stream/onStreamStarted',
-    'video-streaming.didStop',
-    filter,
-  )
-}
+  return createEventSubscriber(client, 'stream/onStreamStarted', 'video-streaming.didStop', filter);
+};

package/src/user/api/getUser.ts

@@ -1,12 +1,12 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { ingestInCache, pullFromCache } from '~/core/cache'
-import { decoratePayload } from '~/core/query'
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
 
 /**
  * ```js
  * import { getUser } from '@amityco/ts-sdk'
- * const user = await getUser('foobar')
+ * const { data: user } = await getUser('foobar')
  * ```
  *
  * Fetches a {@link Amity.User} object
@@ -17,28 +17,30 @@ import { decoratePayload } from '~/core/query'
  * @category User API
  * @async
  */
-export const getUser = async (
-  userId: Amity.User['userId'],
-) => {
-  const client = getActiveClient()
-  client.log('user/getUser', userId)
+export const getUser = async (userId: Amity.User['userId']): Promise<Amity.Cached<Amity.User>> => {
+  const client = getActiveClient();
+  client.log('user/getUser', userId);
 
   // API-FIX: endpoint should not be /list, parameters should be querystring.
   const { data } = await client.http.get<Amity.UserPayload>(
-    `/api/v3/users/${userId}`,
-  )
+    `/api/v3/users/${encodeURIComponent(userId)}`,
+  );
 
-  decoratePayload(data)
-  ingestInCache(data)
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
 
-  const { users } = data
-  return users.find(user => user.userId === userId)!
-}
+  const { users } = data;
+
+  return {
+    data: users.find(user => user.userId === userId)!,
+    cachedAt,
+  };
+};
 
 /**
  * ```js
  * import { getUser } from '@amityco/ts-sdk'
- * const user = getUser.locally('foobar')
+ * const { data: user } = getUser.locally('foobar')
  * ```
  *
  * Fetches a {@link Amity.User} object from cache
@@ -48,12 +50,9 @@ export const getUser = async (
  *
  * @category User API
  */
-getUser.locally = (
-  userId: Amity.User['userId'],
-) => {
-  const client = getActiveClient()
-  client.log('user/getUser.locally', userId)
-
-  const [user] = pullFromCache('user', userId) ?? []
-  return user
-}
+getUser.locally = (userId: Amity.User['userId']): Amity.Cached<Amity.User> | undefined => {
+  const client = getActiveClient();
+  client.log('user/getUser.locally', userId);
+
+  return client.cache && pullFromCache<Amity.User>(['user', 'get', userId]);
+};

package/src/user/api/getUsers.ts

@@ -1,13 +1,12 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { decoratePayload } from '~/core/query'
-import { ingestInCache, pullFromCache } from '~/core/cache'
-import { toRecord } from '~/core/model'
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
 
 /**
  * ```js
  * import { getUsers } from '@amityco/ts-sdk'
- * const users = await getUsers(['foo', 'bar'])
+ * const { data: users } = await getUsers(['foo', 'bar'])
  * ```
  *
  * Fetches a collection of {@link Amity.User} objects
@@ -20,27 +19,30 @@ import { toRecord } from '~/core/model'
  */
 export const getUsers = async (
   userIds: Amity.User['userId'][],
-) => {
-  const client = getActiveClient()
-  client.log('user/getUsers', userIds)
+): Promise<Amity.Cached<Amity.User[]>> => {
+  const client = getActiveClient();
+  client.log('user/getUsers', userIds);
+
+  const encodedUserIds = userIds.map(userId => encodeURIComponent(userId));
 
   // API-FIX: endpoint should not be /list, parameters should be querystring.
-  const { data } = await client.http.get<Amity.UserPayload>(
-    `/api/v3/users/list`,
-    { params: { userIds } },
-  )
+  const { data } = await client.http.get<Amity.UserPayload>(`/api/v3/users/list`, {
+    params: { userIds: encodedUserIds },
+  });
 
-  decoratePayload(data)
-  ingestInCache(data)
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
 
-  const { users } = data
-  return toRecord(users)
-}
+  return {
+    data: data.users,
+    cachedAt,
+  };
+};
 
 /**
  * ```js
  * import { getUsers } from '@amityco/ts-sdk'
- * const users = getUsers.locally!(['foo', 'bar'])
+ * const { data: users } = getUsers.locally!(['foo', 'bar'])
  * ```
  *
  * Fetches a collection of {@link Amity.User} objects from cache
@@ -50,11 +52,23 @@ export const getUsers = async (
  *
  * @category User API
  */
-getUsers.locally = (
-  userIds: Amity.User['userId'][],
-) => {
-  const cached = pullFromCache('user', ...userIds) ?? []
+getUsers.locally = (userIds: Amity.User['userId'][]): Amity.Cached<Amity.User[]> | undefined => {
+  const client = getActiveClient();
+  client.log('user/getUsers.locally', userIds);
+
+  if (!client.cache) return;
+
+  const cached = userIds
+    .map(userId => pullFromCache<Amity.User>(['user', 'get', userId])!)
+    .filter(Boolean);
+
+  const users = cached.map(({ data }) => data);
+  const oldest = cached.sort((a, b) => (a.cachedAt! < b.cachedAt! ? -1 : 1))?.[0];
+
+  if (cached?.length < userIds.length) return;
 
-  if (cached?.length === userIds.length)
-    return toRecord(cached)
-}
+  return {
+    data: users,
+    cachedAt: oldest.cachedAt,
+  };
+};

package/src/user/api/index.ts

@@ -1,5 +1,5 @@
-export { getUser } from './getUser'
-export { getUsers } from './getUsers'
-export { queryUsers } from './queryUsers'
+export { getUser } from './getUser';
+export { getUsers } from './getUsers';
+export { queryUsers } from './queryUsers';
 
-export { updateUser } from './updateUser'
+export { updateUser } from './updateUser';

package/src/user/api/queryUsers.ts

@@ -1,13 +1,15 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { decoratePayload, toPage, toToken } from '~/core/query'
-import { ingestInCache, pullFromCache } from '~/core/cache'
-import { toRecord } from '~/core/model'
+import { toPage, toToken } from '~/core/query';
+
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getResolver } from '~/core/model';
 
 /**
  * ```js
  * import { queryUsers } from '@amityco/ts-sdk'
- * const { users, previous, next } = await queryUsers({ keyword: 'foo' })
+ * const { data: users, prevPage, nextPage } = await queryUsers({ displayName: 'foo' })
  * ```
  *
  * Queries a paginable list of {@link Amity.User} objects
@@ -20,54 +22,54 @@ import { toRecord } from '~/core/model'
  * @async
  */
 export const queryUsers = async (
-  query?: {
-    displayName?: Amity.User['displayName']
-    filter?: 'all' | 'flagged'
-    sortBy?: 'displayName' | 'firstCreated' | 'lastCreated'
-    page?: Amity.Page
-  }
-) => {
-  const client = getActiveClient()
-  client.log('user/queryUsers', query)
-
-  const {
-    page,
-    displayName,
-    filter = 'all',
-    sortBy = 'displayName',
-    ...params
-  } = query ?? {}
+  query: {
+    displayName?: Amity.User['displayName'];
+    filter?: 'all' | 'flagged';
+    sortBy?: 'displayName' | 'firstCreated' | 'lastCreated';
+    page?: Amity.Page;
+  } = {},
+): Promise<Amity.Cached<Amity.Paged<Amity.User>>> => {
+  const client = getActiveClient();
+  client.log('user/queryUsers', query);
+
+  const { page, displayName, filter = 'all', sortBy = 'displayName', ...params } = query;
 
   // API-FIX: parameters should be querystring.
-  const { data } = await client.http.get<Amity.UserPayload & Amity.Pagination>(
-    `/api/v3/users`, { params: {
+  const { data } = await client.http.get<Amity.UserPayload & Amity.Pagination>(`/api/v3/users`, {
+    params: {
       ...params,
       keyword: displayName,
       filter,
       sortBy,
       options: {
         token: toToken(page, 'skiplimit'),
-      }
-    } }
-  )
+      },
+    },
+  });
 
   // unpacking
-  const { paging, ...response } = data
+  const { paging, ...payload } = data;
+  const { users } = payload;
+
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache) {
+    ingestInCache(payload as Amity.UserPayload, { cachedAt });
 
-  decoratePayload(response as unknown as Record<string, any[]>)
-  ingestInCache(response as unknown as Record<string, any[]>)
+    const cacheKey = ['user', 'query', query as Amity.Serializable];
+    pushToCache(cacheKey, { users: users.map(getResolver('user')), paging });
+  }
 
-  const prevPage = toPage(paging.previous)
-  const nextPage = toPage(paging.next)
+  const prevPage = toPage(paging.previous);
+  const nextPage = toPage(paging.next);
 
-  const { users } = response
-  return { data: toRecord(users), prevPage, nextPage }
-}
+  return { data: users, cachedAt, prevPage, nextPage };
+};
 
 /**
  * ```js
  * import { queryUsers } from '@amityco/ts-sdk'
- * const users = queryUsers.locally({ keyword: 'foo' })
+ * const { data: users } = queryUsers.locally({ keyword: 'foo' })
  * ```
  *
  * Queries a paginable list of {@link Amity.User} objects from cache
@@ -79,10 +81,27 @@ export const queryUsers = async (
  * @category User API
  */
 queryUsers.locally = (
-  query: Parameters<typeof queryUsers>[0],
-) => {
-  const client = getActiveClient()
-  client.log('user/queryUsers.locally', query)
+  query: Parameters<typeof queryUsers>[0] = {},
+): Amity.Cached<Amity.Paged<Amity.User>> | undefined => {
+  const client = getActiveClient();
+  client.log('user/queryUsers.locally', query);
+
+  if (!client.cache) return;
+
+  const queryKey = ['user', 'query', query as Amity.Serializable];
+  const { data, cachedAt } =
+    pullFromCache<{ users: Pick<Amity.User, 'userId'>[] } & Amity.Pagination>(queryKey) ?? {};
+
+  const users: Amity.User[] =
+    data?.users
+      .map(userId => pullFromCache<Amity.User>(['user', 'get', userId])!)
+      .filter(Boolean)
+      .map(({ data }) => data) ?? [];
+
+  const prevPage = toPage(data?.paging.previous);
+  const nextPage = toPage(data?.paging.next);
 
-  // TODO
-}
+  return users.length > 0 && users.length === data?.users?.length
+    ? { data: users, cachedAt, prevPage, nextPage }
+    : undefined;
+};

package/src/user/api/updateUser.ts

@@ -1,7 +1,6 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { decoratePayload } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
+import { ingestInCache } from '~/cache/api/ingestInCache';
 
 /**
  * ```js
@@ -20,10 +19,13 @@ import { ingestInCache } from '~/core/cache'
  */
 export const updateUser = async (
   userId: Amity.User['userId'],
-  patch: Patch<Amity.User, 'displayName' | 'description' | 'avatarFileId' | 'metadata'>,
-) => {
-  const client = getActiveClient()
-  client.log('user/updateUser', userId, patch)
+  patch: Patch<
+    Amity.User,
+    'displayName' | 'description' | 'avatarFileId' | 'avatarCustomUrl' | 'metadata'
+  >,
+): Promise<Amity.Cached<Amity.User>> => {
+  const client = getActiveClient();
+  client.log('user/updateUser', userId, patch);
 
   // API-FIX: Endpoint is malformed, userId should be a url param.
   /*
@@ -32,13 +34,19 @@ export const updateUser = async (
     )
   */
 
-  const { data } = await client.http.put<Amity.UserPayload>(
-    `/api/v3/users/`, { userId, ...patch, createNewUserWhenNotFound: false },
-  )
+  const { data } = await client.http.put<Amity.UserPayload>(`/api/v3/users/`, {
+    userId,
+    ...patch,
+    createNewUserWhenNotFound: false,
+  });
 
-  decoratePayload(data)
-  ingestInCache(data)
-  // no need for event, fired by server
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
 
-  return data.users.find(user => user.userId === userId)!
-}
+  const { users } = data;
+
+  return {
+    data: users.find(user => user.userId === userId)!,
+    cachedAt,
+  };
+};

package/src/user/events/index.ts

@@ -1 +1,6 @@
-export * from './onUserUpdated'
+export * from './onUserUpdated';
+export * from './onUserDeleted';
+
+export * from './onUserFlagged';
+export * from './onUserUnflagged';
+export * from './onUserFlagCleared';

package/src/user/events/onUserDeleted.ts

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

package/src/user/events/onUserFlagCleared.ts

@@ -0,0 +1,19 @@
+import { createUserEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onUserFlagCleared } from '@amityco/ts-sdk'
+ * const dispose = onUserFlagCleared(user => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when flags have been cleared for a {@link Amity.User}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category User Events
+ */
+export const onUserFlagCleared = (callback: Amity.Listener<Amity.User>) =>
+  createUserEventSubscriber('user.flagCleared', callback);

package/src/user/events/onUserFlagged.ts

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

package/src/user/events/onUserUnflagged.ts

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

package/src/user/events/onUserUpdated.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 { createUserEventSubscriber } from './utils';
 
 /**
  * ```js
@@ -12,28 +8,12 @@ import { ingestInCache } from '~/core/cache'
  * })
  * ```
  *
- * Fired when any {@link Amity.User} have been updated
+ * Fired when a {@link Amity.User} has been updated
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
  * @category User Events
  */
-export const onUserUpdated = (
-  callback: Amity.Listener<Amity.User>
-) => {
-  const client = getActiveClient()
-
-  const filter = (payload: Amity.UserPayload) => {
-    decoratePayload(payload)
-    ingestInCache(payload)
-    callback(payload.users[0])
-  }
-
-  return createEventSubscriber(
-    client,
-    'user/onUserUpdate',
-    'v3.user.didUpdate',
-    filter
-  )
-}
+export const onUserUpdated = (callback: Amity.Listener<Amity.User>) =>
+  createUserEventSubscriber('user.updated', callback);

package/src/user/events/utils.ts

@@ -0,0 +1,21 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { createEventSubscriber } from '~/core/events';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+export const createUserEventSubscriber = (
+  event: keyof Amity.MqttUserMessageEvents,
+  callback: Amity.Listener<Amity.User>,
+) => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.UserPayload) => {
+    if (client.cache) {
+      ingestInCache(payload);
+    }
+
+    callback(payload.users[0]);
+  };
+
+  return createEventSubscriber(client, event, event, filter);
+};

package/src/user/observers/index.ts

@@ -1 +1 @@
-export { observeUser } from './observeUser'
+export { observeUser } from './observeUser';