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.

7.9 KB
Raw Blame
import { fireAndForget } from '@core/util/fireAndForget';
import { thrownResultErrorHasCode } from '@core/util/result';
import {
  type DraftLifecycleChange,
  publishDraftLifecycleChange,
  subscribeToDraftLifecycleChanges,
} from '@queries/email/draft-lifecycle-events';
import { emailKeys } from '@queries/email/keys';
import { fetchFreshEmailThread } from '@queries/email/thread';
import type { ApiMessage } from '@service-email/generated/schemas';
import {
  type QueryKey,
  queryOptions,
  useQuery,
  useQueryClient,
} from '@tanstack/solid-query';
import { createSignal, onCleanup } from 'solid-js';
import type {
  EmailDraftLifecycleSource,
  EmailDraftLifecycleState,
} from '../context/compose-capabilities';

const EDITING_REFRESH_INTERVAL_MS = 15_000;
const DUE_REFRESH_INTERVAL_MS = 2_000;
const FAR_SCHEDULE_REFRESH_INTERVAL_MS = 30_000;
let nextObserverId = 0;

export { publishDraftLifecycleChange };

export function deriveEmailDraftLifecycle(input: {
  draftId: string;
  threadId: string;
  inboxId?: string;
  message?: ApiMessage;
  observedAt?: number;
}): EmailDraftLifecycleState {
  const observedAt = input.observedAt ?? Date.now();
  const message = input.message;
  if (!message || (input.inboxId && message.link_id !== input.inboxId)) {
    return {
      type: 'missing',
      draftId: input.draftId,
      threadId: input.threadId,
      inboxId: input.inboxId,
      observedAt,
    };
  }
  const identity = {
    draftId: input.draftId,
    threadId: message.thread_db_id,
    inboxId: message.link_id,
    observedAt,
  };
  if (message.is_sent || !message.is_draft) {
    return { type: 'sent', ...identity };
  }
  if (message.scheduled_send_time) {
    return {
      type: 'scheduled',
      ...identity,
      sendTime: message.scheduled_send_time,
      deliveryStatus: message.scheduled_send_status ?? undefined,
    };
  }
  return { type: 'editing', ...identity };
}

async function fetchLifecycle(input: {
  draftId: string;
  threadId: string;
  inboxId?: string;
}): Promise<EmailDraftLifecycleState> {
  const observedAt = Date.now();
  try {
    const thread = await fetchFreshEmailThread(input.threadId, input.draftId);
    return deriveEmailDraftLifecycle({
      ...input,
      observedAt,
      message: thread.messages.find(
        (message) => message.db_id === input.draftId
      ),
    });
  } catch (error) {
    if (thrownResultErrorHasCode(error, 'NOT_FOUND')) {
      return deriveEmailDraftLifecycle({ ...input, observedAt });
    }
    throw error;
  }
}

function refreshInterval(state: EmailDraftLifecycleState | undefined) {
  if (!state || state.type === 'editing') return EDITING_REFRESH_INTERVAL_MS;
  if (state.type !== 'scheduled') return false;
  const untilSend = new Date(state.sendTime).getTime() - Date.now();
  return untilSend > FAR_SCHEDULE_REFRESH_INTERVAL_MS
    ? FAR_SCHEDULE_REFRESH_INTERVAL_MS
    : DUE_REFRESH_INTERVAL_MS;
}

type DraftIdentity = Parameters<typeof fetchLifecycle>[0];
/** The observer's latest refresh; a read started before it is stale. */
type RefreshVersion = { current: number };

async function readLifecycle(identity: DraftIdentity, version: RefreshVersion) {
  const started = version.current;
  const state = await fetchLifecycle(identity);
  return { state, version: started };
}

function lifecycleReadOptions(
  queryKey: QueryKey,
  identity: DraftIdentity,
  version: RefreshVersion
) {
  return {
    queryKey,
    queryFn: () => readLifecycle(identity, version),
    staleTime: 0,
  };
}

function lifecycleQueryOptions(
  queryKey: QueryKey,
  identity: DraftIdentity,
  version: RefreshVersion
) {
  return queryOptions({
    ...lifecycleReadOptions(queryKey, identity, version),
    enabled: identity.draftId.length > 0 && identity.threadId.length > 0,
    refetchOnWindowFocus: 'always',
    refetchOnReconnect: 'always',
    refetchInterval: (stateQuery) =>
      refreshInterval(
        stateQuery.state.data?.version === version.current
          ? stateQuery.state.data.state
          : undefined
      ),
  });
}

export const emailDraftLifecycleSource: EmailDraftLifecycleSource = {
  observe(input) {
    const queryClient = useQueryClient();
    const observerId = ++nextObserverId;
    // Keep the shared prefix for websocket invalidation, but never share a
    // pending read or cancellation with another composer or a previous mount.
    const observerQueryKey = (
      draftId: string,
      threadId: string,
      inboxId?: string
    ) =>
      [
        ...emailKeys.composeDraftState({ draftId, threadId, inboxId }).queryKey,
        observerId,
      ] as const;
    const [refreshing, setRefreshing] = createSignal<{
      draftId: string;
      threadId: string;
      inboxId?: string;
    }>();
    const refreshVersion: RefreshVersion = { current: 0 };
    const [requiredReadVersion, setRequiredReadVersion] = createSignal(0);
    const query = useQuery(() => {
      const draftId = input.draftId() ?? '';
      const threadId = input.threadId() ?? '';
      const inboxId = input.inboxId();
      return lifecycleQueryOptions(
        observerQueryKey(draftId, threadId, inboxId),
        { draftId, threadId, inboxId },
        refreshVersion
      );
    });

    const refresh = async () => {
      const draftId = input.draftId();
      const threadId = input.threadId();
      const inboxId = input.inboxId();
      if (!draftId || !threadId) return undefined;

      const version = ++refreshVersion.current;
      // Once a mutation needs reconciliation, no earlier observation is
      // authoritative again, even if the fresh read fails or query-store
      // notifications are delayed. A later successful poll can satisfy this
      // barrier without relying on wall-clock timestamp resolution.
      setRequiredReadVersion(version);
      setRefreshing({ draftId, threadId, inboxId });
      const queryKey = observerQueryKey(draftId, threadId, inboxId);
      try {
        // refetch({ cancelRefetch: true }) still shares an initial pending
        // read. Explicit cancellation prevents its late result from entering
        // this observer's cache; the REST query below starts independently.
        await queryClient.cancelQueries({ queryKey, exact: true });
        const result = await queryClient.fetchQuery(
          lifecycleReadOptions(
            queryKey,
            { draftId, threadId, inboxId },
            refreshVersion
          )
        );
        return version === refreshVersion.current &&
          result.version === version &&
          draftId === input.draftId() &&
          threadId === input.threadId() &&
          inboxId === input.inboxId()
          ? result.state
          : undefined;
      } finally {
        if (version === refreshVersion.current) setRefreshing(undefined);
      }
    };

    const refreshFromEvent = async (event: DraftLifecycleChange) => {
      if (event.draftId !== input.draftId()) return;
      if (event.inboxId && event.inboxId !== input.inboxId()) return;
      try {
        await refresh();
      } catch {
        // Background failures remain query errors and retry on the next event/poll.
      }
    };
    const unsubscribe = subscribeToDraftLifecycleChanges((event) =>
      fireAndForget(refreshFromEvent(event), 'email-compose')
    );
    onCleanup(unsubscribe);

    // A cached terminal state can predate undo-send or a draft migration.
    // Only a successful read made by this observer can change the composer.
    const state = () => {
      const pending = refreshing();
      if (
        pending?.draftId === input.draftId() &&
        pending?.threadId === input.threadId() &&
        pending?.inboxId === input.inboxId()
      )
        return undefined;
      if (!query.isSuccess || !query.isFetchedAfterMount) return undefined;
      const observation = query.data;
      return observation.version === requiredReadVersion()
        ? observation.state
        : undefined;
    };
    return {
      state,
      refresh,
      refreshIdentity: (identity) => fetchLifecycle(identity),
    };
  },
};