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.

9.3 KB
Raw Blame
import type {
  EmailDraftAggregateFieldsFragment,
  SaveEmailDraftMutation,
} from '@service-storage/graphql/generated/graphql';

export type DraftThread = SaveEmailDraftMutation['saveEmailDraft']['thread'];
type Aggregate = EmailDraftAggregateFieldsFragment;
type DraftState = NonNullable<DraftThread['mailDraftState']>;
type DraftMessage = SaveEmailDraftMutation['saveEmailDraft']['draft'];

/** The typename keys the preview as its own normalized record. */
function draftPreview(draft: DraftMessage): NonNullable<
  DraftThread['mailDraftPreview']
> & {
  __typename: 'GraphqlMailPreviewMessage';
} {
  return {
    __typename: 'GraphqlMailPreviewMessage',
    id: draft.id,
    subject: draft.subject,
    snippet: draft.snippet,
    isDraft: true,
    senderEmail: draft.from?.email ?? null,
    senderName: draft.from?.name ?? null,
    senderPhotoUrl: draft.from?.photoUrl ?? null,
  };
}

/** What one local draft contributes to its thread's aggregated Mail state. A
 * draft returns its thread to the inbox only as a reply to received mail. */
function draftAggregateEntry(
  draft: DraftMessage,
  isSignal: boolean,
  hasReceivedMail: boolean
): DraftState['drafts'][number] {
  return {
    id: draft.id,
    macroDraft: true,
    facts: {
      ...emptyAggregate(),
      messageCount: 1,
      inboxVisible: hasReceivedMail,
      isSignal,
      latestInboundMessageTs: hasReceivedMail ? draft.updatedAt : null,
      latestNonSpamMessageTs: draft.updatedAt,
      preview: draftPreview(draft),
      previewTs: draft.internalDateTs ?? draft.createdAt,
    },
  };
}

/** Complete local thread, checked against both Soup and thread-page selections. */
export function createDraftThread(
  draft: DraftMessage,
  ownerId: string,
  isSignal: boolean
): DraftThread {
  const preview = draftPreview(draft);
  return {
    __typename: 'GraphqlSoupEmailThread',
    id: draft.threadId,
    entityType: 'EMAIL_THREAD',
    ownerId,
    linkId: draft.linkId,
    providerId: null,
    cacheProjection: null,
    displayName: draft.subject,
    emailName: draft.subject,
    snippet: draft.snippet,
    senderEmail: preview.senderEmail,
    senderName: preview.senderName,
    senderPhotoUrl: preview.senderPhotoUrl,
    inboxVisible: false,
    hasReceivedMail: false,
    isRead: true,
    isDraft: true,
    isSignal,
    isImportant: isSignal,
    isFavorited: false,
    projectId: null,
    createdAt: draft.createdAt,
    updatedAt: draft.updatedAt,
    latestInboundMessageTs: null,
    latestOutboundMessageTs: null,
    latestNonSpamMessageTs: draft.updatedAt,
    reminderReturnedAt: null,
    viewedAt: null,
    frecencyScore: null,
    mailAllPreview: preview,
    mailDraftPreview: preview,
    mailSentPreview: null,
    participants: [],
    attachments: [],
    labels: [],
    properties: [],
    notifications: [],
    viewerPermission: {
      __typename: 'GraphqlAccessLevelPermission',
      accessLevel: 'OWNER',
    },
    mailDraftState: {
      baseline: emptyAggregate(),
      drafts: [draftAggregateEntry(draft, isSignal, false)],
    },
    messages: [draft],
  };
}

function emptyAggregate(): Aggregate {
  return {
    messageCount: 0,
    inboxVisible: false,
    isRead: true,
    isSignal: false,
    hasCalendarAttachment: false,
    latestInboundMessageTs: null,
    latestNonSpamMessageTs: null,
    latestOutboundMessageTs: null,
    preview: null,
    previewTs: null,
  };
}

function latest(a: string | null, b: string | null): string | null {
  if (!a) return b;
  if (!b) return a;
  return Date.parse(a) >= Date.parse(b) ? a : b;
}

/** Server preview ordering is creation/internal time, then message ID. */
function mergeAggregate(a: Aggregate, b: Aggregate): Aggregate {
  const bIsLater =
    b.preview !== null &&
    (a.preview === null ||
      Date.parse(b.previewTs!) > Date.parse(a.previewTs!) ||
      (Date.parse(b.previewTs!) === Date.parse(a.previewTs!) &&
        b.preview.id > a.preview.id));
  return {
    messageCount: a.messageCount + b.messageCount,
    inboxVisible: a.inboxVisible || b.inboxVisible,
    isRead: a.isRead && b.isRead,
    isSignal: a.isSignal || b.isSignal,
    hasCalendarAttachment: a.hasCalendarAttachment || b.hasCalendarAttachment,
    latestInboundMessageTs: latest(
      a.latestInboundMessageTs,
      b.latestInboundMessageTs
    ),
    latestNonSpamMessageTs: latest(
      a.latestNonSpamMessageTs,
      b.latestNonSpamMessageTs
    ),
    latestOutboundMessageTs: latest(
      a.latestOutboundMessageTs,
      b.latestOutboundMessageTs
    ),
    preview: bIsLater ? b.preview : a.preview,
    previewTs: bIsLater ? b.previewTs : a.previewTs,
  };
}

function applyDraftState(
  existing: DraftThread,
  state: DraftState,
  updatedAt: string
): DraftThread {
  const drafts = state.drafts.reduce(
    (sum, entry) => mergeAggregate(sum, entry.facts),
    emptyAggregate()
  );
  const all = mergeAggregate(state.baseline, drafts);
  // A provider draft in junk can remain in Drafts, but cannot supply All Mail's
  // preview. Each draft's non-spam timestamp records that eligibility.
  const allPreview = state.drafts.reduce(
    (sum, entry) =>
      entry.facts.latestNonSpamMessageTs === null
        ? sum
        : mergeAggregate(sum, entry.facts),
    state.baseline
  ).preview;
  // Read/unread mutations can update the canonical thread before the message
  // aggregate is refreshed. Preserve that newer intent across draft edits;
  // otherwise deleting the sole unread draft still recomputes the read state.
  const previousState = existing.mailDraftState;
  const previousIsRead =
    previousState &&
    previousState.baseline.isRead &&
    previousState.drafts.every((entry) => entry.facts.isRead);
  const hasNewerReadIntent =
    previousState !== null && existing.isRead !== previousIsRead;
  return {
    ...existing,
    mailDraftState: state,
    updatedAt,
    latestInboundMessageTs: all.latestInboundMessageTs,
    latestOutboundMessageTs: all.latestOutboundMessageTs,
    latestNonSpamMessageTs: all.latestNonSpamMessageTs,
    inboxVisible: all.inboxVisible,
    isDraft: drafts.preview !== null,
    isRead: hasNewerReadIntent ? existing.isRead : all.isRead,
    isSignal: all.isSignal,
    isImportant: all.isSignal,
    displayName: allPreview?.subject ?? null,
    emailName: allPreview?.subject ?? null,
    snippet: allPreview?.snippet ?? null,
    senderEmail: allPreview?.senderEmail ?? null,
    senderName: allPreview?.senderName ?? null,
    senderPhotoUrl: allPreview?.senderPhotoUrl ?? null,
    mailAllPreview: allPreview,
    mailDraftPreview: drafts.preview,
  };
}

/** Preserve conversation state while replacing only this draft's contribution. */
export function updateDraftThread(
  existing: DraftThread,
  draft: DraftMessage,
  isSignal: boolean
): DraftThread {
  // Older cache entries may lack the complete baseline. Preserve their facts;
  // never infer the unseen message history from a paginated message list.
  if (!existing.mailDraftState)
    return {
      ...existing,
      messages: [
        draft,
        ...existing.messages.filter((message) => message.id !== draft.id),
      ],
    };
  const previous = existing.mailDraftState.drafts.find(
    (entry) => entry.id === draft.id
  );
  // Cache entries written before the field existed lack it; the server's
  // default for unrecomputed threads is that they have received mail.
  const hasReceivedMail = existing.hasReceivedMail !== false;
  const fresh = draftAggregateEntry(draft, isSignal, hasReceivedMail);
  const entry = previous
    ? {
        ...previous,
        facts: {
          ...previous.facts,
          isRead: true,
          isSignal: previous.facts.preview ? isSignal : false,
          inboxVisible: previous.macroDraft
            ? fresh.facts.inboxVisible
            : previous.facts.inboxVisible,
          latestInboundMessageTs: previous.macroDraft
            ? fresh.facts.latestInboundMessageTs
            : previous.facts.latestInboundMessageTs,
          latestNonSpamMessageTs:
            previous.macroDraft &&
            previous.facts.latestNonSpamMessageTs !== null
              ? draft.updatedAt
              : previous.facts.latestNonSpamMessageTs,
          preview: previous.facts.preview ? fresh.facts.preview : null,
        },
      }
    : fresh;
  const next = applyDraftState(
    existing,
    {
      ...existing.mailDraftState,
      drafts: [
        ...existing.mailDraftState.drafts.filter(
          (entry) => entry.id !== draft.id
        ),
        entry,
      ],
    },
    draft.updatedAt
  );
  return {
    ...next,
    messages: [
      draft,
      ...existing.messages.filter((message) => message.id !== draft.id),
    ],
  };
}

/** Discard restores the full non-draft baseline, even beyond message page one. */
export function removeDraftFromThread(
  existing: DraftThread,
  draftId: string
): DraftThread | undefined {
  if (!existing.mailDraftState) return;
  const next = applyDraftState(
    existing,
    {
      ...existing.mailDraftState,
      drafts: existing.mailDraftState.drafts.filter(
        (entry) => entry.id !== draftId
      ),
    },
    new Date().toISOString()
  );
  return {
    ...next,
    messages: existing.messages.filter((message) => message.id !== draftId),
  };
}

export function draftThreadIsEmpty(thread: DraftThread): boolean {
  const state = thread.mailDraftState;
  return (
    !!state && state.baseline.messageCount === 0 && state.drafts.length === 0
  );
}