@amityco/ts-sdk 7.4.1-b7aa4210.0 → 7.4.1-c116567e.0

package/src/core/model/index.ts

@@ -54,6 +54,8 @@ export const PAYLOAD2MODEL: Record<string, Amity.Domain> = {
   pins: 'pin',
 
   notificationTrayItems: 'notificationTrayItem',
+
+  invitations: 'invitation',
 };
 
 /** hidden */

package/src/index.ts

@@ -51,3 +51,5 @@ export * as AdRepository from './adRepository';
 export * from './external/api';
 
 export * as notificationTray from './notificationTray';
+
+export * as InvitationRepository from './invitationRepository';

package/src/invitationRepository/events/index.ts

@@ -0,0 +1,3 @@
+export * from './onLocalInvitationCreated';
+export * from './onLocalInvitationUpdated';
+export * from './onLocalInvitationDeleted';

package/src/invitationRepository/events/onLocalInvitationCreated.ts

@@ -0,0 +1,33 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ * ```js
+ * import { onLocalInvitationCreated } from '@amityco/ts-sdk'
+ * const dispose = onLocalInvitationCreated(data => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.InvitationPayload} has been created
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Invitation Events
+ */
+export const onLocalInvitationCreated = (
+  callback: Amity.Listener<Amity.InternalInvitation[]>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const disposers = [
+    createEventSubscriber(client, 'onLocalInvitationCreated', 'local.invitation.created', payload =>
+      callback(payload),
+    ),
+  ];
+
+  return () => {
+    disposers.forEach(fn => fn());
+  };
+};

package/src/invitationRepository/events/onLocalInvitationDeleted.ts

@@ -0,0 +1,33 @@
+import { createEventSubscriber } from '~/core/events';
+import { getActiveClient } from '~/client/api/activeClient';
+
+/**
+ * ```js
+ * import { onLocalInvitationDeleted } from '@amityco/ts-sdk'
+ * const dispose = onLocalInvitationDeleted(data => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.InvitationPayload} has been deleted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Invitation Events
+ */
+export const onLocalInvitationDeleted = (
+  callback: Amity.Listener<Amity.InternalInvitation[]>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const disposers = [
+    createEventSubscriber(client, 'onLocalInvitationDeleted', 'local.invitation.deleted', payload =>
+      callback(payload),
+    ),
+  ];
+
+  return () => {
+    disposers.forEach(fn => fn());
+  };
+};

package/src/invitationRepository/events/onLocalInvitationUpdated.ts

@@ -0,0 +1,33 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ * ```js
+ * import { onLocalInvitationUpdated } from '@amityco/ts-sdk'
+ * const dispose = onLocalInvitationUpdated(data => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.InvitationPayload} has been updated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Invitation Events
+ */
+export const onLocalInvitationUpdated = (
+  callback: Amity.Listener<Amity.InternalInvitation[]>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const disposers = [
+    createEventSubscriber(client, 'onLocalInvitationUpdated', 'local.invitation.updated', payload =>
+      callback(payload),
+    ),
+  ];
+
+  return () => {
+    disposers.forEach(fn => fn());
+  };
+};

package/src/invitationRepository/index.ts

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

package/src/invitationRepository/internalApi/acceptInvitation.ts

@@ -0,0 +1,45 @@
+import { fireEvent } from '~/core/events';
+import { getActiveClient } from '~/client/api/activeClient';
+import { pullFromCache, upsertInCache } from '~/cache/api';
+import { InvitationStatusEnum } from '~/@types';
+
+/* begin_public_function
+  id: invitation.accept
+*/
+/**
+ * ```js
+ * import { acceptInvitation } from '@amityco/ts-sdk'
+ * const isAccepted = await acceptInvitation(invitationId)
+ * ```
+ *
+ * Accepts a {@link Amity.Invitation} object
+ *
+ * @param invitationId the {@link Amity.Invitation} to accept
+ * @returns A success boolean if the {@link Amity.Invitation} was accepted
+ *
+ * @category Invitation API
+ * @async
+ */
+export const acceptInvitation = async (invitationId: Amity.Invitation['_id']): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('invitation/acceptInvitation', invitationId);
+
+  const { data } = await client.http.post<{ success: boolean }>(
+    `/api/v1/invitations/${invitationId}/accept`,
+  );
+
+  const invitation = pullFromCache<Amity.InternalInvitation>([
+    'invitation',
+    'get',
+    invitationId,
+  ])?.data;
+
+  if (invitation) {
+    upsertInCache(['invitation', 'get', invitationId], { status: InvitationStatusEnum.Approved });
+
+    fireEvent('local.invitation.updated', [invitation]);
+  }
+
+  return data.success;
+};
+/* end_public_function */

package/src/invitationRepository/internalApi/cancelInvitation.ts

@@ -0,0 +1,44 @@
+import { fireEvent } from '~/core/events';
+import { dropFromCache, pullFromCache } from '~/cache/api';
+import { getActiveClient } from '~/client/api/activeClient';
+
+/* begin_public_function
+  id: invitation.cancel
+*/
+/**
+ * ```js
+ * import { cancelInvitation } from '@amityco/ts-sdk'
+ * const isCanceled = await cancelInvitation(invitationId)
+ * ```
+ *
+ * Cancels a {@link Amity.Invitation} object
+ *
+ * @param invitationId the {@link Amity.Invitation} to cancel
+ * @returns A success boolean if the {@link Amity.Invitation} was canceled
+ *
+ * @category Invitation API
+ * @async
+ */
+export const cancelInvitation = async (invitationId: Amity.Invitation['_id']): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('invitation/cancelInvitation', invitationId);
+
+  const { data } = await client.http.delete<{ success: boolean }>(
+    `/api/v1/invitations/${invitationId}`,
+  );
+
+  const invitation = pullFromCache<Amity.InternalInvitation>([
+    'invitation',
+    'get',
+    invitationId,
+  ])?.data;
+
+  if (invitation) {
+    dropFromCache(['invitation', 'get', invitationId]);
+
+    fireEvent('local.invitation.deleted', [invitation]);
+  }
+
+  return data.success;
+};
+/* end_public_function */

package/src/invitationRepository/internalApi/createInvitations.ts

@@ -0,0 +1,52 @@
+import { fireEvent } from '~/core/events';
+import { getActiveClient } from '~/client/api/activeClient';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { prepareInvitationPayload } from '../utils';
+
+/* begin_public_function
+  id: invitation.createInvitations
+*/
+/**
+ * ```js
+ * import { createInvitations } from '@amityco/ts-sdk'
+ * const created = await createInvitations({
+ *  type: string,
+ *  targetType: string,
+ *  targetId: string,
+ *  userIds: string[]
+ * }))
+ * ```
+ *
+ * Creates an {@link Amity.Invitation}
+ *
+ * @param bundle The data necessary to create a new {@link Amity.Invitation}
+ * @returns The newly created {@link Amity.Invitation}
+ *
+ * @category Invitation API
+ * @async
+ */
+export const createInvitations = async (
+  bundle: Amity.CreateInvitations,
+): Promise<Amity.Cached<Amity.InternalInvitation[]>> => {
+  const client = getActiveClient();
+  client.log('invitation/createInvitations', bundle);
+
+  const { data: payload } = await client.http.post<Amity.InvitationPayload>(
+    '/api/v1/invitations',
+    bundle,
+  );
+
+  const data = prepareInvitationPayload(payload);
+
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  fireEvent('local.invitation.created', data.invitations);
+
+  return {
+    data: data.invitations,
+    cachedAt,
+  };
+};
+/* end_public_function */

package/src/invitationRepository/internalApi/index.ts

@@ -0,0 +1,4 @@
+export * from './createInvitations';
+export * from './acceptInvitation';
+export * from './rejectInvitation';
+export * from './cancelInvitation';

package/src/invitationRepository/internalApi/rejectInvitation.ts

@@ -0,0 +1,45 @@
+import { fireEvent } from '~/core/events';
+import { InvitationStatusEnum } from '~/@types';
+import { pullFromCache, upsertInCache } from '~/cache/api';
+import { getActiveClient } from '~/client/api/activeClient';
+
+/* begin_public_function
+  id: invitation.reject
+*/
+/**
+ * ```js
+ * import { rejectInvitation } from '@amityco/ts-sdk'
+ * const isRejected = await rejectInvitation(invitationId)
+ * ```
+ *
+ * Rejects a {@link Amity.Invitation} object
+ *
+ * @param invitationId the {@link Amity.Invitation} to reject
+ * @returns A success boolean if the {@link Amity.Invitation} was rejected
+ *
+ * @category Invitation API
+ * @async
+ */
+export const rejectInvitation = async (invitationId: Amity.Invitation['_id']): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('invitation/rejectInvitation', invitationId);
+
+  const { data } = await client.http.post<{ success: boolean }>(
+    `/api/v1/invitations/${invitationId}/reject`,
+  );
+
+  const invitation = pullFromCache<Amity.InternalInvitation>([
+    'invitation',
+    'get',
+    invitationId,
+  ])?.data;
+
+  if (invitation) {
+    upsertInCache(['invitation', 'get', invitationId], { status: InvitationStatusEnum.Rejected });
+
+    fireEvent('local.invitation.updated', [invitation]);
+  }
+
+  return data.success;
+};
+/* end_public_function */

package/src/invitationRepository/observers/getInvitations/InvitationsLiveCollectionController.ts

@@ -0,0 +1,148 @@
+import hash from 'object-hash';
+import { isNonNullable } from '~/utils';
+import { InvitationActionsEnum } from './enums';
+import { invitationLinkedObject } from '~/utils/linkedObject/invitationLinkedObject';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { sortByFirstCreated, sortByLastCreated } from '~/core/query';
+import { InvitationsPaginationController } from './InvitationsPaginationController';
+import { InvitationsQueryStreamController } from './InvitationsQueryStreamController';
+import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionController';
+import { prepareInvitationPayload } from '~/invitationRepository/utils';
+import {
+  onLocalInvitationCreated,
+  onLocalInvitationDeleted,
+  onLocalInvitationUpdated,
+} from '~/invitationRepository/events';
+
+export class InvitationsLiveCollectionController extends LiveCollectionController<
+  'invitation',
+  Amity.InvitationLiveCollection,
+  Amity.Invitation,
+  InvitationsPaginationController
+> {
+  private queryStreamController: InvitationsQueryStreamController;
+
+  private query: Amity.InvitationLiveCollection;
+
+  constructor(
+    query: Amity.InvitationLiveCollection,
+    callback: Amity.LiveCollectionCallback<Amity.Invitation>,
+  ) {
+    const queryStreamId = hash(query);
+    const cacheKey = ['invitation', 'collection', queryStreamId];
+    const paginationController = new InvitationsPaginationController(query);
+
+    super(paginationController, queryStreamId, cacheKey, callback);
+
+    this.query = query;
+    this.queryStreamController = new InvitationsQueryStreamController(
+      this.query,
+      this.cacheKey,
+      this.notifyChange.bind(this),
+      prepareInvitationPayload,
+    );
+
+    this.callback = callback.bind(this);
+    this.loadPage({ initial: true });
+  }
+
+  protected setup() {
+    const collection = pullFromCache<Amity.InvitationLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) {
+      pushToCache(this.cacheKey, {
+        data: [],
+        params: {},
+      });
+    }
+  }
+
+  protected async persistModel(queryPayload: Amity.InvitationPayload & Amity.Pagination) {
+    await this.queryStreamController.saveToMainDB(queryPayload);
+  }
+
+  protected persistQueryStream({
+    response,
+    direction,
+    refresh,
+  }: Amity.LiveCollectionPersistQueryStreamParams<'invitation'>) {
+    this.queryStreamController.appendToQueryStream(response, direction, refresh);
+  }
+
+  startSubscription() {
+    return this.queryStreamController.subscribeRTE([
+      {
+        fn: onLocalInvitationCreated,
+        action: InvitationActionsEnum.OnLocalInvitationCreated,
+      },
+      {
+        fn: onLocalInvitationUpdated,
+        action: InvitationActionsEnum.OnLocalInvitationUpdated,
+      },
+      {
+        fn: onLocalInvitationDeleted,
+        action: InvitationActionsEnum.OnLocalInvitationDeleted,
+      },
+    ]);
+  }
+
+  notifyChange({ origin, loading, error }: Amity.LiveCollectionNotifyParams) {
+    const collection = pullFromCache<Amity.InvitationLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) return;
+
+    const data = this.applyFilter(
+      collection.data
+        .map(id => pullFromCache<Amity.InternalInvitation>(['invitation', 'get', id])!)
+        .filter(isNonNullable)
+        .map(({ data }) => invitationLinkedObject(data)) ?? [],
+    );
+
+    if (!this.shouldNotify(data) && origin === 'event') return;
+
+    this.callback({
+      onNextPage: () => this.loadPage({ direction: Amity.LiveCollectionPageDirection.NEXT }),
+      data,
+      hasNextPage: !!this.paginationController.getNextToken(),
+      loading,
+      error,
+    });
+  }
+
+  applyFilter(data: Amity.Invitation[]) {
+    let invitations = data;
+
+    if (this.query.targetId) {
+      invitations = invitations.filter(invitation => invitation.targetId === this.query.targetId);
+    }
+
+    if (this.query.statuses) {
+      invitations = invitations.filter(invitation =>
+        this.query.statuses?.includes(invitation.status),
+      );
+    }
+
+    if (this.query.targetType) {
+      invitations = invitations.filter(
+        invitation => invitation.targetType === this.query.targetType,
+      );
+    }
+
+    if (this.query.type) {
+      invitations = invitations.filter(invitation => invitation.type === this.query.type);
+    }
+
+    const sortFn = (() => {
+      switch (this.query.sortBy) {
+        case 'firstCreated':
+          return sortByFirstCreated;
+        case 'lastCreated':
+          return sortByLastCreated;
+        default:
+          return sortByLastCreated;
+      }
+    })();
+
+    invitations = invitations.sort(sortFn);
+
+    return invitations;
+  }
+}

package/src/invitationRepository/observers/getInvitations/InvitationsPaginationController.ts

@@ -0,0 +1,19 @@
+import { COLLECTION_DEFAULT_PAGINATION_LIMIT } from '~/utils/constants';
+import { PaginationController } from '~/core/liveCollection/PaginationController';
+
+export class InvitationsPaginationController extends PaginationController<
+  'invitation',
+  Amity.InvitationLiveCollection
+> {
+  async getRequest(queryParams: Amity.InvitationLiveCollection, token: string | undefined) {
+    const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, ...params } = queryParams;
+    const options = token ? { token } : { limit };
+
+    const { data } = await this.http.get<Amity.InvitationPayload & Amity.Pagination>(
+      `/api/v1/invitations`,
+      { params: { ...params, options } },
+    );
+
+    return data;
+  }
+}

package/src/invitationRepository/observers/getInvitations/InvitationsQueryStreamController.ts

@@ -0,0 +1,97 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { getResolver } from '~/core/model';
+import { InvitationActionsEnum } from './enums';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { QueryStreamController } from '~/core/liveCollection/QueryStreamController';
+
+export class InvitationsQueryStreamController extends QueryStreamController<
+  Amity.InvitationPayload,
+  Amity.InvitationLiveCollection
+> {
+  private notifyChange: (params: Amity.LiveCollectionNotifyParams) => void;
+
+  private preparePayload: (response: Amity.InvitationPayload) => Amity.ProcessedInvitationPayload;
+
+  constructor(
+    query: Amity.InvitationLiveCollection,
+    cacheKey: string[],
+    notifyChange: (params: Amity.LiveCollectionNotifyParams) => void,
+    preparePayload: (response: Amity.InvitationPayload) => Amity.ProcessedInvitationPayload,
+  ) {
+    super(query, cacheKey);
+    this.notifyChange = notifyChange;
+    this.preparePayload = preparePayload;
+  }
+
+  async saveToMainDB(response: Amity.InvitationPayload) {
+    const processedPayload = await this.preparePayload(response);
+
+    const client = getActiveClient();
+    const cachedAt = client.cache && Date.now();
+
+    if (client.cache) {
+      ingestInCache(processedPayload, { cachedAt });
+    }
+  }
+
+  appendToQueryStream(
+    response: Amity.InvitationPayload & Partial<Amity.Pagination>,
+    direction: Amity.LiveCollectionPageDirection,
+    refresh = false,
+  ) {
+    if (refresh) {
+      pushToCache(this.cacheKey, {
+        data: response.invitations.map(getResolver('invitation')),
+      });
+    } else {
+      const collection = pullFromCache<Amity.InvitationLiveCollectionCache>(this.cacheKey)?.data;
+
+      const invitations = collection?.data ?? [];
+
+      pushToCache(this.cacheKey, {
+        ...collection,
+        data: [
+          ...new Set([...invitations, ...response.invitations.map(getResolver('invitation'))]),
+        ],
+      });
+    }
+  }
+
+  reactor(action: InvitationActionsEnum) {
+    return (invitations: Amity.InternalInvitation[]) => {
+      const collection = pullFromCache<Amity.InvitationLiveCollectionCache>(this.cacheKey)?.data;
+      if (!collection) return;
+
+      if (action === InvitationActionsEnum.OnLocalInvitationUpdated) {
+        const isExist = collection.data.find(id => id === invitations[0].invitationId);
+        if (!isExist) return;
+      }
+
+      if (action === InvitationActionsEnum.OnLocalInvitationCreated) {
+        collection.data = [
+          ...new Set([
+            ...invitations.map(invitation => invitation.invitationId),
+            ...collection.data,
+          ]),
+        ];
+      }
+
+      if (action === InvitationActionsEnum.OnLocalInvitationDeleted) {
+        collection.data = collection.data.filter(id => id !== invitations[0].invitationId);
+      }
+
+      pushToCache(this.cacheKey, collection);
+      this.notifyChange({ origin: Amity.LiveDataOrigin.EVENT, loading: false });
+    };
+  }
+
+  subscribeRTE(
+    createSubscriber: {
+      fn: (reactor: Amity.Listener<Amity.InternalInvitation[]>) => Amity.Unsubscriber;
+      action: InvitationActionsEnum;
+    }[],
+  ) {
+    return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+  }
+}

package/src/invitationRepository/observers/getInvitations/enums.ts

@@ -0,0 +1,5 @@
+export enum InvitationActionsEnum {
+  OnLocalInvitationCreated = 'onLocalInvitationCreated',
+  OnLocalInvitationUpdated = 'onLocalInvitationUpdated',
+  OnLocalInvitationDeleted = 'onLocalInvitationDeleted',
+}

package/src/invitationRepository/observers/getInvitations.ts

@@ -0,0 +1,44 @@
+import { dropFromCache } from '~/cache/api';
+import { getActiveClient } from '~/client/api/activeClient';
+import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+import { InvitationsLiveCollectionController } from './getInvitations/InvitationsLiveCollectionController';
+
+/**
+ * Get invitations
+ *
+ * @param params the query parameters
+ * @param callback the callback to be called when the invitations are updated
+ * @returns invitations
+ *
+ * @category Invitation Live Collection
+ *
+ */
+export const getInvitations = (
+  params: Amity.InvitationLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.Invitation>,
+  config?: Amity.LiveCollectionConfig,
+) => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`getInvitations: (tmpid: ${timestamp}) > listen`);
+
+  const invitationsLiveCollection = new InvitationsLiveCollectionController(params, callback);
+
+  const disposers = invitationsLiveCollection.startSubscription();
+
+  const cacheKey = invitationsLiveCollection.getCacheKey();
+
+  disposers.push(() => {
+    dropFromCache(cacheKey);
+  });
+
+  return () => {
+    log(`getInvitations (tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/invitationRepository/utils/index.ts

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

package/src/invitationRepository/utils/prepareInvitationPayload.ts

@@ -0,0 +1,11 @@
+export const prepareInvitationPayload = (
+  rawPayload: Amity.InvitationPayload,
+): Amity.ProcessedInvitationPayload => {
+  return {
+    invitations: rawPayload.invitations.map(invitation => ({
+      ...invitation,
+      invitationId: invitation._id,
+      createdById: invitation.createdBy,
+    })),
+  };
+};

package/src/messagePreview/utils/getChannelMessagePreviewWithUser.ts

@@ -1,6 +1,6 @@
-import { pullFromCache } from '~/cache/api';
+import { pullFromCache } from '~/cache/api/pullFromCache';
 import { getChannelMessagePreview } from './getChannelMessagePreview';
-import { LinkedObject } from '~/utils/linkedObject';
+import { userLinkedObject } from '~/utils/linkedObject/userLinkedObject';
 
 export const getChannelMessagePreviewWithUser = (
   channel: Amity.StaticInternalChannel,
@@ -20,7 +20,7 @@ export const getChannelMessagePreviewWithUser = (
   const messagePreviewWithUser = messagePreview
     ? {
         ...messagePreview,
-        user: internalUser ? LinkedObject.user(internalUser) : undefined,
+        user: internalUser ? userLinkedObject(internalUser) : undefined,
       }
     : null;