zapishis-client/packages/graphql/api/customer.ts

'use server';
import { getClientWithToken } from '../apollo/client';
import * as GQL from '../types';

export async function createOrUpdateUser(input: GQL.CreateCustomerMutationVariables) {
  if (!input.phone && !input.telegramId) throw new Error('Missing phone and telegramId');

  const { query, mutate } = await getClientWithToken();

  const response = await query({
    query: GQL.GetCustomerDocument,
    variables: input,
  });

  const customer = response?.data?.customers?.at(0);

  if (customer && customer.phone === input.phone) {
    return mutate({
      mutation: GQL.UpdateCustomerProfileDocument,
      variables: {
        documentId: customer.documentId,
        data: { ...input },
      },
    });
  }

  return mutate({
    mutation: GQL.CreateCustomerDocument,
    variables: input,
  });
}

export async function getCustomer(input: GQL.GetCustomerQueryVariables) {
  const { query } = await getClientWithToken();

  return query({
    query: GQL.GetCustomerDocument,
    variables: input,
  });
}

export async function getCustomerMasters(input: GQL.GetCustomerMastersQueryVariables) {
  const { query } = await getClientWithToken();

  return query({
    query: GQL.GetCustomerMastersDocument,
    variables: input,
  });
}

export async function getCustomerClients(input: GQL.GetCustomerClientsQueryVariables) {
  const { query } = await getClientWithToken();

  return query({
    query: GQL.GetCustomerClientsDocument,
    variables: input,
  });
}

type AddCustomerMasterInput = Pick<GQL.CreateCustomerMutationVariables, 'phone' | 'telegramId'> & {
  masterId: GQL.Scalars['ID']['input'];
  operation: 'add' | 'remove';
};

export async function updateCustomerMaster(input: AddCustomerMasterInput) {
  if (!input.phone && !input.telegramId) throw new Error('Missing phone and telegramId');

  const { query } = await getClientWithToken();

  const response = await query({
    query: GQL.GetCustomerMastersDocument,
    variables: input,
  });

  const customer = response?.data?.customers?.at(0);

  if (customer) {
    let newMastersIds = customer.masters.map((x) => x?.documentId);

    switch (input.operation) {
      case 'add':
        if (newMastersIds.includes(input.masterId)) return;
        newMastersIds = [...newMastersIds, input.masterId];
        break;
      case 'remove':
        newMastersIds = newMastersIds.filter((x) => x !== input.masterId);
        break;
      default:
        break;
    }

    return updateCustomerProfile({
      documentId: customer.documentId,
      data: {
        masters: newMastersIds,
      },
    });
  }
}

export async function updateCustomerProfile(input: GQL.UpdateCustomerProfileMutationVariables) {
  const { mutate } = await getClientWithToken();

  return mutate({
    mutation: GQL.UpdateCustomerProfileDocument,
    variables: input,
  });
}