Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

3.3 KB
Raw Blame
import { toast } from '@core/component/Toast/Toast';
import { fireAndForget } from '@core/util/fireAndForget';
import { throwOnErr } from '@core/util/result';
import { authServiceClient } from '@service-auth/client';
import type { TeamInvitesResponse } from '@service-auth/generated/schemas/teamInvitesResponse';
import { useMutation, useQuery } from '@tanstack/solid-query';
import { queryClient } from '../client';
import { type MutationCallbacks, withCallbacks } from '../utils';
import { teamKeys } from './keys';
import { invalidateUserTeams } from './teams';

function fetchUserInvites() {
  return throwOnErr(() => authServiceClient.getUserInvites());
}

export function useUserInvitesQuery() {
  return useQuery(() => ({
    queryKey: teamKeys.userInvites.queryKey,
    queryFn: fetchUserInvites,
  }));
}

function invalidateUserInvites() {
  return queryClient.invalidateQueries({
    queryKey: teamKeys.userInvites.queryKey,
  });
}

type JoinTeamArgs = { teamInviteId: string };
type JoinTeamContext = { previousInvites: TeamInvitesResponse | undefined };
type JoinTeamCallbacks = MutationCallbacks<
  void,
  Error,
  JoinTeamArgs,
  JoinTeamContext
>;

export function useJoinTeamMutation(callbacks?: JoinTeamCallbacks) {
  return useMutation(() => ({
    mutationKey: teamKeys.acceptInvite.queryKey,
    mutationFn: async ({ teamInviteId }: JoinTeamArgs) => {
      await throwOnErr(() => authServiceClient.joinTeam(teamInviteId));
    },

    ...withCallbacks<void, Error, JoinTeamArgs, JoinTeamContext>(
      {
        onSuccess: () => {
          invalidateUserTeams();
          fireAndForget(invalidateUserInvites(), 'team-invitations');
          toast.success('Joined team');
        },

        onError: (error, _vars, context) => {
          console.error('Failed to join team', error);
          toast.failure('Failed to join team');

          if (context?.previousInvites) {
            queryClient.setQueryData(
              teamKeys.userInvites.queryKey,
              context.previousInvites
            );
          }
        },
      },
      callbacks
    ),
  }));
}

type RejectInvitationArgs = { teamInviteId: string };
type RejectInvitationContext = {
  previousInvites: TeamInvitesResponse | undefined;
};
type RejectInvitationCallbacks = MutationCallbacks<
  void,
  Error,
  RejectInvitationArgs,
  RejectInvitationContext
>;

export function useRejectInvitationMutation(
  callbacks?: RejectInvitationCallbacks
) {
  return useMutation(() => ({
    mutationKey: teamKeys.rejectInvite.queryKey,
    mutationFn: async ({ teamInviteId }: RejectInvitationArgs) => {
      await throwOnErr(() => authServiceClient.rejectInvitation(teamInviteId));
    },

    ...withCallbacks<
      void,
      Error,
      RejectInvitationArgs,
      RejectInvitationContext
    >(
      {
        onSuccess: () => {
          fireAndForget(invalidateUserInvites(), 'team-invitations');
          toast.success('Invitation declined');
        },

        onError: (error, _vars, context) => {
          console.error('Failed to reject invitation', error);
          toast.failure('Failed to reject invitation');

          if (context?.previousInvites) {
            queryClient.setQueryData(
              teamKeys.userInvites.queryKey,
              context.previousInvites
            );
          }
        },
      },
      callbacks
    ),
  }));
}