@amityco/ts-sdk-react-native/src/channelRepository/observers/getMyMembership.ts

Amity Social Cloud Typescript SDK

import { getActiveUser } from '~/client/api/activeUser';
import { getMyMembership as _getMyMembership } from '../internalApi/getMyMembership';
import { ASCApiError, ASCError } from '~/core/errors';
import { getActiveClient } from '~/client/api/activeClient';
import { isEqual } from '~/utils/isEqual';
import { createQuery, runQuery } from '~/core/query';
import {
  UNSYNCED_OBJECT_CACHED_AT_MESSAGE,
  UNSYNCED_OBJECT_CACHED_AT_VALUE,
} from '~/utils/constants';
import { channelMemberLinkedObject } from '~/utils/linkedObject/channelMemberLinkedObject';
import { onChannelMemberBanned, onChannelMemberUnbanned } from '../events';
import { onChannelSetUserMuted } from '../events/onChannelSetUserMuted';

export const getMyMembership = (
  channelId: string,
  callback: Amity.LiveObjectCallback<Amity.Membership<'channel'> | undefined>,
): Amity.Unsubscriber => {
  const { _id: userId } = getActiveUser();

  if (!userId)
    throw new ASCError(
      'The _id has not been defined in ActiveUser',
      Amity.ClientError.UNKNOWN_ERROR,
      Amity.ErrorLevel.ERROR,
    );

  const { log, cache } = getActiveClient();

  if (!cache) {
    console.log('This observable object need the cache data!');
  }

  const timestamp = Date.now();
  log(`liveMymembership(tmpid: ${timestamp}) > listen`);

  const disposers: Amity.Unsubscriber[] = [];

  let isUnsyncedModel = false; // for messages

  let model: Amity.Membership<'channel'> | undefined;

  const dispatcher = (data: Amity.LiveObject<Amity.Membership<'channel'> | undefined>) => {
    callback({
      ...data,
      data: data.data ? channelMemberLinkedObject(data.data) : data.data,
    });
  };

  const realtimeRouter = (_: Amity.StaticInternalChannel, __: Amity.RawMembership<'channel'>) => {
    const { data } = _getMyMembership(channelId);

    if (isEqual(model, data)) return;

    dispatcher({
      loading: false,
      data,
    });
  };

  const onFetch = () => {
    const query = createQuery(async () => _getMyMembership(channelId));

    runQuery(query, ({ error, data, loading, origin, cachedAt }) => {
      if (cachedAt === UNSYNCED_OBJECT_CACHED_AT_VALUE) {
        dispatcher({
          data,
          origin,
          loading: false,
          error: new ASCApiError(
            UNSYNCED_OBJECT_CACHED_AT_MESSAGE,
            Amity.ClientError.DISALOOW_UNSYNCED_OBJECT,
            Amity.ErrorLevel.ERROR,
          ),
        });

        isUnsyncedModel = true;
        disposers.forEach(fn => fn());
      } else if (!isUnsyncedModel) {
        dispatcher({ loading, data, origin, error });
      }

      if (error) {
        disposers.forEach(fn => fn());
      }
    });
  };

  disposers.push(onChannelMemberBanned(realtimeRouter));
  disposers.push(onChannelMemberUnbanned(realtimeRouter));
  disposers.push(onChannelSetUserMuted(realtimeRouter));

  onFetch();

  return () => {
    disposers.forEach(fn => fn());
  };
};