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.

24.1 KB
Raw Blame
import type { UrqlQueryOptions } from '@app/lib/urql-solid';
import type { CacheHost, ReadRecordsByKeysArgs } from '@graphql-cache/index';
import { INITIAL_CACHE_REVISION } from '@graphql-cache/index';
import type {
  ItemPreviewDetailsFieldsFragment,
  ItemPreviewFieldsFragment,
  ItemPreviewQuery,
  ItemPreviewQueryVariables,
  ItemPreviewsQuery,
} from '@service-storage/graphql/generated/graphql';
import { type Accessor, createRoot, createSignal } from 'solid-js';
import { createStore } from 'solid-js/store';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';

const createUrqlQueryMock = vi.hoisted(() => vi.fn());
const getGraphqlSoupCacheHostMock = vi.hoisted(() => vi.fn());
const getGraphqlSoupClientMock = vi.hoisted(() => vi.fn());

vi.mock('@app/lib/urql-solid', () => ({
  createUrqlQuery: createUrqlQueryMock,
}));

vi.mock('@service-storage/client', () => ({ DEFAULT_ITEM_TYPE: 'document' }));

vi.mock('@service-storage/graphql-soup', () => ({
  getGraphqlSoupCacheHost: getGraphqlSoupCacheHostMock,
  getGraphqlSoupClient: getGraphqlSoupClientMock,
  mapGraphqlProperties: (properties: unknown[]) => properties,
}));

import {
  createGraphqlItemPreviewQuery,
  getGraphqlItemPreview,
  graphqlRecordToPreview,
  isGraphqlPreviewItem,
  readCachedGraphqlItemPreviewFromHost,
  setGraphqlPreviewFileType,
  setGraphqlPreviewName,
  setGraphqlPreviewOnCreate,
} from '../graphql';
import type { ItemEntity } from '../types';

type PreviewQueryOptions = UrqlQueryOptions<
  ItemPreviewQuery | ItemPreviewsQuery,
  ItemPreviewQueryVariables
>;

function trackPreviewBatches() {
  const options: PreviewQueryOptions[] = [];
  createUrqlQueryMock.mockImplementation(
    (getOptions: Accessor<PreviewQueryOptions>) => {
      options.push(getOptions());
      return {
        data: undefined,
        error: null,
        isError: false,
        isFetched: false,
        isFetching: false,
        isLoading: false,
        isEnabled: true,
        stale: false,
        refetch: vi.fn(async () => undefined),
      };
    }
  );
  return options;
}

beforeEach(() => {
  vi.useFakeTimers();
  getGraphqlSoupClientMock.mockReturnValue({});
  getGraphqlSoupCacheHostMock.mockReturnValue(undefined);
  createUrqlQueryMock.mockClear();
});
afterEach(() => vi.useRealTimers());

function cacheHost(
  read: (
    args: ReadRecordsByKeysArgs
  ) => Promise<Array<{ recordKey: string; record: unknown }>>
): Pick<CacheHost, 'readRecordsByKeys'> {
  return {
    readRecordsByKeys: async (args) => ({
      revision: INITIAL_CACHE_REVISION,
      records: await read(args),
    }),
  };
}

describe('GraphQL item previews', () => {
  it('maps normalized document fields without the full Soup projection', () => {
    const record = {
      __typename: 'GraphqlSoupDocument',
      id: 'doc-1',
      displayName: 'Roadmap',
      documentName: 'Roadmap',
      fileType: 'md',
      subType: {
        __typename: 'GraphqlTaskSubType',
        isCompleted: true,
      },
    } satisfies ItemPreviewFieldsFragment;

    expect(graphqlRecordToPreview(record)).toEqual({
      id: 'doc-1',
      type: 'document',
      access: 'access',
      loading: false,
      rawName: 'Roadmap',
      name: 'Roadmap',
      fileType: 'md',
      subType: { type: 'task', is_completed: true },
    });
  });

  it('carries loaded-empty properties and permission on the preview', () => {
    const record = {
      __typename: 'GraphqlSoupDocument',
      id: 'task-1',
      displayName: 'Task',
      documentName: 'Task',
      fileType: 'md',
      subType: null,
      properties: [],
      viewerPermission: {
        __typename: 'GraphqlAccessLevelPermission',
        accessLevel: 'EDIT',
      },
    } satisfies ItemPreviewDetailsFieldsFragment;
    expect(graphqlRecordToPreview(record)).toMatchObject({
      documentMetadata: { properties: [], canEdit: true },
    });
    expect(
      graphqlRecordToPreview({ ...record, viewerPermission: null })
    ).toMatchObject({ documentMetadata: { canEdit: false } });
  });

  it('shares a live rich query, keyed cache read, and refresh for multiple previews', async () => {
    const read = vi.fn(async () => []);
    getGraphqlSoupCacheHostMock.mockReturnValue(cacheHost(read));
    const [result, setResult] = createStore({
      data: undefined as ItemPreviewQuery | undefined,
      error: null,
      isError: false,
      isFetched: false,
      isFetching: true,
      isLoading: true,
      isEnabled: true,
      stale: false,
      refetch: vi.fn(async () => undefined),
    });
    createUrqlQueryMock.mockReturnValue(result);
    const { queries, dispose } = createRoot((dispose) => ({
      queries: ['one', 'two', 'one'].map((id) =>
        createGraphqlItemPreviewQuery(
          () => ({ id, type: 'document' }),
          () => true
        )
      ),
      dispose,
    }));
    try {
      expect(queries.every((q) => q.isLoading())).toBe(true);
      await vi.advanceTimersByTimeAsync(30);
      expect(createUrqlQueryMock).toHaveBeenCalledTimes(1);
      expect(read).toHaveBeenCalledTimes(1);
      const options = createUrqlQueryMock.mock.calls[0][0]();
      expect(options.query.definitions[0].name.value).toBe('ItemPreviews');
      expect(options.variables.input.initial.limit).toBe(2);
      const records = ['one', 'two'].map((id) => ({
        __typename: 'GraphqlSoupDocument' as const,
        id,
        displayName: id,
        documentName: id,
        fileType: 'md',
        subType: null,
      }));
      setResult({
        data: { user: { id: 'viewer', soup: { items: records } } },
        isFetched: true,
        isFetching: false,
        isLoading: false,
      });
      expect(queries.map((q) => q.data())).toMatchObject([
        { name: 'one' },
        { name: 'two' },
        { name: 'one' },
      ]);
      // Simulate a pushed normalized-cache update: all consumers remain live.
      setResult('data', 'user', 'soup', 'items', 0, 'displayName', 'Renamed');
      expect(queries[0].data()).toMatchObject({ name: 'Renamed' });
      expect(queries[2].data()).toMatchObject({ name: 'Renamed' });
      await Promise.all(queries.map((q) => q.refetch()));
      expect(result.refetch).toHaveBeenCalledTimes(1);
    } finally {
      dispose();
    }
  });

  it('treats a user envelope without soup items as unloaded, not a throw', async () => {
    const [result, setResult] = createStore({
      data: { user: { id: 'viewer' } } as ItemPreviewQuery,
      error: null,
      isError: false,
      isFetched: false,
      isFetching: true,
      isLoading: true,
      isEnabled: true,
      stale: false,
      refetch: vi.fn(async () => undefined),
    });
    createUrqlQueryMock.mockReturnValue(result);

    const { query, dispose } = createRoot((dispose) => ({
      query: createGraphqlItemPreviewQuery(
        () => ({ id: 'doc-1', type: 'document' }),
        () => true
      ),
      dispose,
    }));

    try {
      await vi.advanceTimersByTimeAsync(30);
      expect(query.data()).toBeUndefined();
      expect(query.shouldFallback()).toBe(false);
      setResult({
        isFetched: true,
        isFetching: false,
        isLoading: false,
      });
      expect(query.data()).toBeUndefined();
      expect(query.shouldFallback()).toBe(true);
    } finally {
      dispose();
    }
  });

  it('isolates missing records and partial errors within a heterogeneous batch', async () => {
    const [result] = createStore({
      data: {
        user: {
          id: 'viewer',
          soup: {
            items: [
              {
                __typename: 'GraphqlSoupProject' as const,
                id: 'same',
                displayName: 'Project',
                projectName: 'Project',
              },
              {
                __typename: 'GraphqlSoupDocument' as const,
                id: 'same',
                displayName: 'Document',
                documentName: 'Document',
                fileType: 'md',
                subType: null,
              },
            ],
          },
        },
      },
      error: new Error('A sibling resolver failed'),
      isError: true,
      isFetched: true,
      isFetching: false,
      isLoading: false,
      isEnabled: true,
      stale: false,
      refetch: vi.fn(async () => undefined),
    });
    createUrqlQueryMock.mockReturnValue(result);
    const { queries, dispose } = createRoot((dispose) => ({
      queries: [
        createGraphqlItemPreviewQuery(
          () => ({ id: 'same', type: 'document' }),
          () => true
        ),
        createGraphqlItemPreviewQuery(
          () => ({ id: 'same', type: 'project' }),
          () => true
        ),
        createGraphqlItemPreviewQuery(
          () => ({ id: 'missing', type: 'document' }),
          () => true
        ),
      ],
      dispose,
    }));
    await vi.advanceTimersByTimeAsync(30);
    expect(queries[0].data()).toMatchObject({ name: 'Document' });
    expect(queries[1].data()).toMatchObject({ name: 'Project' });
    expect(queries.map((query) => query.shouldFallback())).toEqual([
      false,
      false,
      true,
    ]);
    dispose();
    await queries[0].refetch();
    expect(result.refetch).not.toHaveBeenCalled();
  });

  it('uses a cached viewer-relative direct-message name when available', () => {
    const record = {
      __typename: 'GraphqlSoupChannel',
      id: 'channel-1',
      displayName: 'Jordan',
      channelDisplayName: null,
      channelType: 'DIRECT_MESSAGE',
    } satisfies ItemPreviewFieldsFragment;

    expect(graphqlRecordToPreview(record)).toMatchObject({
      type: 'channel',
      rawName: 'Jordan',
      channelType: 'direct_message',
    });
  });

  it('leaves unnamed direct messages on the viewer-relative REST path', () => {
    const record = {
      __typename: 'GraphqlSoupChannel',
      id: 'channel-1',
      displayName: null,
      channelDisplayName: null,
      channelType: 'DIRECT_MESSAGE',
    } satisfies ItemPreviewFieldsFragment;

    expect(graphqlRecordToPreview(record)).toBeUndefined();
  });

  it('maps an initiative record to a task project preview', () => {
    const record = {
      __typename: 'GraphqlSoupInitiative',
      id: 'initiative-1',
      displayName: 'Roadmap',
    } satisfies ItemPreviewFieldsFragment;

    expect(graphqlRecordToPreview(record)).toEqual({
      id: 'initiative-1',
      type: 'initiative',
      access: 'access',
      loading: false,
      rawName: 'Roadmap',
      name: 'Roadmap',
    });
  });

  it('reads the exact normalized key through the minimal fragment', async () => {
    const readRecordsByKeys = vi.fn(async (args: ReadRecordsByKeysArgs) => [
      {
        recordKey: args.keys[0],
        record: {
          __typename: 'GraphqlSoupProject',
          id: 'project-1',
          displayName: 'Launch',
          projectName: 'Launch',
        },
      },
    ]);

    await expect(
      readCachedGraphqlItemPreviewFromHost(cacheHost(readRecordsByKeys), {
        id: 'project-1',
        type: 'project',
      })
    ).resolves.toMatchObject({
      id: 'project-1',
      type: 'project',
      rawName: 'Launch',
    });

    expect(readRecordsByKeys).toHaveBeenCalledWith(
      expect.objectContaining({
        keys: ['GraphqlSoupProject:project-1'],
        fragmentName: 'ItemPreviewFields',
      })
    );
    expect(readRecordsByKeys.mock.calls[0]?.[0].document).not.toContain(
      'properties'
    );
  });

  it('only rejoins a batch when entity identity or enabled state changes', async () => {
    const options = trackPreviewBatches();
    const { setItem, setEnabled, query, dispose } = createRoot((dispose) => {
      const [item, setItem] = createSignal<ItemEntity>({ id: 'doc-1' });
      const [enabled, setEnabled] = createSignal(true);
      const query = createGraphqlItemPreviewQuery(item, enabled);
      return { setItem, setEnabled, query, dispose };
    });
    try {
      expect(options).toHaveLength(0);
      await vi.advanceTimersByTimeAsync(30);
      expect(options).toHaveLength(1);

      setItem({ id: 'doc-1' });
      setItem({ id: 'doc-1', type: 'document' });
      await vi.advanceTimersByTimeAsync(30);
      expect(options).toHaveLength(1);

      setItem({ id: 'doc-2', type: 'document' });
      await vi.advanceTimersByTimeAsync(30);
      expect(options).toHaveLength(2);
      expect(
        options.at(-1)?.variables?.input.initial?.filters?.documentFilter
      ).toEqual({ literal: { id: 'doc-2' } });

      setItem({ id: 'doc-2', type: 'chat' });
      await vi.advanceTimersByTimeAsync(30);
      expect(options).toHaveLength(3);
      expect(
        options.at(-1)?.variables?.input.initial?.filters?.chatFilter
      ).toEqual({ literal: { chatId: 'doc-2' } });

      setEnabled(false);
      expect(query.isEnabled()).toBe(false);
      await vi.advanceTimersByTimeAsync(30);
      expect(options).toHaveLength(3);
      setEnabled(true);
      expect(query.isEnabled()).toBe(true);
      await vi.advanceTimersByTimeAsync(30);
      expect(options).toHaveLength(4);
      expect(options.at(-1)?.requestPolicy).toBe('cache-and-network');
    } finally {
      dispose();
    }
  });

  it('snapshots reactive props and preserves channel-message REST exceptions', async () => {
    const options = trackPreviewBatches();
    const { setItem, query, dispose } = createRoot((dispose) => {
      const [item, setItem] = createStore({
        id: 'channel-1',
        type: 'channel' as const,
        messageId: undefined as string | undefined,
      });
      const query = createGraphqlItemPreviewQuery(
        () => item,
        () => true
      );
      return { setItem, query, dispose };
    });
    try {
      await vi.advanceTimersByTimeAsync(30);
      expect(options).toHaveLength(1);
      expect(query.isEnabled()).toBe(true);

      setItem('id', 'channel-2');
      await vi.advanceTimersByTimeAsync(30);
      expect(options).toHaveLength(2);
      expect(
        options.at(-1)?.variables?.input.initial?.filters?.channelFilter
      ).toEqual({ literal: { channelId: 'channel-2' } });

      setItem('messageId', 'message-1');
      expect(query.isEnabled()).toBe(false);
      await vi.advanceTimersByTimeAsync(30);
      expect(options).toHaveLength(2);
      setItem('messageId', 'message-2');
      await vi.advanceTimersByTimeAsync(30);
      expect(options).toHaveLength(2);
      expect(query.isEnabled()).toBe(false);

      setItem('messageId', undefined);
      expect(query.isEnabled()).toBe(true);
      await vi.advanceTimersByTimeAsync(30);
      expect(options).toHaveLength(3);
    } finally {
      dispose();
    }
  });

  it('holds creation grace before the asynchronous cache seed is readable', async () => {
    vi.useFakeTimers();
    let finishWrite!: () => void;
    const write = new Promise<void>((resolve) => {
      finishWrite = resolve;
    });
    getGraphqlSoupCacheHostMock.mockReturnValue({
      disabled: false,
      writeQuery: () => write,
      readRecordsByKeys: async () => ({
        revision: INITIAL_CACHE_REVISION,
        records: [],
      }),
    });
    const [result] = createStore({
      data: undefined,
      error: null,
      isError: false,
      isFetched: true,
      isFetching: false,
      isLoading: false,
      isEnabled: true,
      stale: false,
      refetch: vi.fn(async () => undefined),
    });
    createUrqlQueryMock.mockReturnValue(result);

    try {
      const seed = setGraphqlPreviewOnCreate(
        {
          itemId: 'new-doc',
          itemType: 'document',
          name: 'New document',
          fileType: 'md',
        },
        'user-1'
      );

      createRoot((dispose) => {
        const query = createGraphqlItemPreviewQuery(
          () => ({ id: 'new-doc', type: 'document' }),
          () => true
        );

        vi.advanceTimersByTime(30);
        expect(query.data()).toBeUndefined();
        expect(query.shouldFallback()).toBe(false);
        dispose();
      });

      finishWrite();
      await seed;
    } finally {
      vi.runAllTimers();
      vi.useRealTimers();
    }
  });

  it('keeps an established REST fallback selected during GraphQL refresh', () => {
    getGraphqlSoupCacheHostMock.mockReturnValue(undefined);
    const [result, setResult] = createStore({
      data: undefined as ItemPreviewQuery | undefined,
      error: null,
      isError: false,
      isFetched: true,
      isFetching: false,
      isLoading: false,
      isEnabled: true,
      stale: false,
      refetch: vi.fn(async () => undefined),
    });
    createUrqlQueryMock.mockReturnValue(result);

    createRoot((dispose) => {
      const query = createGraphqlItemPreviewQuery(
        () => ({ id: 'missing-doc', type: 'document' }),
        () => true
      );

      vi.advanceTimersByTime(30);
      expect(query.shouldFallback()).toBe(true);
      setResult({ isFetching: true });
      expect(query.shouldFallback()).toBe(true);
      setResult({
        data: {
          user: {
            id: 'user-1',
            soup: {
              items: [
                {
                  __typename: 'GraphqlSoupDocument',
                  id: 'missing-doc',
                  displayName: 'Now available',
                  documentName: 'Now available',
                  fileType: 'md',
                  subType: null,
                },
              ],
            },
          },
        },
        isFetched: true,
        isFetching: false,
      });
      expect(query.shouldFallback()).toBe(false);
      dispose();
    });
  });

  it('returns from REST fallback when a delayed cache read succeeds', async () => {
    let finishRead!: (
      records: Array<{ recordKey: string; record: unknown }>
    ) => void;
    const read = new Promise<Array<{ recordKey: string; record: unknown }>>(
      (resolve) => {
        finishRead = resolve;
      }
    );
    getGraphqlSoupCacheHostMock.mockReturnValue(cacheHost(() => read));
    const [result] = createStore({
      data: undefined as ItemPreviewQuery | undefined,
      error: { networkError: new Error('offline') },
      isError: true,
      isFetched: true,
      isFetching: false,
      isLoading: false,
      isEnabled: true,
      stale: false,
      refetch: vi.fn(async () => undefined),
    });
    createUrqlQueryMock.mockReturnValue(result);

    const { query, dispose } = createRoot((dispose) => ({
      query: createGraphqlItemPreviewQuery(
        () => ({ id: 'cached-doc', type: 'document' }),
        () => true
      ),
      dispose,
    }));

    try {
      await vi.advanceTimersByTimeAsync(30);
      expect(query.shouldFallback()).toBe(true);
      finishRead([
        {
          recordKey: 'GraphqlSoupDocument:cached-doc',
          record: {
            __typename: 'GraphqlSoupDocument',
            id: 'cached-doc',
            displayName: 'Cached document',
            documentName: 'Cached document',
            fileType: 'md',
            subType: null,
          },
        },
      ]);

      await vi.waitFor(() => {
        expect(query.data()).toMatchObject({ name: 'Cached document' });
        expect(query.shouldFallback()).toBe(false);
      });
    } finally {
      dispose();
    }
  });

  it('bypasses cached access state for security-sensitive lookups', async () => {
    getGraphqlSoupCacheHostMock.mockClear();
    const query = vi.fn(() => ({
      toPromise: async () => ({
        data: {
          user: {
            soup: {
              items: [
                {
                  __typename: 'GraphqlSoupDocument',
                  id: 'doc-1',
                  displayName: 'Roadmap',
                  documentName: 'Roadmap',
                  fileType: 'md',
                  subType: null,
                },
              ],
            },
          },
        },
      }),
    }));
    getGraphqlSoupClientMock.mockReturnValue({ query });

    await expect(
      getGraphqlItemPreview(
        { id: 'doc-1', type: 'document' },
        { requireFresh: true }
      )
    ).resolves.toMatchObject({ access: 'access', name: 'Roadmap' });

    expect(getGraphqlSoupCacheHostMock).not.toHaveBeenCalled();
    expect(query).toHaveBeenCalledWith(expect.anything(), expect.anything(), {
      requestPolicy: 'network-only',
    });
  });

  it.each([
    { type: 'document', nameKey: 'documentName' },
    { type: 'chat', nameKey: 'chatName' },
    { type: 'project', nameKey: 'projectName' },
    { type: 'channel', nameKey: 'channelDisplayName' },
    { type: 'call', nameKey: 'customName' },
    { type: 'crm_company', nameKey: 'companyName' },
    { type: 'email', nameKey: 'emailName' },
  ] as const)(
    'optimistic $type rename writes $nameKey, not only displayName',
    async ({ type, nameKey }) => {
      const writes: Parameters<CacheHost['writeQuery']>[0][] = [];
      getGraphqlSoupCacheHostMock.mockReturnValue({
        disabled: false,
        writeQuery: async (write: Parameters<CacheHost['writeQuery']>[0]) => {
          writes.push(write);
        },
      });

      await setGraphqlPreviewName(
        { id: 'rename-target', type },
        'Renamed',
        'viewer'
      );

      expect(writes).toHaveLength(1);
      const write = writes[0];
      const data = write.data as {
        user: { soup: { items: Array<Record<string, unknown>> } };
      };
      const target = data.user.soup.items.find(
        (item) => item.id === 'rename-target'
      );
      expect(target).toMatchObject({
        displayName: 'Renamed',
        [nameKey]: 'Renamed',
      });
    }
  );

  it('writes optimistic patches and complete creation records to normalized cache', async () => {
    vi.useFakeTimers();
    const writeQuery = vi.fn(async () => undefined);
    getGraphqlSoupCacheHostMock.mockReturnValue({
      disabled: false,
      writeQuery,
    });

    try {
      await setGraphqlPreviewName(
        { id: 'doc-1', type: 'document' },
        'Renamed',
        'user-1'
      );
      await setGraphqlPreviewFileType('doc-1', 'pdf', 'user-1');
      await setGraphqlPreviewOnCreate(
        {
          itemId: 'doc-2',
          itemType: 'document',
          name: 'Created',
          fileType: 'md',
          subType: { type: 'task', is_completed: false },
        },
        'user-1'
      );

      expect(writeQuery).toHaveBeenNthCalledWith(
        1,
        expect.objectContaining({
          operationName: 'ItemPreviewNameCacheWrite',
          data: {
            user: {
              id: 'user-1',
              soup: {
                items: [
                  expect.objectContaining({
                    __typename: 'GraphqlSoupDocument',
                    id: 'doc-1',
                    displayName: 'Renamed',
                  }),
                ],
              },
            },
          },
        })
      );
      expect(writeQuery).toHaveBeenNthCalledWith(
        2,
        expect.objectContaining({
          operationName: 'ItemPreviewFileTypeCacheWrite',
          data: {
            user: {
              id: 'user-1',
              soup: {
                items: [
                  {
                    __typename: 'GraphqlSoupDocument',
                    id: 'doc-1',
                    fileType: 'pdf',
                  },
                ],
              },
            },
          },
        })
      );
      expect(writeQuery).toHaveBeenNthCalledWith(
        3,
        expect.objectContaining({
          operationName: 'ItemPreview',
          data: {
            user: {
              id: 'user-1',
              soup: {
                items: [
                  expect.objectContaining({
                    __typename: 'GraphqlSoupDocument',
                    id: 'doc-2',
                    displayName: 'Created',
                    documentName: 'Created',
                    fileType: 'md',
                    subType: {
                      __typename: 'GraphqlTaskSubType',
                      isCompleted: false,
                    },
                  }),
                ],
              },
            },
          },
        })
      );
    } finally {
      vi.runAllTimers();
      vi.useRealTimers();
    }
  });

  it('keeps unsupported and enriched preview variants off GraphQL', () => {
    expect(
      isGraphqlPreviewItem({ id: 'event-1', type: 'calendar_event' })
    ).toBe(false);
    expect(
      isGraphqlPreviewItem({
        id: 'channel-1',
        type: 'channel',
        messageId: 'message-1',
      })
    ).toBe(false);
    expect(isGraphqlPreviewItem({ id: 'doc-1', type: 'document' })).toBe(true);
  });
});