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

package/src/stream/events/onStreamRecorded.ts

@@ -0,0 +1,35 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { onStreamRecorded } from '@amityco/ts-sdk'
+ * const dispose = onStreamRecorded(stream => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when the recordings of a {@link Amity.Stream} are available
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Stream Events
+ */
+export const onStreamRecorded = (callback: Amity.Listener<Amity.Stream>): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.StreamPayload) => {
+    ingestInCache(payload);
+    callback(payload.videoStreamings[0]);
+  };
+
+  return createEventSubscriber(
+    client,
+    'stream/onStreamRecorded',
+    'video-streaming.didRecord',
+    filter,
+  );
+};

package/src/stream/events/onStreamStarted.ts

@@ -0,0 +1,35 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { onStreamStarted } from '@amityco/ts-sdk'
+ * const dispose = onStreamStarted(stream => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Stream} has started airing
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Stream Events
+ */
+export const onStreamStarted = (callback: Amity.Listener<Amity.Stream>): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.StreamPayload) => {
+    ingestInCache(payload);
+    callback(payload.videoStreamings[0]);
+  };
+
+  return createEventSubscriber(
+    client,
+    'stream/onStreamStarted',
+    'video-streaming.didStart',
+    filter,
+  );
+};

package/src/stream/events/onStreamStopped.ts

@@ -0,0 +1,30 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { onStreamStopped } from '@amityco/ts-sdk'
+ * const dispose = onStreamStopped(stream => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Stream} has stopped airing
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Stream Events
+ */
+export const onStreamStopped = (callback: Amity.Listener<Amity.Stream>): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.StreamPayload) => {
+    ingestInCache(payload);
+    callback(payload.videoStreamings[0]);
+  };
+
+  return createEventSubscriber(client, 'stream/onStreamStarted', 'video-streaming.didStop', filter);
+};

package/src/user/api/getUser.ts

@@ -0,0 +1,58 @@
+import { getActiveClient } from '~/client/api';
+
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { getUser } from '@amityco/ts-sdk'
+ * const { data: user } = await getUser('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.User} object
+ *
+ * @param userId the ID of the {@link Amity.User} to fetch
+ * @returns the associated {@link Amity.User} object
+ *
+ * @category User API
+ * @async
+ */
+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/${encodeURIComponent(userId)}`,
+  );
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const { users } = data;
+
+  return {
+    data: users.find(user => user.userId === userId)!,
+    cachedAt,
+  };
+};
+
+/**
+ * ```js
+ * import { getUser } from '@amityco/ts-sdk'
+ * const { data: user } = getUser.locally('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.User} object from cache
+ *
+ * @param userId the ID of the {@link Amity.User} to fetch
+ * @returns the associated {@link Amity.User} object
+ *
+ * @category User API
+ */
+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

@@ -0,0 +1,74 @@
+import { getActiveClient } from '~/client/api';
+
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { getUsers } from '@amityco/ts-sdk'
+ * const { data: users } = await getUsers(['foo', 'bar'])
+ * ```
+ *
+ * Fetches a collection of {@link Amity.User} objects
+ *
+ * @param userIds the IDs of the {@link Amity.User} to fetch
+ * @returns the associated collection of {@link Amity.User} objects
+ *
+ * @category User API
+ * @async
+ */
+export const getUsers = async (
+  userIds: Amity.User['userId'][],
+): 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: encodedUserIds },
+  });
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  return {
+    data: data.users,
+    cachedAt,
+  };
+};
+
+/**
+ * ```js
+ * import { getUsers } from '@amityco/ts-sdk'
+ * const { data: users } = getUsers.locally!(['foo', 'bar'])
+ * ```
+ *
+ * Fetches a collection of {@link Amity.User} objects from cache
+ *
+ * @param userIds the IDs of the {@link Amity.User} to fetch
+ * @returns the associated collection of {@link Amity.User} objects
+ *
+ * @category User API
+ */
+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;
+
+  return {
+    data: users,
+    cachedAt: oldest.cachedAt,
+  };
+};

package/src/user/api/index.ts

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

package/src/user/api/queryUsers.ts

@@ -0,0 +1,107 @@
+import { getActiveClient } from '~/client/api';
+
+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 { data: users, prevPage, nextPage } = await queryUsers({ displayName: 'foo' })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.User} objects
+ * Search is performed by displayName such as `.startsWith(search)`
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.User} objects
+ *
+ * @category User API
+ * @async
+ */
+export const queryUsers = async (
+  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: {
+      ...params,
+      keyword: displayName,
+      filter,
+      sortBy,
+      options: {
+        token: toToken(page, 'skiplimit'),
+      },
+    },
+  });
+
+  // unpacking
+  const { paging, ...payload } = data;
+  const { users } = payload;
+
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache) {
+    ingestInCache(payload as Amity.UserPayload, { cachedAt });
+
+    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);
+
+  return { data: users, cachedAt, prevPage, nextPage };
+};
+
+/**
+ * ```js
+ * import { queryUsers } from '@amityco/ts-sdk'
+ * const { data: users } = queryUsers.locally({ keyword: 'foo' })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.User} objects from cache
+ * Search is performed by displayName such as `.startsWith(search)`
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.User} objects
+ *
+ * @category User API
+ */
+queryUsers.locally = (
+  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);
+
+  return users.length > 0 && users.length === data?.users?.length
+    ? { data: users, cachedAt, prevPage, nextPage }
+    : undefined;
+};

package/src/user/api/updateUser.ts

@@ -0,0 +1,52 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { updateUser } from '@amityco/ts-sdk'
+ * const updated = await updateUser(userId, { displayName: 'foobar' })
+ * ```
+ *
+ * Updates an {@link Amity.User}
+ *
+ * @param userId The ID of the {@link Amity.User} to update
+ * @param patch The patch data to apply
+ * @returns the updated {@link Amity.User} object
+ *
+ * @category User API
+ * @async
+ */
+export const updateUser = async (
+  userId: Amity.User['userId'],
+  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.
+  /*
+    const { data } = await client.http.put<Amity.Response<UserPayload>>(
+      `/api/v3/users/${userId}`, patch,
+    )
+  */
+
+  const { data } = await client.http.put<Amity.UserPayload>(`/api/v3/users/`, {
+    userId,
+    ...patch,
+    createNewUserWhenNotFound: false,
+  });
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const { users } = data;
+
+  return {
+    data: users.find(user => user.userId === userId)!,
+    cachedAt,
+  };
+};

package/src/user/events/index.ts

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,19 @@
+import { createUserEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onUserUpdated } from '@amityco/ts-sdk'
+ * const dispose = onUserUpdated(user => {
+ *   // ...
+ * })
+ * ```
+ *
+ * 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>) =>
+  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/observeUser.ts

@@ -0,0 +1,68 @@
+import { createQuery, runQuery } from '~/core/query/query';
+
+import { getActiveClient } from '~/client/api';
+
+import { getUser } from '../api';
+import {
+  onUserUpdated,
+  onUserDeleted,
+  onUserFlagged,
+  onUserUnflagged,
+  onUserFlagCleared,
+} from '../events';
+
+/**
+ * ```js
+ * import { observeUser } from '@amityco/ts-sdk'
+ *
+ * let user = {}
+ * const dispose = observeUser(userId, updated => user = updated)
+ * ```
+ *
+ * @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 user
+ *
+ * Observe all mutation on a given {@link Amity.User}
+ * @category User Observer
+ */
+export const observeUser = <
+  Events extends ['onFetch', 'onUpdate', 'onDelete', 'onFlagged', 'onUnflagged', 'onFlagCleared'],
+>(
+  userId: string,
+  callback: Amity.ObjectListener<Amity.Snapshot<Amity.User>, Events>,
+): Amity.Unsubscriber => {
+  const { log } = getActiveClient();
+
+  const timestamp = Date.now();
+  log(`observeUser(tmpid: ${timestamp}) > listen`);
+
+  // wrapper function to make sure
+  const router = (result: Amity.Snapshot<Amity.User>, action: Events[number]) => {
+    // filter function
+    if (result.data?.userId !== userId) return;
+
+    if (callback instanceof Function) return callback(result);
+
+    if (action !== 'onFetch') callback.onEvent?.(action, result);
+
+    callback[action]?.(result);
+  };
+
+  const disposers: Amity.Unsubscriber[] = [];
+
+  disposers.push(
+    onUserUpdated(data => router({ data, loading: false, origin: 'event' }, 'onUpdate')),
+    onUserDeleted(data => router({ data, loading: false, origin: 'event' }, 'onDelete')),
+    onUserFlagged(data => router({ data, loading: false, origin: 'event' }, 'onFlagged')),
+    onUserUnflagged(data => router({ data, loading: false, origin: 'event' }, 'onUnflagged')),
+    onUserFlagCleared(data => router({ data, loading: false, origin: 'event' }, 'onFlagCleared')),
+  );
+
+  runQuery(createQuery(getUser, userId), result => result.data && router(result, 'onFetch'));
+
+  return () => {
+    log(`observeUser(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/utils/env.ts

@@ -0,0 +1,12 @@
+/* eslint-disable no-undef */
+const theGlobal =
+  // eslint-disable-next-line no-nested-ternary
+  typeof globalThis === 'object' ? globalThis : typeof global === 'object' ? global : window;
+
+export const { process: safeProcess = {} }: { process: Partial<NodeJS.Process> } = theGlobal;
+
+export function getEnv(): NodeJS.ProcessEnv | undefined {
+  return safeProcess.env ?? {};
+}
+
+export const isProduction = safeProcess.env?.NODE_ENV === 'production';

package/src/version.ts

@@ -0,0 +1,4 @@
+// used in createClient
+import { safeProcess } from '~/utils/env';
+
+export const VERSION = safeProcess.env?.VERSION ?? '__dev__';

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "extends": "../../tsconfig.json",
+
+  "include": ["./src"],
+  "exclude": ["node_modules"],
+
+  "compilerOptions": {
+    "baseUrl": "./src",
+    "paths": {
+      "~/*": ["./*"],
+    },
+
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "declaration": true,
+    "declarationDir": "./dist",
+    "noEmit": true, // by rollup
+
+    "module": "es2020",
+    "target": "es2017",
+
+    "lib": [
+      "esnext",
+      "es7",
+      "es6",
+      "dom",
+    ],
+  }
+}

package/@types/core/cache.d.ts

@@ -1,21 +0,0 @@
-export {};
-declare global {
-    namespace Amity {
-        /**
-         * The typing of cache allows to distribute the typings properly for each values
-         * of T, so that there will be a proper auto-completion for K = "user" or K = "file"
-         * @hidden
-         */
-        type Cache = {
-            lookup: Record<string, string>;
-        } & {
-            [K in keyof Amity.Model]?: Amity.Store<Amity.Model[K]>;
-        };
-        /**
-         * Possible stores should be restricted to the one to fit in cache
-         * @hidden
-         */
-        type Domain = keyof Amity.Model;
-    }
-}
-//# sourceMappingURL=cache.d.ts.map

package/@types/core/cache.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../../src/@types/core/cache.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAA;AAET,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,KAAK,CAAC;QACd;;;;WAIG;QACH,KAAK,KAAK,GAAG;YACX,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;SAChC,GAAG;aACD,CAAC,IAAI,MAAM,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;SACvD,CAAA;QAED;;;WAGG;QACH,KAAK,MAAM,GAAG,MAAM,KAAK,CAAC,KAAK,CAAA;KAChC;CACF"}