@amityco/ts-sdk 7.5.1-3d3fd19.0 → 7.5.1-3eaba4ad.0

package/src/communityRepository/observers/getJoinRequests.ts

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

package/src/invitationRepository/events/index.ts

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

package/src/invitationRepository/events/onLocalInvitationCreated.ts

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

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

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

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

package/src/invitationRepository/internalApi/acceptInvitation.ts

@@ -1,45 +0,0 @@
-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/createInvitations.ts

@@ -1,52 +0,0 @@
-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/getInvitation.ts

@@ -1,47 +0,0 @@
-import { getActiveClient } from '~/client/api/activeClient';
-import { ingestInCache } from '~/cache/api/ingestInCache';
-import { prepareMyInvitationsPayload } from '../utils/prepareMyInvitationsPayload';
-import { invitationLinkedObject } from '~/utils/linkedObject/invitationLinkedObject';
-
-/* begin_public_function
-  id: invitation.get
-*/
-/**
- * ```js
- * import { getInvitation } from '@amityco/ts-sdk'
- * const { invitation } = await getInvitation(targetType, targetId)
- * ```
- *
- * Get a {@link Amity.Invitation} object
- *
- * @param targetType The type of the target of the {@link Amity.Invitation}
- * @param targetId The ID of the target of the {@link Amity.Invitation}
- * @returns A {@link Amity.Invitation} object
- *
- * @category Invitation API
- * @async
- */
-export const getInvitation = async (
-  targetType: Amity.Invitation['targetType'],
-  targetId: Amity.Invitation['targetId'],
-): Promise<Amity.Cached<Amity.Invitation | undefined>> => {
-  const client = getActiveClient();
-  client.log('invitation/getInvitation', targetType, targetId);
-
-  const { data: payload } = await client.http.get<Amity.MyInvitationsPayload>(
-    `/api/v1/invitations/me`,
-    { params: { targetType, targetId } },
-  );
-
-  const data = prepareMyInvitationsPayload(payload);
-
-  const cachedAt = client.cache && Date.now();
-
-  if (client.cache) ingestInCache(data, { cachedAt });
-
-  return {
-    data: data.invitations[0] ? invitationLinkedObject(data.invitations[0]) : undefined,
-    cachedAt,
-  };
-};
-/* end_public_function */

package/src/invitationRepository/internalApi/index.ts

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

package/src/invitationRepository/internalApi/rejectInvitation.ts

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

@@ -1,148 +0,0 @@
-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: this.query,
-      });
-    }
-  }
-
-  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

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

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

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

package/src/invitationRepository/observers/getInvitations.ts

@@ -1,44 +0,0 @@
-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());
-  };
-};