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.

14.7 KB
Raw Blame
import type { ThreadQueryData, ThreadQueryResult } from '@queries/email/thread';
import type { ApiMessage, ApiThread } from '@service-email/generated/schemas';
import { batch, createRoot, createSignal } from 'solid-js';
import { describe, expect, it, vi } from 'vitest';
import { invitationFixture } from '../../email-message/core/calendar-invitation-fixtures';

const invalidateInvitations = vi.hoisted(() => vi.fn());
vi.mock('@queries/calendar/invitations', () => ({
  invalidateInvitationScheduling: invalidateInvitations,
}));

function message(id: string, overrides: Partial<ApiMessage> = {}): ApiMessage {
  return {
    db_id: id,
    thread_db_id: 'thread',
    link_id: 'inbox',
    created_at: '2026-09-01T10:00:00Z',
    updated_at: '2026-09-01T10:00:00Z',
    to: [{ email: '[email protected]' }],
    cc: [],
    bcc: [],
    draft_generation: 0,
    attachments: [],
    attachments_draft: [],
    attachments_forwarded: [],
    labels: [],
    is_read: true,
    is_draft: false,
    is_sent: false,
    is_starred: false,
    has_attachments: false,
    ...overrides,
  };
}
function thread(messages: ApiMessage[]): ApiThread {
  return {
    db_id: 'thread',
    link_id: 'inbox',
    access_level: 'owner',
    inbox_visible: true,
    has_received_mail: true,
    is_read: true,
    created_at: '2026-09-01T10:00:00Z',
    updated_at: '2026-09-01T10:00:00Z',
    messages,
  };
}

import { createThreadSnapshot } from '../primitives/thread-snapshot';
import { createEmailThreadSource, toEmailThread } from './thread-source';

it('keeps a reopened local draft through server identity adoption and rejects another route', () =>
  createRoot((dispose) => {
    try {
      const [route, setRoute] = createSignal('local-thread');
      const [resolved, setResolved] = createSignal('local-thread');
      const [loading, setLoading] = createSignal(false);
      const local = {
        ...thread([message('local-draft', { is_draft: true })]),
        db_id: 'local-thread',
      };
      const [data, setData] = createSignal<ThreadQueryData | undefined>({
        thread: local,
        hasMore: false,
      });
      const source = createEmailThreadSource(route, {
        get resolvedThreadId() {
          return resolved();
        },
        get isSuccess() {
          return !loading();
        },
        get isLoading() {
          return loading();
        },
        isError: false,
        get data() {
          if (loading()) throw new Error('suspending resource read');
          return data();
        },
      } as ThreadQueryResult<ThreadQueryData>);
      const snapshot = createThreadSnapshot(source);
      expect(snapshot()?.messages[0].db_id).toBe('local-draft');

      // Cache subscriptions can publish the aliased record before the async
      // identity lookup observes the same settlement.
      setData({ thread: { ...local, db_id: 'server-thread' }, hasMore: false });
      expect(snapshot()?.messages[0].db_id).toBe('local-draft');

      // The route remains a durable local handle while its query changes keys.
      batch(() => {
        setResolved('server-thread');
        setLoading(true);
        setData(undefined);
      });
      expect(snapshot()?.messages[0].db_id).toBe('local-draft');
      batch(() => {
        setData({
          thread: { ...local, db_id: 'server-thread' },
          hasMore: false,
        });
        setLoading(false);
      });
      expect(source.id()).toBe('server-thread');
      expect(snapshot()?.db_id).toBe('server-thread');

      // Reopening the old route after settlement also accepts the canonical row.
      const reopened = createEmailThreadSource(route, {
        resolvedThreadId: 'server-thread',
        isSuccess: true,
        isError: false,
        data: data(),
      } as ThreadQueryResult<ThreadQueryData>);
      expect(reopened.thread()?.db_id).toBe('server-thread');
      batch(() => {
        setRoute('another-thread');
        setResolved('another-thread');
        setLoading(true);
      });
      expect(snapshot()).toBeUndefined();
    } finally {
      dispose();
    }
  }));

describe('thread query adaptation', () => {
  it('preserves saved invitations through the explicit cached message projection', () => {
    const invitations = [invitationFixture];
    expect(
      toEmailThread(
        thread([message('invite', { calendar_invitations: invitations })])
      ).messages[0].calendar_invitations
    ).toEqual(invitations);
  });
  it('guards resource reads, retains available data during refresh errors, and clears it when switching threads', () =>
    createRoot((dispose) => {
      try {
        const [id, setId] = createSignal('thread');
        const [status, setStatus] = createSignal('pending');
        const [data, setData] = createSignal<ThreadQueryData | undefined>();
        const read = vi.fn(() => {
          if (status() === 'pending')
            throw new Error('suspending resource read');
          return data();
        });
        const query = {
          get isError() {
            return status() === 'error';
          },
          get isSuccess() {
            return status() === 'success';
          },
          get isLoading() {
            return status() === 'pending';
          },
          isFetching: false,
          isFetchingNextPage: false,
          hasNextPage: true,
          get data() {
            return read();
          },
        } as unknown as ThreadQueryResult<ThreadQueryData>;
        const source = createEmailThreadSource(id, query);
        expect(source.thread()).toBeUndefined();
        expect(read).not.toHaveBeenCalled();
        const original = thread([message('first')]);
        batch(() => {
          setData({ thread: original } as ThreadQueryData);
          setStatus('success');
        });
        expect(source.thread()?.messages[0].db_id).toBe('first');
        expect(source.thread()).not.toBe(original);
        setStatus('error');
        expect(source.thread()?.db_id).toBe('thread');
        setId('other');
        expect(source.thread()).toBeUndefined();
        batch(() => {
          setData(undefined);
          setStatus('success');
        });
        expect(source.thread()).toBeUndefined();
      } finally {
        dispose();
      }
    }));
  it('owns nested message data while preserving missing versus empty HTML', () => {
    const wire = thread([
      message('one', { body_replyless: '' }),
      message('two', { body_replyless: null }),
    ]);
    const projected = toEmailThread(wire);
    expect(projected.messages.map((m) => m.body_replyless)).toEqual(['', null]);
    projected.messages[0].to[0].email = '[email protected]';
    expect(wire.messages[0].to[0].email).toBe('[email protected]');
  });
});

it('exposes cached data when the first observed query result is an error', () =>
  createRoot((dispose) => {
    try {
      const cached = thread([message('cached')]);
      const query = {
        isError: true,
        isSuccess: false,
        isLoading: false,
        data: { thread: cached, hasMore: false },
      } as ThreadQueryResult<ThreadQueryData>;
      expect(
        createEmailThreadSource(() => 'thread', query).thread()?.messages[0]
          .db_id
      ).toBe('cached');
    } finally {
      dispose();
    }
  }));

it.each(['fetchOlder', 'refresh'] as const)(
  '%s remains pending until the query request finishes',
  async (operation) => {
    const { promise: request, resolve: finish } = Promise.withResolvers<void>();
    const { source, dispose } = createRoot((dispose) => ({
      dispose,
      source: createEmailThreadSource(() => 'thread', {
        isSuccess: false,
        isError: false,
        fetchNextPage: () =>
          operation === 'fetchOlder' ? request : Promise.resolve(),
        refetch: () => (operation === 'refresh' ? request : Promise.resolve()),
      } as unknown as ThreadQueryResult<ThreadQueryData>),
    }));
    try {
      let completed = false;
      const completion = source[operation]().then(() => {
        completed = true;
      });
      await Promise.resolve();
      expect(completed).toBe(false);
      finish();
      await completion;
      expect(completed).toBe(true);
    } finally {
      dispose();
    }
  }
);

it('keeps rendering and attachment identities while excluding transport metadata', () => {
  const wire = thread([
    message('message', {
      headers_json: { transport: 'private' },
      provider_history_id: 'sync-history',
      from: { email: '[email protected]', name: 'Sender', photo_url: 'photo' },
      labels: [
        {
          created_at: 'now',
          link_id: 'inbox',
          name: 'CATEGORY_PERSONAL',
          provider_label_id: 'UNREAD',
        },
      ],
      attachments: [
        {
          db_id: 'inline',
          content_id: 'image-cid',
          sfs_id: 'file',
          mime_type: 'image/png',
          filename: 'image.png',
          size_bytes: 123,
        },
        {
          db_id: 'cloud',
          filename: 'invite.ics',
          mime_type: 'text/calendar',
          reference_url: 'https://outlook.office.com/mail/item',
        },
      ],
      attachments_draft: [
        {
          id: 'draft-file',
          draft_id: 'message',
          content_type: 'text/plain',
          file_name: 'notes.txt',
          s3_key: 'notes',
          upload_pending: false,
          is_inline: false,
          sha: 'sha',
          size: 42,
        },
      ],
      attachments_forwarded: [
        {
          attachment_id: 'forward-file',
          draft_id: 'message',
          message_provider_id: 'provider',
          provider_attachment_id: 'private-id',
          filename: 'forward.txt',
          mime_type: 'text/plain',
          size_bytes: 15,
        },
      ],
      provider_id: 'reply-provider-id',
      scheduled_send_time: '2026-10-01T12:00:00Z',
      scheduled_send_status: 'unconfirmed',
    }),
  ]);
  const projected = toEmailThread(wire).messages[0];
  expect(projected).toMatchObject({
    provider_id: 'reply-provider-id',
    scheduled_send_time: '2026-10-01T12:00:00Z',
    scheduled_send_status: 'unconfirmed',
    labels: [{ name: 'CATEGORY_PERSONAL', provider_label_id: 'UNREAD' }],
    attachments: [
      { db_id: 'inline', content_id: 'image-cid', sfs_id: 'file' },
      { db_id: 'cloud', reference_url: 'https://outlook.office.com/mail/item' },
    ],
    attachments_draft: [{ id: 'draft-file', s3_key: 'notes' }],
    attachments_forwarded: [
      { attachment_id: 'forward-file', filename: 'forward.txt' },
    ],
  });
  expect(projected).not.toHaveProperty('headers_json');
  expect(projected).not.toHaveProperty('provider_history_id');
  expect(projected.attachments_forwarded[0]).not.toHaveProperty(
    'message_provider_id'
  );
  // Feature state must not mutate the query cache's nested values.
  projected.from!.name = 'Changed';
  projected.labels[0].name = 'Changed';
  projected.attachments[0].filename = 'Changed';
  projected.attachments_draft[0].file_name = 'Changed';
  projected.attachments_forwarded[0].filename = 'Changed';
  expect(wire.messages[0].from?.name).toBe('Sender');
  expect(wire.messages[0].labels[0].name).toBe('CATEGORY_PERSONAL');
  expect(wire.messages[0].attachments[0].filename).toBe('image.png');
  expect(wire.messages[0].attachments_draft[0].file_name).toBe('notes.txt');
  expect(wire.messages[0].attachments_forwarded[0].filename).toBe(
    'forward.txt'
  );
});

it('revalidates capabilities when newer scheduling snapshots arrive in a fresh thread', async () => {
  const { setData, dispose } = createRoot((dispose) => {
    const [data, setData] = createSignal<ThreadQueryData>({
      thread: thread([
        message('old', {
          calendar_invitations: [invitationFixture],
        }),
      ]),
      hasMore: false,
    });
    createEmailThreadSource(() => 'thread', {
      isSuccess: true,
      isError: false,
      get data() {
        return data();
      },
    } as ThreadQueryResult<ThreadQueryData>);
    return { setData, dispose };
  });
  try {
    invalidateInvitations.mockClear();
    setData({
      thread: thread([
        message('old', {
          calendar_invitations: [invitationFixture],
        }),
        message('cancel', {
          calendar_invitations: [
            { ...invitationFixture, method: 'cancel', sequence: 2 },
          ],
        }),
      ]),
      hasMore: false,
    });
    await vi.waitFor(() =>
      expect(invalidateInvitations).toHaveBeenCalledExactlyOnceWith('thread')
    );
  } finally {
    dispose();
  }
});

it('does not revalidate when a thread first loads or the view switches threads', async () => {
  const withInvite = (id: string): ThreadQueryData => ({
    thread: {
      ...thread([
        message('invite', {
          thread_db_id: id,
          calendar_invitations: [invitationFixture],
        }),
      ]),
      db_id: id,
    },
    hasMore: false,
  });
  const { setId, setData, dispose } = createRoot((dispose) => {
    const [id, setId] = createSignal('thread');
    const [data, setData] = createSignal<ThreadQueryData | undefined>();
    createEmailThreadSource(id, {
      get isSuccess() {
        return data() !== undefined;
      },
      isError: false,
      get data() {
        return data();
      },
    } as ThreadQueryResult<ThreadQueryData>);
    return { setId, setData, dispose };
  });
  try {
    invalidateInvitations.mockClear();
    setData(withInvite('thread'));
    await Promise.resolve();
    batch(() => {
      setId('other');
      setData(withInvite('other'));
    });
    await Promise.resolve();
    expect(invalidateInvitations).not.toHaveBeenCalled();
  } finally {
    dispose();
  }
});

it('does not revalidate capabilities for unchanged snapshots or ordinary email changes', async () => {
  const { setData, dispose } = createRoot((dispose) => {
    const [data, setData] = createSignal<ThreadQueryData>({
      thread: thread([message('plain')]),
      hasMore: false,
    });
    createEmailThreadSource(() => 'thread', {
      isSuccess: true,
      isError: false,
      get data() {
        return data();
      },
    } as ThreadQueryResult<ThreadQueryData>);
    return { setData, dispose };
  });
  try {
    invalidateInvitations.mockClear();
    setData({
      thread: thread([message('plain', { body_text: 'Changed body' })]),
      hasMore: false,
    });
    await Promise.resolve();
    expect(invalidateInvitations).not.toHaveBeenCalled();
    const calendar_invitations = [invitationFixture];
    setData({
      thread: thread([message('invite', { calendar_invitations })]),
      hasMore: false,
    });
    await vi.waitFor(() =>
      expect(invalidateInvitations).toHaveBeenCalledOnce()
    );
    setData({
      thread: thread([
        message('invite', {
          calendar_invitations: structuredClone(calendar_invitations),
        }),
      ]),
      hasMore: false,
    });
    await Promise.resolve();
    expect(invalidateInvitations).toHaveBeenCalledOnce();
  } finally {
    dispose();
  }
});