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.

19.0 KB
Raw Blame
import { renameDatabase } from '@block-database/queries/rename-database';
import { renameItem } from '@core/component/FileList/itemOperations';
import { toast } from '@core/component/Toast/Toast';
import {
  enableGraphqlSoup,
  isFeatureEnabled,
} from '@core/constant/featureFlags';
import { fireAndForget } from '@core/util/fireAndForget';
import { optimisticMutationDispositionOf } from '@graphql-cache/exchange/optimistic';
import { renameAgentSession } from '@queries/agent-session/entity-mutations';
import { callKeys } from '@queries/call/keys';
import { channelKeys } from '@queries/channel/keys';
import { queryClient } from '@queries/client';
import { setHistoryItemName } from '@queries/history/history';
import { historyKeys } from '@queries/history/keys';
import { setPreviewName } from '@queries/preview';
import { refreshActiveGraphqlPreviewQueries } from '@queries/preview/active-queries';
import {
  getSoupEntityById,
  optimisticUpdateSoupEntity,
  type SoupTransaction,
} from '@queries/soup/cache';
import { refreshActiveGraphqlSoupQueries } from '@queries/soup/graphql/active-queries';
import { soupKeys } from '@queries/soup/keys';
import { ownTouchStamp } from '@queries/soup/normalized-cache/own-touch';
import { type MutationCallbacks, withCallbacks } from '@queries/utils';
import type { CallRecord } from '@service-call/client';
import type { ApiChannelWithLatest } from '@service-storage/channel-list-types';
import type { ItemType } from '@service-storage/client';
import { ChannelTypeEnum } from '@service-storage/client';
import {
  type GraphqlEntityType,
  RenameEntitiesDocument,
  type RenameEntitiesMutation,
  type RenameEntitiesMutationVariables,
} from '@service-storage/graphql/generated/graphql';
import {
  getEntityGraphqlClient,
  getGraphqlCacheHost,
} from '@service-storage/graphql-soup';
import { useMutation } from '@tanstack/solid-query';
import type { EntityData } from '../types/entity';

type RenamableEntity = Pick<EntityData, 'id' | 'type' | 'name'> &
  Partial<EntityData>;

type EntityRenameOperation = {
  entity: RenamableEntity;
  newName: string;
};

type EntityRenameOperationResult = {
  success: boolean;
  queued?: boolean;
};

// Keyed by the full entity identity so heterogeneous or duplicate IDs cannot
// overwrite another operation's rollback transaction.
type SoupTransactionMap = Map<string, SoupTransaction>;

type RenameRollbackContext = {
  soupTransactions: SoupTransactionMap;
};

type EntityRenameData = {
  id: string;
  itemType: EntityData['type'];
  oldName: string;
  newName: string;
};

type EntityRenameOptimisticInfo = Omit<EntityRenameData, 'oldName'>;

type RenameDssEntityMutationVariables = EntityRenameOperation;

type BulkRenameDssEntityMutationVariables = RenameDssEntityMutationVariables[];

type RenameDssEntityMutationData = EntityRenameOperationResult;

type BulkRenameDssEntityMutationData = RenameDssEntityMutationData[];

const MAX_ENTITY_MUTATION_BATCH = 100;

const soupTransactionKey = (itemType: ItemType, id: string): string =>
  `${itemType}:${id}`;

const validateBulkRename = (
  params: BulkRenameDssEntityMutationVariables
): void => {
  const seen = new Set<string>();
  for (const { entity } of params) {
    validateEntityRename(entity);
    const key = `${entity.type}:${entity.id}`;
    if (seen.has(key)) {
      throw new Error(`Bulk rename contains duplicate entity ${key}`);
    }
    seen.add(key);
  }
};

type RenameOnMutateResult = {
  contexts: RenameRollbackContext;
  updates: EntityRenameData[];
};

const getEntityRenameData = (
  operation: EntityRenameOperation
): EntityRenameData | null => {
  const { entity, newName } = operation;
  // crm companies/contacts aren't renamable and have no storage item type.
  // Reminders aren't either — the entity-mutation router rejects them, and a
  // reminder's name is its description, edited through the reminders API.
  // Calendar event titles are edited through the calendar mutation API.
  // Databases go through `renameDatabase` (not Soup optimism); forms through
  // `renameForm` on the form block.
  if (
    entity.type === 'crm_company' ||
    entity.type === 'crm_contact' ||
    entity.type === 'calendar_event' ||
    entity.type === 'initiative' ||
    entity.type === 'database' ||
    entity.type === 'form'
  ) {
    return null;
  }
  return {
    id: entity.id,
    itemType: entity.type,
    oldName: entity.name,
    newName,
  };
};

const performEntityRename = async (operation: EntityRenameOperation) => {
  if (operation.entity.type === 'database') {
    if (operation.newName.trim() === operation.entity.name) {
      return { success: true };
    }
    const renamed = await renameDatabase(
      getEntityGraphqlClient(),
      operation.entity.id,
      operation.newName
    );
    if (renamed.isErr()) {
      console.error('Failed to rename database', renamed.error);
    }
    return { success: renamed.isOk() };
  }
  const data = getEntityRenameData(operation);
  if (!data) return { success: false };
  if (data.itemType === 'agent_session') {
    await renameAgentSession(data.id, data.newName);
    return { success: true };
  }
  const success = await renameItem(data);
  return { success };
};

function graphqlRenameType(
  entity: RenamableEntity
): GraphqlEntityType | undefined {
  switch (entity.type) {
    case 'document':
      return 'DOCUMENT';
    case 'chat':
      return 'CHAT';
    case 'project':
      return 'PROJECT';
    case 'channel':
      return 'CHANNEL';
    case 'call':
      return 'CALL';
    default:
      return undefined;
  }
}

async function performGraphqlRenames(
  operations: EntityRenameOperation[]
): Promise<RenameDssEntityMutationData[]> {
  const inputs = operations.map(({ entity, newName }) => {
    const type = graphqlRenameType(entity);
    if (!type) throw new Error(`Unsupported GraphQL rename: ${entity.type}`);
    return {
      entity: { type, id: entity.id },
      displayName: newName,
    };
  });
  const uuid = crypto.randomUUID();
  const settlement = observeRenameSettlement(uuid, operations);
  let queued = false;
  try {
    const result = await getEntityGraphqlClient()
      .mutation<RenameEntitiesMutation, RenameEntitiesMutationVariables>(
        RenameEntitiesDocument,
        { inputs },
        { optimisticMutation: { uuid } }
      )
      .toPromise();
    const disposition = optimisticMutationDispositionOf(result);
    if (disposition?.kind === 'queued') {
      queued = true;
      return operations.map(() => ({ success: true, queued: true }));
    }
    if (disposition?.kind === 'permanently-failed') throw disposition.error;
    if (result.error) throw result.error;
    if (!result.data) throw new Error('GraphQL rename returned no data');
    return result.data.renameEntities.results.map((result) => ({
      success: result.__typename === 'GraphqlMutationSuccess',
    }));
  } finally {
    if (!queued) settlement.complete();
  }
}

/** Legacy readers refetch confirmed state; the normalized layer owns optimism. */
function observeRenameSettlement(
  uuid: string,
  operations: EntityRenameOperation[]
) {
  const host = getGraphqlCacheHost();
  let finished = false;
  let unsubscribe: (() => void) | undefined;
  let unsubscribeReset: (() => void) | undefined;
  const dispose = () => {
    unsubscribe?.();
    unsubscribeReset?.();
  };
  const refresh = async () => {
    const requests = [
      queryClient.invalidateQueries({ queryKey: historyKeys.list.queryKey }),
      queryClient.invalidateQueries({ queryKey: soupKeys._def }),
    ];
    if (operations.some(({ entity }) => entity.type === 'channel'))
      requests.push(
        queryClient.invalidateQueries({
          queryKey: channelKeys.listChannels.queryKey,
        })
      );
    for (const { entity } of operations) {
      if (entity.type === 'call')
        requests.push(
          queryClient.invalidateQueries({
            queryKey: callKeys.record(entity.id).queryKey,
          })
        );
      if (!host || host.disabled)
        requests.push(refreshActiveGraphqlPreviewQueries(entity.id));
    }
    if (!host || host.disabled)
      requests.push(refreshActiveGraphqlSoupQueries());
    await Promise.allSettled(requests);
  };
  const complete = () => {
    if (finished) return;
    finished = true;
    dispose();
    fireAndForget(refresh(), 'entity-rename');
  };
  unsubscribe = host?.onMutationSettled((settlement) => {
    if (settlement.mutationUuid === uuid && settlement.status !== 'superseded')
      complete();
  });
  unsubscribeReset = host?.onCacheGenerationChanged((change) => {
    if (change.storage === 'reset') {
      finished = true;
      dispose();
    }
  });
  return { complete };
}

const validateEntityRename = (entity: RenamableEntity): void => {
  switch (entity.type) {
    case 'channel':
      // NOTE: channel type is undefined if provided from the split modal due to casting in createEntityData
      if (entity.channelType === ChannelTypeEnum.DirectMessage) {
        throw new Error('Direct messages do not support renaming');
      }
      break;
    case 'agent_session':
    case 'document':
    case 'chat':
    case 'project':
    case 'call':
    case 'database':
      return;
    case 'foreign':
      throw new Error('Foreign entities do not support renaming');
    default:
      throw new Error(`Unsupported entity type: ${entity.type}`);
  }
};

const renameDssSetData = (
  entities: EntityRenameOptimisticInfo[]
): SoupTransactionMap => {
  const txns: SoupTransactionMap = new Map();
  // A rename is an Edited activity, i.e. a touch (own-touch.ts).
  for (const { id, itemType, newName } of entities) {
    const current = getSoupEntityById(id);
    const score = current?.frecency_score ?? 0;
    if (itemType === 'channel') {
      txns.set(
        soupTransactionKey(itemType, id),
        optimisticUpdateSoupEntity({
          tag: 'channel',
          data: { channel: { id, name: newName } },
          frecency_score: score,
          touched_at: ownTouchStamp(id),
        })
      );
    } else if (itemType === 'call') {
      txns.set(
        soupTransactionKey(itemType, id),
        optimisticUpdateSoupEntity({
          tag: 'call',
          data: { callId: id, customName: newName },
          frecency_score: score,
        })
      );
    } else if (
      itemType !== 'email' &&
      itemType !== 'channel_message' &&
      itemType !== 'channel_thread' &&
      itemType !== 'routine' &&
      itemType !== 'calendar_event' &&
      itemType !== 'foreign' &&
      itemType !== 'database' &&
      itemType !== 'form' &&
      // CRM companies/contacts aren't renamed via the FileList path (their
      // names derive from the directory/email, and their soup tags are
      // camelCase 'crmCompany'/'crmContact', not these snake-case itemTypes).
      itemType !== 'crm_company' &&
      itemType !== 'crm_contact'
    ) {
      txns.set(
        soupTransactionKey(itemType, id),
        optimisticUpdateSoupEntity({
          tag: itemType === 'agent_session' ? 'agentSession' : itemType,
          data: { id, name: newName },
          frecency_score: score,
          touched_at: ownTouchStamp(id),
        })
      );
    }
  }
  return txns;
};

const renameChannelSetData = (entities: EntityRenameOptimisticInfo[]): void => {
  const channelUpdates = entities.filter(
    ({ itemType }) => itemType === 'channel'
  );
  if (channelUpdates.length === 0) return;

  queryClient.setQueryData<ApiChannelWithLatest[]>(
    channelKeys.listChannels.queryKey,
    (prev) => {
      if (!prev) return prev;
      return prev.map((channel) => {
        const update = channelUpdates.find(({ id }) => id === channel.id);
        if (!update) return channel;
        return { ...channel, name: update.newName };
      });
    }
  );
};

const renameCallRecordSetData = (
  entities: EntityRenameOptimisticInfo[]
): void => {
  entities.forEach(({ id, newName, itemType }) => {
    if (itemType !== 'call') return;
    queryClient.setQueryData<CallRecord>(
      callKeys.record(id).queryKey,
      (prev) => {
        if (!prev) return prev;
        return { ...prev, customName: newName };
      }
    );
  });
};

const renamePreviewSetData = (entities: EntityRenameOptimisticInfo[]) => {
  entities.forEach(({ id, newName, itemType }) => {
    // Calendar event previews are API-served projections keyed to the
    // viewer's copy; renames flow through calendar mutations instead.
    if (itemType === 'calendar_event') return;
    setPreviewName({
      itemId: id,
      name: newName,
      itemType,
    });
  });
};

const renameHistorySetData = (entities: EntityRenameOptimisticInfo[]) => {
  entities.forEach(({ id, newName }) => {
    setHistoryItemName(id, newName);
  });
};

function performOptimisticRenameUpdates(
  entities: EntityRenameOptimisticInfo[]
): RenameRollbackContext {
  // A durable queued write can fail after the mutation callback has returned.
  // Only REST operations may write the legacy caches before confirmation.
  if (isFeatureEnabled(enableGraphqlSoup))
    entities = entities.filter(
      ({ id, itemType, newName }) =>
        !graphqlRenameType({ id, type: itemType, name: newName })
    );
  renamePreviewSetData(entities);
  renameHistorySetData(entities);
  renameChannelSetData(entities);
  renameCallRecordSetData(entities);
  const soupTransactions = renameDssSetData(entities);

  return { soupTransactions };
}

function rollbackOptimisticRenameUpdates({
  contexts,
  updates,
}: RenameOnMutateResult): void {
  for (const [, txn] of contexts.soupTransactions) {
    txn.rollback();
  }

  const rollbackEntities = updates
    .filter(({ id, itemType }) =>
      contexts.soupTransactions.has(soupTransactionKey(itemType, id))
    )
    .map(({ id, oldName, itemType }) => ({
      id,
      itemType,
      newName: oldName,
    }));

  renameHistorySetData(rollbackEntities);
  renamePreviewSetData(rollbackEntities);
  renameChannelSetData(rollbackEntities);
  renameCallRecordSetData(rollbackEntities);
}

const bulkRenameMutationFn = async (
  params: BulkRenameDssEntityMutationVariables
): Promise<BulkRenameDssEntityMutationData> => {
  validateBulkRename(params);

  if (!isFeatureEnabled(enableGraphqlSoup)) {
    return await Promise.all(params.map(performEntityRename));
  }

  const results: Array<RenameDssEntityMutationData | undefined> = new Array(
    params.length
  );
  const graphqlOperations = params
    .map((operation, index) => ({ operation, index }))
    .filter(({ operation }) => graphqlRenameType(operation.entity));
  const legacyOperations = params
    .map((operation, index) => ({ operation, index }))
    .filter(({ operation }) => !graphqlRenameType(operation.entity));
  if (graphqlOperations.length > MAX_ENTITY_MUTATION_BATCH) {
    throw new Error(
      `Bulk rename accepts at most ${MAX_ENTITY_MUTATION_BATCH} GraphQL entities`
    );
  }

  const [graphqlResults, legacyResults] = await Promise.all([
    graphqlOperations.length > 0
      ? performGraphqlRenames(
          graphqlOperations.map(({ operation }) => operation)
        ).catch((error) => {
          console.error('GraphQL rename batch failed', error);
          return graphqlOperations.map(() => ({ success: false }));
        })
      : Promise.resolve([]),
    Promise.all(
      legacyOperations.map(async ({ operation }) => {
        try {
          return await performEntityRename(operation);
        } catch (error) {
          console.error('Legacy rename failed', operation, error);
          return { success: false };
        }
      })
    ),
  ]);
  graphqlOperations.forEach(({ index }, resultIndex) => {
    results[index] = graphqlResults[resultIndex];
  });
  legacyOperations.forEach(({ index }, resultIndex) => {
    results[index] = legacyResults[resultIndex];
  });

  return results.map((result) => result ?? { success: false });
};

const bulkRenameOnMutate = (
  params: BulkRenameDssEntityMutationVariables
): RenameOnMutateResult => {
  // TanStack runs onMutate before mutationFn. Validate before the first cache
  // write so an invalid batch cannot require a best-effort rollback.
  validateBulkRename(params);
  const updates = params
    .map(getEntityRenameData)
    .filter((d): d is EntityRenameData => d !== null);
  const contexts = performOptimisticRenameUpdates(updates);
  return { contexts, updates };
};

const bulkRenameOnSettled = (
  data: BulkRenameDssEntityMutationData | undefined,
  error: Error | null,
  params: BulkRenameDssEntityMutationVariables,
  onMutateResult: RenameOnMutateResult | undefined
): void => {
  const hasFailed = !!error || data?.some((d) => !d.success);
  if (!hasFailed) return;

  console.error(`Failed rename`, params, data, error);
  toast.failure('Failed to rename');

  if (!onMutateResult) {
    // most likely nothing to rollback, but it's possible there were mutations that succeeded before the OnMutate failed
    // TODO: refetch everything to be safe
    return;
  }

  // rollback everything if we can't identify specific failures
  if (!data) {
    rollbackOptimisticRenameUpdates(onMutateResult);
    return;
  }

  // Rollback only the failed items by entity ID
  const failedUpdates: EntityRenameData[] = [];
  const failedSoupTransactions: SoupTransactionMap = new Map();

  data.forEach((result, index) => {
    if (!result.success) {
      const { entity } = params[index];
      const update = onMutateResult.updates.find(
        ({ id, itemType }) => id === entity.id && itemType === entity.type
      );
      if (update) {
        failedUpdates.push(update);
        const key = soupTransactionKey(update.itemType, update.id);
        const txn = onMutateResult.contexts.soupTransactions.get(key);
        if (txn) failedSoupTransactions.set(key, txn);
      }
    }
  });

  // Rollback only the failed items
  if (failedUpdates.length > 0) {
    rollbackOptimisticRenameUpdates({
      contexts: {
        soupTransactions: failedSoupTransactions,
      },
      updates: failedUpdates,
    });
  }
};

/** Supports channel/document/chat/project/call/agent-session/database rename. */
export function createRenameDssEntityMutation(
  callbacks?: MutationCallbacks<
    RenameDssEntityMutationData,
    Error,
    RenameDssEntityMutationVariables,
    RenameOnMutateResult
  >
) {
  return useMutation<
    RenameDssEntityMutationData,
    Error,
    RenameDssEntityMutationVariables,
    RenameOnMutateResult
  >(() => ({
    mutationFn: async (params) => (await bulkRenameMutationFn([params]))[0],
    ...withCallbacks<
      RenameDssEntityMutationData,
      Error,
      RenameDssEntityMutationVariables,
      RenameOnMutateResult
    >(
      {
        onMutate: async (params) => bulkRenameOnMutate([params]),
        onSettled: (data, error, params, onMutateResult) => {
          bulkRenameOnSettled(
            data ? [data] : undefined,
            error,
            [params],
            onMutateResult
          );
        },
      },
      callbacks
    ),
  }));
}

/** Supports channel/document/chat/project/call/agent-session/database bulk rename. */
export function createBulkRenameDssEntityMutation() {
  return useMutation<
    BulkRenameDssEntityMutationData,
    Error,
    BulkRenameDssEntityMutationVariables,
    RenameOnMutateResult
  >(() => ({
    mutationFn: bulkRenameMutationFn,
    onMutate: bulkRenameOnMutate,
    onSettled: bulkRenameOnSettled,
  }));
}