get: function()

in packages/chat-stateful-client/src/StatefulChatClient.ts [71:139]
64 lines of code
11 McCabe index (conditional complexity)

  get: function <P extends keyof StatefulChatClientWithPrivateProps>(
    chatClient: ChatClient,
    prop: P,
    receiver: StatefulChatClientWithPrivateProps
  ) {
    // skip receiver.context call to avoid recursive bugs
    if (prop === 'context') {
      return Reflect.get(chatClient, prop);
    }

    const context = receiver.context;
    switch (prop) {
      case 'createChatThread': {
        return context.withAsyncErrorTeedToState(async function (...args: Parameters<ChatClient['createChatThread']>) {
          const result = await chatClient.createChatThread(...args);
          const thread = result.chatThread;
          if (thread) {
            const [request] = args;
            context.createThread(thread.id, { topic: request.topic });
          }
          return result;
        }, 'ChatClient.createChatThread');
      }

      case 'deleteChatThread': {
        return context.withAsyncErrorTeedToState(async function (...args: Parameters<ChatClient['deleteChatThread']>) {
          const result = await chatClient.deleteChatThread(...args);
          context.deleteThread(args[0]);
          return result;
        }, 'ChatClient.deleteChatThread');
      }
      case 'listChatThreads': {
        return createDecoratedListThreads(chatClient, context);
      }
      case 'getChatThreadClient': {
        return function (...args: Parameters<ChatClient['getChatThreadClient']>) {
          const chatThreadClient = chatClient.getChatThreadClient(...args);
          // TODO(prprabhu): Ensure that thread properties are fetched into the ChatContext at this point.
          // A new thread might be created here, but the properties will never be fetched.
          return chatThreadClientDeclaratify(chatThreadClient, context);
        };
      }
      case 'startRealtimeNotifications': {
        return context.withAsyncErrorTeedToState(async function (
          ...args: Parameters<ChatClient['startRealtimeNotifications']>
        ) {
          const ret = await chatClient.startRealtimeNotifications(...args);
          if (!receiver.eventSubscriber) {
            receiver.eventSubscriber = new EventSubscriber(chatClient, context);
          }
          return ret;
        }, 'ChatClient.startRealtimeNotifications');
      }
      case 'stopRealtimeNotifications': {
        return context.withAsyncErrorTeedToState(async function (
          ...args: Parameters<ChatClient['stopRealtimeNotifications']>
        ) {
          const ret = await chatClient.stopRealtimeNotifications(...args);
          if (receiver.eventSubscriber) {
            receiver.eventSubscriber.unsubscribe();
            receiver.eventSubscriber = undefined;
          }
          return ret;
        }, 'ChatClient.stopRealtimeNotifications');
      }
      default:
        return Reflect.get(chatClient, prop);
    }
  }