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.

17.6 KB
Raw Blame
import {
  createTagFacetContext,
  EMPTY_TAG_FACET_CONTEXT,
} from '@app/features/soup';
import type { EntityData, WithNotification } from '@entity';
import { makeGraphqlSoupInput } from '@queries/soup/graphql/ast';
import type { TagSetResponse } from '@service-properties/generated/schemas/tagSetResponse';
import { describe, expect, it, vi } from 'vitest';
import { EMAIL_TAB_IDS } from '../constants';
import type { EmailTab } from '../types';
import {
  buildEmailQuery,
  type EmailQueryContext,
  emailViewForTab,
} from './email-query';
import { groupEmailEntitiesByDate } from './email-results';
import { buildEmailSearchRequest } from './email-search';

vi.mock('@app/features/soup', async () => ({
  ...(await import('@app/features/soup/filters')),
}));
vi.mock('@entity', async () => ({
  ...(await import('@entity/types/entity')),
  ...(await import('@entity/utils/notification')),
  ...(await import('@entity/utils/task-properties')),
  ...(await import('@entity/utils/company-properties')),
}));
vi.mock('@notifications', async () => await import('@notifications/types'));

// The soup barrel these pull in transitively imports the websocket client
// modules, which open real sockets at module scope and reject under jsdom.
vi.mock('@service-storage/websocket', () => ({
  storageWS: { reconnectIfDisconnected: vi.fn() },
  createWebSocketJob: vi.fn(),
}));
vi.mock('@service-connection/websocket', () => ({
  ws: { addEventListener: vi.fn(), send: vi.fn() },
  state: () => 'closed',
  createConnectionBlockWebsocketEffect: vi.fn(),
  createConnectionWebsocketEffect: vi.fn(),
}));

const NIL = '00000000-0000-0000-0000-000000000000';

const serialize = (value: unknown) => JSON.stringify(value);

const contextFor = (
  overrides: Partial<EmailQueryContext> = {}
): EmailQueryContext => ({
  tab: 'all',
  inboxIds: undefined,
  facets: {},
  facetContext: EMPTY_TAG_FACET_CONTEXT,
  ...overrides,
});

const TAG_SETS = [
  {
    scope: 'user',
    definition: { id: 'tag-definition' },
    options: [
      {
        id: 'invoices',
        propertyDefinitionId: 'tag-definition',
        displayOrder: 0,
        value: { type: 'string', value: 'Invoices' },
      },
    ],
  },
] as TagSetResponse[];

describe('buildEmailQuery', () => {
  it('scopes alias mail by inbox and exact address in every direction before pagination', () => {
    const args = buildEmailQuery(
      contextFor({
        aliasFilter: {
          inboxId: 'owner-inbox',
          emailAddress: '[email protected]',
        },
      })
    );
    const tree = serialize(
      makeGraphqlSoupInput(args).initial?.filters?.emailFilter
    );
    expect(tree).toContain(serialize({ literal: { owner: 'owner-inbox' } }));
    for (const direction of ['sender', 'recipient', 'cc', 'bcc']) {
      expect(tree).toContain(
        serialize({
          literal: { [direction]: { complete: '[email protected]' } },
        })
      );
    }
    expect(tree).not.toContain('partial');
  });
  it('filters favorites on the server in both Soup transports, including inbox and read scope', () => {
    const args = buildEmailQuery(
      contextFor({
        tab: 'favorites',
        favoriteThreadIds: ['starred-a', 'starred-b'],
        inboxIds: ['inbox-a'],
        facets: { read: ['unread'] },
      })
    );
    expect(args.transport).toBeUndefined();
    expect(args.body.emailView).toBe('all');
    expect(args.body.favorites_only).toBe(true);
    expect(serialize(args.body)).not.toContain('starred-a');
    const input = makeGraphqlSoupInput(args);
    expect(input.initial?.emailView).toBe('ALL');
    const filter = serialize(input.initial?.filters?.emailFilter);
    expect(input.initial?.filters?.favoritesOnly).toBe(true);
    expect(filter).toContain(serialize({ literal: { owner: 'inbox-a' } }));
    expect(filter).toContain(serialize({ literal: { read: false } }));
    expect(filter).not.toContain('inboxVisible');
  });

  it('keeps the Soup query identical as favorite membership changes', () => {
    const args = buildEmailQuery(contextFor({ tab: 'favorites' }));
    for (const favoriteThreadIds of [[], ['a'], ['a', 'b']]) {
      expect(
        buildEmailQuery(contextFor({ tab: 'favorites', favoriteThreadIds }))
      ).toEqual(args);
    }
    expect(args.body.favorites_only).toBe(true);
    const admitted = buildEmailQuery(
      contextFor({ tab: 'favorites', facets: { read: ['unread'] } }),
      ['a']
    );
    expect(admitted.body.favorites_only).toBe(true);
    expect(serialize(admitted.body.ef)).toContain('a');
    expect(serialize(admitted.body.ef)).not.toContain('Read');
  });

  it('keeps a full admission batch below REST and GraphQL ingress recursion limits', () => {
    const ids = Array.from(
      { length: 100 },
      (_, index) =>
        `00000000-0000-0000-0000-${String(index + 1).padStart(12, '0')}`
    );
    const args = buildEmailQuery(
      contextFor({ tab: 'important', facets: { read: ['unread'] } }),
      ids
    );
    const graphql = makeGraphqlSoupInput({ ...args, cursor: null });
    const depth = (value: unknown): number =>
      value && typeof value === 'object'
        ? 1 + Math.max(0, ...Object.values(value).map(depth))
        : 0;
    expect(depth(args.body)).toBeLessThan(40);
    expect(depth(graphql)).toBeLessThan(40);
    for (const id of ids) expect(serialize(graphql)).toContain(id);
    expect(serialize(args.body.ef)).not.toContain('"Read"');
  });

  it('lists the server view each tab reads from', () => {
    expect(EMAIL_TAB_IDS.map((tab) => [tab, emailViewForTab(tab)])).toEqual([
      ['important', 'inbox'],
      ['noise', 'inbox'],
      ['favorites', 'all'],
      ['sent', 'sent'],
      ['scheduled', 'drafts'],
      ['reminders', 'all'],
      ['calendar', 'all'],
      ['drafts', 'drafts'],
      ['shared', 'all'],
      ['archived', 'all'],
      ['all', 'all'],
      ['focus', 'all'],
      ['spam', 'spam'],
      ['trash', 'trash'],
    ]);

    for (const tab of EMAIL_TAB_IDS) {
      expect(buildEmailQuery(contextFor({ tab })).body.emailView).toBe(
        emailViewForTab(tab)
      );
    }
  });

  it.each(['spam', 'trash'] as const)(
    'keeps %s in its provider folder with inbox and alias scope',
    (tab) => {
      const args = buildEmailQuery(
        contextFor({
          tab,
          inboxIds: ['inbox-a'],
          aliasFilter: {
            inboxId: 'inbox-a',
            emailAddress: '[email protected]',
          },
        })
      );
      expect(args.transport).toBe('rest');
      expect(args.body.emailView).toBe(tab);
      expect(serialize(args.body.ef)).toContain('inbox-a');
      expect(serialize(args.body.ef)).toContain('[email protected]');
    }
  );

  it('confines every non-email target to nothing', () => {
    const { body } = buildEmailQuery(contextFor());

    expect(body.df).toEqual({ l: { id: NIL } });
    expect(body.chanf).toEqual({ l: { ChannelId: NIL } });
    expect(body.cthf).toEqual({ l: { ChannelId: NIL } });
    expect(body.cf).toEqual({ l: { cid: NIL } });
    expect(body.pf).toEqual({ l: { pid: NIL } });
    expect(body.calf).toEqual({ l: { id: NIL } });
    expect(body.callf).toEqual({ l: { CallId: NIL } });
    expect(body.fef).toEqual({ l: { id: NIL } });
    expect(body.ccf).toEqual({ l: { id: NIL } });
    expect(body.ef).toEqual({ '!': { l: { ThreadId: NIL } } });
  });

  it('scopes Signal and Noise by importance and excludes shared threads', () => {
    const signal = serialize(
      buildEmailQuery(contextFor({ tab: 'important' })).body.ef
    );
    const noise = serialize(
      buildEmailQuery(contextFor({ tab: 'noise' })).body.ef
    );

    expect(signal).toContain(serialize({ l: { Importance: true } }));
    expect(signal).toContain(serialize({ l: { Shared: 'exclude' } }));
    expect(noise).toContain(serialize({ l: { Importance: false } }));
    expect(noise).toContain(serialize({ l: { Shared: 'exclude' } }));
  });

  it('scopes Calendar to invite threads and Shared to shared threads', () => {
    const calendar = serialize(
      buildEmailQuery(contextFor({ tab: 'calendar' })).body.ef
    );
    const shared = buildEmailQuery(contextFor({ tab: 'shared' })).body.ef;

    expect(calendar).toContain(serialize({ l: { CalendarOnly: true } }));
    expect(calendar).toContain(serialize({ l: { Shared: 'exclude' } }));
    expect(shared).toEqual({ l: { Shared: 'only' } });
  });

  it('lists archived mail on the All view, done and unshared', () => {
    const args = buildEmailQuery(contextFor({ tab: 'archived' }));

    expect(args.body.emailView).toBe('all');
    const ef = serialize(args.body.ef);
    expect(ef).toContain(serialize({ l: { InboxVisible: false } }));
    expect(ef).toContain(serialize({ l: { Shared: 'exclude' } }));

    const input = makeGraphqlSoupInput(args);
    expect(input.initial?.emailView).toBe('ALL');
    expect(input.initial?.filters?.emailFilter).toEqual({
      tree: {
        and: {
          left: { literal: { inboxVisible: false } },
          right: { literal: { shared: 'EXCLUDE' } },
        },
      },
    });
  });

  it('leaves the inbox unscoped when every inbox is selected', () => {
    const { body } = buildEmailQuery(contextFor());

    expect(serialize(body.ef)).not.toContain('Owner');
  });

  it('ORs the selected inbox owners', () => {
    const { body } = buildEmailQuery(
      contextFor({ inboxIds: ['link-a', 'link-b'] })
    );

    expect(body.ef).toEqual({
      '&': [
        { '!': { l: { ThreadId: NIL } } },
        { '|': [{ l: { Owner: 'link-a' } }, { l: { Owner: 'link-b' } }] },
      ],
    });
  });

  it('matches nothing when no inbox is selected', () => {
    const { body } = buildEmailQuery(contextFor({ inboxIds: [] }));

    expect(serialize(body.ef)).toContain(serialize({ l: { Owner: NIL } }));
  });

  it('refines by the read, done, and calendar facets on the server', () => {
    const ef = (facets: EmailQueryContext['facets']) =>
      serialize(buildEmailQuery(contextFor({ facets })).body.ef);

    expect(ef({ read: ['unread'] })).toContain(
      serialize({ l: { Read: false } })
    );
    expect(ef({ read: ['read'] })).toContain(serialize({ l: { Read: true } }));
    expect(ef({ done: ['done'] })).toContain(
      serialize({ l: { InboxVisible: false } })
    );
    expect(ef({ done: ['not-done'] })).toContain(
      serialize({ l: { InboxVisible: true } })
    );
    expect(ef({ done: ['done'] })).not.toContain('NotificationState');
    expect(ef({ calendar: ['has-calendar-invite'] })).toContain(
      serialize({ l: { CalendarOnly: true } })
    );
  });

  it('leaves attachment facets to the client', () => {
    const plain = buildEmailQuery(contextFor()).body;
    const withAttachments = buildEmailQuery(
      contextFor({ facets: { attachments: ['attachment-pdf'] } })
    ).body;

    expect(withAttachments).toEqual(plain);
  });

  it('refines by selected tags as a property filter', () => {
    const facetContext = createTagFacetContext(TAG_SETS);
    const { propf } = buildEmailQuery(
      contextFor({ facets: { tags: ['invoices'] }, facetContext })
    ).body;

    expect(propf).toEqual({
      l: { pd: 'tag-definition', v: { so: 'invoices' } },
    });
  });

  it('keeps an unresolved tag selection from filtering', () => {
    const plain = buildEmailQuery(contextFor()).body;
    const withUnknownTag = buildEmailQuery(
      contextFor({ facets: { tags: ['deleted-tag'] } })
    ).body;

    expect(withUnknownTag).toEqual(plain);
  });

  it('pages by latest thread activity, newest first', () => {
    expect(buildEmailQuery(contextFor()).params).toEqual({
      expand: true,
      limit: 100,
      sort_method: 'updated_at',
      sort_direction: 'desc',
    });
  });
});

describe('buildEmailSearchRequest', () => {
  const search = { query: 'invoice', matchType: 'partial' as const };

  it.each(['spam', 'trash'] as const)(
    'fails closed for %s even with retained IDs',
    (tab) => {
      expect(
        buildEmailSearchRequest(contextFor({ tab }), search, [
          'retained-thread',
        ]).body.filters?.email_filters?.email_thread_ids
      ).toEqual([NIL]);
    }
  );

  const requestFor = (overrides: Partial<EmailQueryContext> = {}) => {
    const { body } = buildEmailSearchRequest(contextFor(overrides), search);
    if (!body.filters) throw new Error('search request has no filters');

    return { ...body, filters: body.filters };
  };

  it('searches only email threads', () => {
    const body = requestFor();

    expect(body.query).toBe('invoice');
    expect(body.search_on).toBe('name_content');
    expect(body.filters.document_filters).toEqual({ document_ids: [NIL] });
    expect(body.filters.channel_filters).toEqual({ channel_ids: [NIL] });
    expect(body.filters.email_filters).toEqual({});
  });

  it('restricts search and retained results to current favorites before pagination', () => {
    const context = contextFor({
      tab: 'favorites',
      favoriteThreadIds: ['starred-a', 'starred-b'],
      inboxIds: ['inbox-a'],
    });
    expect(
      buildEmailSearchRequest(context, search).body.filters?.email_filters
    ).toEqual({
      email_thread_ids: ['starred-a', 'starred-b'],
      link_ids: ['inbox-a'],
    });
    expect(
      buildEmailSearchRequest(context, search, ['starred-b', 'removed']).body
        .filters?.email_filters?.email_thread_ids
    ).toEqual(['starred-b']);
    expect(
      requestFor({ tab: 'favorites', favoriteThreadIds: [] }).filters
        .email_filters?.email_thread_ids
    ).toEqual([NIL]);
  });

  it('mirrors the tab scoping the list applies', () => {
    const filtersFor = (tab: EmailTab) =>
      requestFor({ tab }).filters.email_filters;

    expect(filtersFor('important')).toEqual({
      importance: true,
      shared: 'exclude',
    });
    expect(filtersFor('noise')).toEqual({
      importance: false,
      shared: 'exclude',
    });
    expect(filtersFor('calendar')).toEqual({
      calendar_only: true,
      shared: 'exclude',
    });
    expect(filtersFor('shared')).toEqual({ shared: 'only' });
    expect(filtersFor('all')).toEqual({});
  });

  it('leaves Drafts and Sent search unscoped', () => {
    const filtersFor = (tab: EmailTab) =>
      requestFor({ tab }).filters.email_filters;

    // Macro-composed drafts are unindexed and unlabeled; the client trims
    // both tabs' results instead (see tabFilters).
    expect(filtersFor('drafts')).toEqual({});
    expect(filtersFor('sent')).toEqual({});
  });

  it('excludes shared threads from archived search', () => {
    const filtersFor = (tab: EmailTab) =>
      requestFor({ tab }).filters.email_filters;

    expect(filtersFor('archived')).toEqual({ shared: 'exclude' });
  });

  it('restricts to the selected inboxes', () => {
    const selected = requestFor({ inboxIds: ['link-a'] }).filters.email_filters;
    const none = requestFor({ inboxIds: [] }).filters.email_filters;

    expect(selected).toEqual({ link_ids: ['link-a'] });
    expect(none).toEqual({ link_ids: [NIL] });
  });

  it('maps email read independently of notification state selections', () => {
    const filters = requestFor({
      facets: { read: ['unread'], done: ['not-done'] },
    }).filters.email_filters;

    expect(filters).toEqual({
      is_read: false,
      notification_filters: { states: ['unseen', 'seen'] },
    });
    expect(
      requestFor({ facets: { read: ['read'] } }).filters.email_filters
    ).toEqual({ is_read: true });
    expect(
      requestFor({ facets: { read: ['read'], done: ['done'] } }).filters
        .email_filters
    ).toEqual({
      is_read: true,
      notification_filters: { states: ['done'] },
    });
  });

  it('maps the calendar facet and ignores attachment facets', () => {
    const filters = requestFor({
      facets: {
        calendar: ['has-calendar-invite'],
        attachments: ['attachment-pdf'],
      },
    }).filters.email_filters;

    expect(filters).toEqual({ calendar_only: true });
  });

  it('sends selected tags as an entity-wide filter', () => {
    const { filters } = requestFor({
      facets: { tags: ['invoices', 'invoices'] },
      facetContext: createTagFacetContext(TAG_SETS),
    });

    expect(filters.tag_option_ids).toEqual(['invoices']);
    expect(filters.tag_filter_mode).toBe('any');
    expect(filters.email_filters).toEqual({});
  });

  it('drops a selected tag that no longer exists, like the list query', () => {
    const { filters } = requestFor({
      facets: { tags: ['invoices', 'deleted-tag'] },
      facetContext: createTagFacetContext(TAG_SETS),
    });

    expect(filters.tag_option_ids).toEqual(['invoices']);

    const unresolved = requestFor({ facets: { tags: ['deleted-tag'] } });
    expect(unresolved.filters.tag_option_ids).toBeUndefined();
    expect(unresolved.filters.tag_filter_mode).toBeUndefined();
  });
});

describe('groupEmailEntitiesByDate', () => {
  const now = new Date('2026-09-03T18:00:00Z');

  const email = (
    id: string,
    stamps: Partial<Pick<EntityData, 'sortTs' | 'updatedAt' | 'createdAt'>>
  ) =>
    ({
      id,
      type: 'email',
      name: id,
      ownerId: 'macro|[email protected]',
      ...stamps,
    }) as unknown as WithNotification<EntityData>;

  it('buckets on the server sort stamp, then thread recency', () => {
    const groups = groupEmailEntitiesByDate(
      [
        // Served by the page: the sort stamp wins over the stale updatedAt.
        email('paged', {
          sortTs: '2026-09-03T17:00:00Z',
          updatedAt: '2026-08-20T09:00:00Z',
        }),
        // A websocket insert without a stamp falls back to updatedAt.
        email('inserted', { updatedAt: '2026-09-03T16:00:00Z' }),
        // Nothing but a creation time still lands in a bucket.
        email('bare', { createdAt: '2026-08-20T09:00:00Z' }),
      ],
      now
    );

    expect(groups.map((group) => group.entities.map((e) => e.id))).toEqual([
      ['paged', 'inserted'],
      ['bare'],
    ]);
  });
});