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.

33.5 KB
Raw Blame
import type { Property } from '@property/types';
import {
  onlineManager,
  QueryClient,
  QueryClientProvider,
} from '@tanstack/solid-query';
import type { Client } from '@urql/core';
import { err, ok } from 'neverthrow';
import {
  type Accessor,
  createMemo,
  createSignal,
  type JSX,
  type Setter,
} from 'solid-js';
import { render } from 'solid-js/web';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { makeSubject, onEnd, pipe } from 'wonka';
import {
  DeleteEntityPropertyDocument,
  EntityPropertiesDocument,
} from '../../service-clients/service-storage/graphql/generated/graphql';
import { createUrqlQuery } from '../../urql-solid';
import { buildGraphqlEntitySoupInput } from '../soup/graphql/entity-input';

const useFeatureFlagMock = vi.hoisted(() => vi.fn());
const graphqlEntityPropertyMutationMock = vi.hoisted(() => vi.fn());
const createGraphqlAddEntityPropertyMutationMock = vi.hoisted(() => vi.fn());
const createGraphqlBulkSaveEntityPropertiesMutationMock = vi.hoisted(() =>
  vi.fn()
);
const buildEntityPropertiesInputMock = vi.hoisted(() => vi.fn());
const mapGraphqlEntityPropertiesMock = vi.hoisted(() => vi.fn());
const createGraphqlEntityPropertiesQueryMock = vi.hoisted(() => vi.fn());
const graphqlQueryMock = vi.hoisted(() => vi.fn());
const initiativePropertyQueryMock = vi.hoisted(() =>
  vi.fn((..._args: unknown[]) => ({ toPromise: async () => ({ data: {} }) }))
);
const initiativePropertyDeleteMock = vi.hoisted(() =>
  vi.fn(() => ({
    toPromise: async () => ({
      data: {
        deleteEntityProperty: {
          __typename: 'GraphqlCacheDeletion',
          graphqlTypeName: 'GraphqlProperty',
          entityId: 'assignment-1',
        },
      },
    }),
  }))
);

vi.mock('@service-storage/graphql-soup', () => ({
  getGraphqlSoupClient: () => ({
    query: initiativePropertyQueryMock,
    mutation: initiativePropertyDeleteMock,
  }),
}));
const getRestEntityPropertiesMock = vi.hoisted(() => vi.fn());
const deleteEntityPropertyMock = vi.hoisted(() => vi.fn());
const addEntityPropertyOptionMock = vi.hoisted(() => vi.fn());
const bulkUpdateEntityPropertyOptionsMock = vi.hoisted(() => vi.fn());
const updateGraphqlEntityPropertyOptionsMock = vi.hoisted(() => vi.fn());
const setRestEntityPropertyMock = vi.hoisted(() => vi.fn());
const isInstantiatedPropertyMock = vi.hoisted(() => vi.fn());
const entityPropertyFromApiMock = vi.hoisted(() => vi.fn());
const soupPropertyToPropertyMock = vi.hoisted(() => vi.fn());
const rollbackMock = vi.hoisted(() => vi.fn());
const optimisticUpdateSoupEntityMock = vi.hoisted(() => vi.fn());
const invalidateSoupEntityMock = vi.hoisted(() => vi.fn());
const refreshPropertyQueriesMock = vi.hoisted(() => vi.fn(async () => {}));
vi.mock('../soup/property-queries', () => ({
  refreshPropertyQueries: refreshPropertyQueriesMock,
}));
const graphqlSoupEnabledMock = vi.hoisted(() => vi.fn(() => true));
const toastFailureMock = vi.hoisted(() => vi.fn());
const trackMock = vi.hoisted(() => vi.fn());

vi.mock('@app/lib/analytics', () => ({
  analytics: { track: trackMock },
}));

vi.mock('@app/lib/analytics/posthog', () => ({
  useFeatureFlag: useFeatureFlagMock,
}));

vi.mock('@core/component/Toast/Toast', () => ({
  toast: { failure: toastFailureMock },
}));

vi.mock('@core/constant/featureFlags', () => ({
  enableGraphqlSoup: { key: 'enable-graphql-soup' },
  isFeatureEnabled: graphqlSoupEnabledMock,
}));

vi.mock('@entity/extractors-property/property-helpers', () => ({
  soupPropertyToProperty: soupPropertyToPropertyMock,
}));

vi.mock('@property/api/converters', () => ({
  entityPropertyFromApi: entityPropertyFromApiMock,
  propertyValueToApi: vi.fn(() => ({ type: 'string', value: 'doing' })),
}));

vi.mock('@property/utils', () => ({
  isInstantiatedProperty: isInstantiatedPropertyMock,
}));

vi.mock('../../service-clients/service-properties/client', () => ({
  propertiesServiceClient: {
    getEntityProperties: getRestEntityPropertiesMock,
    setEntityProperty: setRestEntityPropertyMock,
    deleteEntityProperty: deleteEntityPropertyMock,
    addEntityPropertyOption: addEntityPropertyOptionMock,
    bulkUpdateEntityPropertyOptions: bulkUpdateEntityPropertyOptionsMock,
  },
}));

vi.mock('./graphql/entity', () => ({
  refetchGraphqlInitiativeProperties: async (initiativeId: string) => {
    await initiativePropertyQueryMock(
      EntityPropertiesDocument,
      { input: buildGraphqlEntitySoupInput('INITIATIVE', initiativeId)! },
      { requestPolicy: 'network-only' }
    ).toPromise();
  },
  createGraphqlEntityPropertiesQuery: createGraphqlEntityPropertiesQueryMock,
  createGraphqlAddEntityPropertyMutation:
    createGraphqlAddEntityPropertyMutationMock,
  createGraphqlBulkSaveEntityPropertiesMutation:
    createGraphqlBulkSaveEntityPropertiesMutationMock,
}));

vi.mock('./graphql/entity-options', () => ({
  updateGraphqlEntityPropertyOptions: updateGraphqlEntityPropertyOptionsMock,
}));

vi.mock('../client', () => ({
  get queryClient() {
    return testQueryClient;
  },
}));

vi.mock('../soup/cache', () => ({
  getSoupEntityById: vi.fn(() => ({
    tag: 'document',
    data: {
      id: 'task-1',
      properties: [
        {
          id: 'assignment-1',
          definition: { id: 'status-def' },
          value: { type: 'String', value: 'todo' },
        },
      ],
    },
    frecency_score: 0,
  })),
  invalidateSoupEntity: invalidateSoupEntityMock,
  optimisticUpdateSoupEntity: optimisticUpdateSoupEntityMock.mockImplementation(
    () => ({ rollback: rollbackMock })
  ),
}));

import {
  useAddEntityPropertyMutation,
  useAddEntityPropertyOptionMutation,
  useBulkSaveEntityPropertiesMutation,
  useBulkUpdateEntityPropertyOptionsMutation,
  useDeleteEntityPropertyMutation,
  useEntityPropertiesQuery,
} from './entity';

let testQueryClient: QueryClient;
let mutation: ReturnType<typeof useBulkSaveEntityPropertiesMutation>;
let addMutation: ReturnType<typeof useAddEntityPropertyMutation>;
let deleteMutation: ReturnType<typeof useDeleteEntityPropertyMutation>;
let addOptionMutation: ReturnType<typeof useAddEntityPropertyOptionMutation>;
let bulkOptionsMutation: ReturnType<
  typeof useBulkUpdateEntityPropertyOptionsMutation
>;
let entityQuery: ReturnType<typeof useEntityPropertiesQuery>;
let dispose: (() => void) | undefined;
let setGraphqlFlagEnabled: Setter<boolean>;
let graphqlExecutions: Array<{
  variables: unknown;
  context: unknown;
  next: (result: unknown) => void;
  ended: boolean;
}>;

const property = {
  propertyId: 'assignment-1',
  propertyDefinitionId: 'status-def',
  displayName: 'Status',
  valueType: 'STRING',
  isMultiSelect: false,
  isSystemProperty: true,
} as unknown as Property;

const variables = {
  properties: [
    {
      entityId: 'task-1',
      entityType: 'TASK' as const,
      property,
      apiValues: { valueType: 'STRING' as const, value: 'doing' },
    },
  ],
};

function renderWithQueryClient(factory: () => void): void {
  const container = document.createElement('div');
  document.body.appendChild(container);
  dispose = render(
    () => (
      <QueryClientProvider client={testQueryClient}>
        {(() => {
          factory();
          return null as unknown as JSX.Element;
        })()}
      </QueryClientProvider>
    ),
    container
  );
}

function renderMutation(): void {
  renderWithQueryClient(() => {
    mutation = useBulkSaveEntityPropertiesMutation();
    addMutation = useAddEntityPropertyMutation();
    deleteMutation = useDeleteEntityPropertyMutation();
    addOptionMutation = useAddEntityPropertyOptionMutation();
    bulkOptionsMutation = useBulkUpdateEntityPropertyOptionsMutation('task-1');
  });
}

function renderEntityQuery(
  includeMetadata: boolean,
  entityType: 'DOCUMENT' | 'USER' | Accessor<'DOCUMENT' | 'USER'> = 'DOCUMENT',
  entityId: string | Accessor<string> = 'document-1'
): void {
  const type = typeof entityType === 'function' ? entityType : () => entityType;
  const id = typeof entityId === 'function' ? entityId : () => entityId;
  renderWithQueryClient(() => {
    entityQuery = useEntityPropertiesQuery(type, id, includeMetadata);
  });
}

describe('useEntityPropertiesQuery transport', () => {
  beforeEach(() => {
    vi.clearAllMocks();
    graphqlSoupEnabledMock.mockReturnValue(true);
    const [graphqlFlagEnabled, setEnabled] = createSignal(true);
    setGraphqlFlagEnabled = setEnabled;
    useFeatureFlagMock.mockReturnValue(() => ({
      enabled: graphqlFlagEnabled(),
      payload: undefined,
    }));
    graphqlExecutions = [];
    graphqlQueryMock.mockImplementation(
      (request: { variables: unknown }, context: unknown) => {
        const subject = makeSubject<unknown>();
        const execution = {
          variables: request.variables,
          context,
          next: subject.next,
          ended: false,
        };
        graphqlExecutions.push(execution);
        return pipe(
          subject.source,
          onEnd(() => {
            execution.ended = true;
          })
        );
      }
    );
    buildEntityPropertiesInputMock.mockImplementation(
      (entityType: string, entityId: string) =>
        entityType === 'USER' ? undefined : { entityType, entityId }
    );
    mapGraphqlEntityPropertiesMock.mockImplementation(
      (
        data:
          | {
              user?: {
                soup?: { items?: Array<{ id: string; properties: unknown[] }> };
              };
            }
          | undefined,
        entityId: string
      ) => {
        if (!data) return undefined;
        return (
          data.user?.soup?.items?.find((item) => item.id === entityId)
            ?.properties ?? []
        );
      }
    );
    soupPropertyToPropertyMock.mockImplementation(
      (soupProperty: { mapped: Property }) => soupProperty.mapped
    );
    createGraphqlEntityPropertiesQueryMock.mockImplementation(
      (options: {
        entityType: Accessor<string>;
        entityId: Accessor<string>;
        enabled: Accessor<boolean>;
      }) => {
        const input = createMemo(() => {
          const entityId = options.entityId();
          if (!options.enabled() || entityId.length === 0) return undefined;
          return buildEntityPropertiesInputMock(options.entityType(), entityId);
        });
        const result = createUrqlQuery(() => {
          const currentInput = input();
          const entityId = options.entityId();
          return {
            query: EntityPropertiesDocument,
            client: {
              executeQuery: graphqlQueryMock,
            } as unknown as Client,
            variables: { input: currentInput! },
            enabled: currentInput !== undefined,
            requestPolicy: 'cache-and-network' as const,
            keepPreviousData: false,
            select: (data: unknown) =>
              (
                (mapGraphqlEntityPropertiesMock(data, entityId) ??
                  []) as Array<{
                  mapped: Property;
                }>
              ).flatMap((property) => {
                const mapped = soupPropertyToPropertyMock(property) as Property;
                return mapped.isMetadata === true ? [] : [mapped];
              }),
          };
        });
        return {
          result,
          isEnabled: () => input() !== undefined,
          refetch: () => result.refetch({ requestPolicy: 'network-only' }),
        };
      }
    );
    testQueryClient = new QueryClient({
      defaultOptions: { queries: { retry: false } },
    });
  });

  afterEach(() => {
    dispose?.();
    document.body.replaceChildren();
  });

  it('keeps a live GraphQL subscription for cache-pushed results', async () => {
    const nextProperty = { ...property, displayName: 'Next status' };
    renderEntityQuery(false);

    expect(entityQuery.isLoading).toBe(true);
    expect(graphqlExecutions).toHaveLength(1);
    expect(graphqlExecutions[0]).toMatchObject({
      variables: {
        input: { entityType: 'DOCUMENT', entityId: 'document-1' },
      },
      context: { requestPolicy: 'cache-and-network' },
    });
    expect(getRestEntityPropertiesMock).not.toHaveBeenCalled();

    graphqlExecutions[0]?.next({
      data: {
        user: {
          soup: {
            items: [{ id: 'document-1', properties: [{ mapped: property }] }],
          },
        },
      },
      stale: true,
    });
    await vi.waitFor(() => expect(entityQuery.data).toEqual([property]));
    expect(entityQuery.isFetching).toBe(true);

    graphqlExecutions[0]?.next({
      data: {
        user: {
          soup: {
            items: [
              { id: 'document-1', properties: [{ mapped: nextProperty }] },
            ],
          },
        },
      },
      stale: false,
    });
    await vi.waitFor(() => expect(entityQuery.data).toEqual([nextProperty]));
    expect(entityQuery.isFetching).toBe(false);
    expect(graphqlExecutions).toHaveLength(1);
  });

  it('reactively switches transports in both directions', async () => {
    getRestEntityPropertiesMock.mockResolvedValue(ok({ properties: [] }));
    renderEntityQuery(false);
    expect(graphqlExecutions).toHaveLength(1);
    expect(useFeatureFlagMock).toHaveBeenCalledWith({
      key: 'enable-graphql-soup',
    });

    setGraphqlFlagEnabled(false);
    await vi.waitFor(() => expect(graphqlExecutions[0]?.ended).toBe(true));
    await vi.waitFor(() =>
      expect(getRestEntityPropertiesMock).toHaveBeenCalled()
    );

    setGraphqlFlagEnabled(true);
    await vi.waitFor(() => expect(graphqlExecutions).toHaveLength(2));
    expect(graphqlExecutions[1]?.ended).toBe(false);
  });

  it('clears the prior entity and resubscribes when the id changes', async () => {
    const [entityId, setEntityId] = createSignal('document-1');
    renderEntityQuery(false, 'DOCUMENT', entityId);
    graphqlExecutions[0]?.next({
      data: {
        user: {
          soup: {
            items: [{ id: 'document-1', properties: [{ mapped: property }] }],
          },
        },
      },
    });
    await vi.waitFor(() => expect(entityQuery.data).toEqual([property]));

    setEntityId('document-2');

    expect(entityQuery.data).toBeUndefined();
    expect(entityQuery.isLoading).toBe(true);
    expect(graphqlExecutions).toHaveLength(2);
    expect(graphqlExecutions[1]?.variables).toEqual({
      input: { entityType: 'DOCUMENT', entityId: 'document-2' },
    });
  });

  it('pauses both transports and makes refetch a no-op for an empty id', async () => {
    renderEntityQuery(false, 'DOCUMENT', '');

    expect(entityQuery.data).toBeUndefined();
    expect(entityQuery.isLoading).toBe(false);
    await expect(entityQuery.refetch()).resolves.toBeUndefined();
    expect(graphqlExecutions).toHaveLength(0);
    expect(getRestEntityPropertiesMock).not.toHaveBeenCalled();
  });

  it('surfaces GraphQL errors and leaves the adapter out of loading', async () => {
    renderEntityQuery(false);
    const error = new Error('query failed');

    graphqlExecutions[0]?.next({ error });

    await vi.waitFor(() => expect(entityQuery.error).toBe(error));
    expect(entityQuery.data).toBeUndefined();
    expect(entityQuery.isLoading).toBe(false);
    expect(entityQuery.isFetching).toBe(false);
  });

  it('re-fetches the live operation from the network', async () => {
    renderEntityQuery(false);

    const refetch = entityQuery.refetch();
    await vi.waitFor(() => expect(graphqlExecutions).toHaveLength(2));
    expect(graphqlExecutions[1]?.context).toMatchObject({
      requestPolicy: 'network-only',
    });
    graphqlExecutions[1]?.next({ data: { user: { soup: { items: [] } } } });
    await refetch;
  });

  it('keeps metadata requests on REST', async () => {
    const apiProperty = { property: { id: 'assignment-1' } };
    getRestEntityPropertiesMock.mockResolvedValue(
      ok({ properties: [apiProperty] })
    );
    entityPropertyFromApiMock.mockReturnValue(property);

    renderEntityQuery(true);

    await vi.waitFor(() => expect(entityQuery.data).toEqual([property]));
    expect(graphqlExecutions).toHaveLength(0);
    expect(getRestEntityPropertiesMock).toHaveBeenCalledWith({
      entity_type: 'DOCUMENT',
      entity_id: 'document-1',
      query: { include_metadata: true },
    });
  });

  it('uses REST when the GraphQL feature is disabled', async () => {
    setGraphqlFlagEnabled(false);
    getRestEntityPropertiesMock.mockResolvedValue(ok({ properties: [] }));

    renderEntityQuery(false);

    await vi.waitFor(() => expect(entityQuery.data).toEqual([]));
    expect(graphqlExecutions).toHaveLength(0);
    expect(getRestEntityPropertiesMock).toHaveBeenCalledWith({
      entity_type: 'DOCUMENT',
      entity_id: 'document-1',
      query: { include_metadata: true },
    });
  });

  it('falls back to REST for USER properties, which Soup cannot query', async () => {
    getRestEntityPropertiesMock.mockResolvedValue(ok({ properties: [] }));

    renderEntityQuery(false, 'USER', 'user-1');

    await vi.waitFor(() => expect(entityQuery.data).toEqual([]));
    expect(graphqlExecutions).toHaveLength(0);
    expect(getRestEntityPropertiesMock).toHaveBeenCalledWith({
      entity_type: 'USER',
      entity_id: 'user-1',
      query: { include_metadata: true },
    });
  });
});

describe('useBulkSaveEntityPropertiesMutation dispositions', () => {
  beforeEach(() => {
    onlineManager.setOnline(true);
    vi.clearAllMocks();
    optimisticUpdateSoupEntityMock.mockReturnValue({ rollback: rollbackMock });
    isInstantiatedPropertyMock.mockReturnValue(true);
    graphqlEntityPropertyMutationMock.mockResolvedValue({ kind: 'committed' });
    createGraphqlAddEntityPropertyMutationMock.mockImplementation(
      (options: {
        onMutate?: (input: {
          entityId: string;
          entityType: string;
          propertyDefinitionId: string;
        }) => unknown;
        onSuccess?: (input: unknown, context: unknown) => unknown;
        onError?: (error: Error, input: unknown, context: unknown) => unknown;
        onSettled?: (
          error: Error | null,
          input: unknown,
          context: unknown
        ) => unknown;
      }) => {
        let isPending = false;
        let error: Error | null = null;
        const mutateAsync = async (input: {
          entityId: string;
          entityType: string;
          propertyDefinitionId: string;
        }) => {
          isPending = true;
          const context = await options.onMutate?.(input);
          let settledError: Error | null = null;
          try {
            const disposition = await graphqlEntityPropertyMutationMock({
              kind: 'add',
              ...input,
            });
            if (disposition.kind === 'permanently-failed') {
              throw disposition.error;
            }
            await options.onSuccess?.(input, context);
            return { error: null };
          } catch (cause) {
            settledError =
              cause instanceof Error ? cause : new Error(String(cause));
            error = settledError;
            await options.onError?.(settledError, input, context);
            throw settledError;
          } finally {
            await options.onSettled?.(settledError, input, context);
            isPending = false;
          }
        };
        return {
          get isPending() {
            return isPending;
          },
          get error() {
            return error;
          },
          mutate: (input: {
            entityId: string;
            entityType: string;
            propertyDefinitionId: string;
          }) => {
            void mutateAsync(input).catch(() => undefined);
          },
          mutateAsync,
        };
      }
    );
    createGraphqlBulkSaveEntityPropertiesMutationMock.mockImplementation(
      (options: {
        onMutate?: (input: typeof variables) => unknown;
        onCommitted?: (
          item: (typeof variables)['properties'][number],
          disposition: { kind: 'committed' }
        ) => unknown;
        onSuccess?: (input: typeof variables, context: unknown) => unknown;
        onError?: (
          error: Error,
          input: typeof variables,
          context: unknown
        ) => unknown;
        onSettled?: (
          error: Error | null,
          input: typeof variables,
          context: unknown
        ) => unknown;
      }) => {
        let isPending = false;
        let error: Error | null = null;
        const mutateAsync = async (input: typeof variables) => {
          isPending = true;
          const context = await options.onMutate?.(input);
          let settledError: Error | null = null;
          try {
            for (const item of input.properties) {
              const disposition = await graphqlEntityPropertyMutationMock({
                kind: 'save',
                ...item,
              });
              if (disposition.kind === 'committed') {
                await options.onCommitted?.(item, disposition);
              } else if (disposition.kind === 'permanently-failed') {
                throw disposition.error;
              }
            }
            await options.onSuccess?.(input, context);
            return { error: null };
          } catch (cause) {
            settledError =
              cause instanceof Error ? cause : new Error(String(cause));
            error = settledError;
            await options.onError?.(settledError, input, context);
            throw settledError;
          } finally {
            await options.onSettled?.(settledError, input, context);
            isPending = false;
          }
        };
        return {
          get isPending() {
            return isPending;
          },
          get error() {
            return error;
          },
          mutate: (input: typeof variables) => {
            void mutateAsync(input).catch(() => undefined);
          },
          mutateAsync,
        };
      }
    );
    setRestEntityPropertyMock.mockResolvedValue(ok({ success: true }));
    graphqlSoupEnabledMock.mockReturnValue(true);
    deleteEntityPropertyMock.mockResolvedValue(ok(undefined));
    addEntityPropertyOptionMock.mockResolvedValue(ok(undefined));
    bulkUpdateEntityPropertyOptionsMock.mockResolvedValue(
      ok({ properties: [{ property_id: 'status-def', option_ids: ['doing'] }] })
    );
    vi.spyOn(console, 'error').mockImplementation(() => undefined);
    testQueryClient = new QueryClient({
      defaultOptions: {
        queries: { retry: false },
        mutations: { retry: false },
      },
    });
    vi.spyOn(testQueryClient, 'invalidateQueries');
    renderMutation();
  });

  afterEach(() => {
    onlineManager.setOnline(true);
    dispose?.();
    document.body.replaceChildren();
    vi.restoreAllMocks();
  });

  it('submits GraphQL optimism while offline and waits for durable settlement', async () => {
    onlineManager.setOnline(false);
    let commit!: (disposition: { kind: 'committed' }) => void;
    graphqlEntityPropertyMutationMock.mockImplementation(
      () =>
        new Promise((resolve) => {
          commit = resolve;
        })
    );

    const pending = mutation.mutateAsync(variables);
    await vi.waitFor(() =>
      expect(graphqlEntityPropertyMutationMock).toHaveBeenCalledOnce()
    );
    expect(mutation.isPending).toBe(true);
    onlineManager.setOnline(true);
    commit({ kind: 'committed' });
    await expect(pending).resolves.toBeUndefined();

    expect(graphqlEntityPropertyMutationMock).toHaveBeenCalledOnce();
    expect(graphqlEntityPropertyMutationMock).toHaveBeenCalledWith({
      kind: 'save',
      ...variables.properties[0],
    });
    expect(optimisticUpdateSoupEntityMock).not.toHaveBeenCalled();
  });

  it('keeps GraphQL saves pending until settlement without snapshot rollback', async () => {
    let commit!: (disposition: { kind: 'committed' }) => void;
    graphqlEntityPropertyMutationMock.mockImplementation(
      () =>
        new Promise((resolve) => {
          commit = resolve;
        })
    );

    const pending = mutation.mutateAsync(variables);
    await vi.waitFor(() =>
      expect(graphqlEntityPropertyMutationMock).toHaveBeenCalledOnce()
    );
    expect(mutation.isPending).toBe(true);
    expect(invalidateSoupEntityMock).not.toHaveBeenCalled();
    expect(toastFailureMock).not.toHaveBeenCalled();
    commit({ kind: 'committed' });
    await expect(pending).resolves.toBeUndefined();

    expect(optimisticUpdateSoupEntityMock).not.toHaveBeenCalled();
    expect(rollbackMock).not.toHaveBeenCalled();
    expect(invalidateSoupEntityMock).toHaveBeenCalledWith('task-1');
    expect(testQueryClient.invalidateQueries).toHaveBeenCalled();
    expect(toastFailureMock).not.toHaveBeenCalled();
  });

  it('invalidates GraphQL permanent failures without snapshot rollback', async () => {
    graphqlEntityPropertyMutationMock.mockResolvedValue({
      kind: 'permanently-failed',
      error: new Error('invalid property'),
    });

    await expect(mutation.mutateAsync(variables)).rejects.toThrow(
      'invalid property'
    );

    expect(optimisticUpdateSoupEntityMock).not.toHaveBeenCalled();
    expect(rollbackMock).not.toHaveBeenCalled();
    expect(invalidateSoupEntityMock).toHaveBeenCalledWith('task-1');
    expect(testQueryClient.invalidateQueries).toHaveBeenCalled();
    expect(toastFailureMock).toHaveBeenCalledOnce();
  });

  it('exposes transport-neutral pending state', async () => {
    let resolve!: (value: { kind: 'committed' }) => void;
    graphqlEntityPropertyMutationMock.mockImplementation(
      () =>
        new Promise((resolveMutation) => {
          resolve = resolveMutation;
        })
    );

    const pending = mutation.mutateAsync(variables);
    await vi.waitFor(() => expect(mutation.isPending).toBe(true));
    await vi.waitFor(() =>
      expect(graphqlEntityPropertyMutationMock).toHaveBeenCalledOnce()
    );

    resolve({ kind: 'committed' });
    await pending;
    expect(mutation.isPending).toBe(false);
  });

  it('invalidates the TanStack projection after an immediate GraphQL commit', async () => {
    graphqlEntityPropertyMutationMock.mockResolvedValue({ kind: 'committed' });

    await mutation.mutateAsync(variables);

    expect(optimisticUpdateSoupEntityMock).not.toHaveBeenCalled();
    expect(rollbackMock).not.toHaveBeenCalled();
    expect(invalidateSoupEntityMock).toHaveBeenCalledWith('task-1');
    expect(testQueryClient.invalidateQueries).toHaveBeenCalled();
    expect(refreshPropertyQueriesMock).toHaveBeenCalledWith('status-def');
    expect(toastFailureMock).not.toHaveBeenCalled();
  });

  it('invalidates the REST projection for a new GraphQL attachment', async () => {
    graphqlEntityPropertyMutationMock.mockResolvedValue({ kind: 'committed' });

    await addMutation.mutateAsync({
      entityId: 'task-1',
      entityType: 'TASK',
      propertyDefinitionId: 'status-def',
    });

    expect(graphqlEntityPropertyMutationMock).toHaveBeenCalledWith({
      kind: 'add',
      entityId: 'task-1',
      entityType: 'TASK',
      propertyDefinitionId: 'status-def',
    });
    expect(testQueryClient.invalidateQueries).toHaveBeenCalled();
    expect(toastFailureMock).not.toHaveBeenCalled();
  });

  it('removes a native project property through GraphQL even when the Soup flag is off', async () => {
    graphqlSoupEnabledMock.mockReturnValue(false);
    await deleteMutation.mutateAsync({
      entityPropertyId: 'assignment-1',
      entityType: 'INITIATIVE',
      entityId: 'initiative-1',
    });
    expect(deleteEntityPropertyMock).not.toHaveBeenCalled();
    expect(initiativePropertyDeleteMock).toHaveBeenCalledWith(
      DeleteEntityPropertyDocument,
      {
        entityPropertyId: 'assignment-1',
        entityType: 'INITIATIVE',
        entityId: 'initiative-1',
      }
    );
    expect(initiativePropertyQueryMock).toHaveBeenCalledWith(
      EntityPropertiesDocument,
      { input: buildGraphqlEntitySoupInput('INITIATIVE', 'initiative-1')! },
      { requestPolicy: 'network-only' }
    );
    expect(refreshPropertyQueriesMock).toHaveBeenCalledOnce();
  });

  it('invalidates REST projections after delete and option writes', async () => {
    await deleteMutation.mutateAsync({
      entityPropertyId: 'assignment-1',
      entityType: 'TASK',
      entityId: 'task-1',
    });
    await addOptionMutation.mutateAsync({
      entityId: 'task-1',
      entityType: 'TASK',
      property,
      optionId: 'doing',
      optimisticOptionIds: ['doing'],
    });

    expect(testQueryClient.invalidateQueries).toHaveBeenCalledTimes(2);
    expect(invalidateSoupEntityMock).toHaveBeenCalledWith('task-1');
    expect(refreshPropertyQueriesMock).toHaveBeenCalledTimes(2);
    expect(refreshPropertyQueriesMock).toHaveBeenCalledWith('status-def');
  });

  it('invalidates REST after a failed attachment write', async () => {
    graphqlEntityPropertyMutationMock.mockResolvedValue({
      kind: 'permanently-failed',
      error: new Error('add failed'),
    });

    await expect(
      addMutation.mutateAsync({
        entityId: 'task-1',
        entityType: 'TASK',
        propertyDefinitionId: 'status-def',
      })
    ).rejects.toThrow('add failed');

    expect(testQueryClient.invalidateQueries).toHaveBeenCalled();
  });

  it('invalidates REST after failed REST-backed writes', async () => {
    // Option selections have their own GraphQL transport, so this REST-only
    // assertion needs the flag off for the bulk-options write below.
    graphqlSoupEnabledMock.mockReturnValue(false);
    deleteEntityPropertyMock.mockResolvedValue(
      err([{ code: 'SERVER_ERROR', message: 'delete failed' }])
    );
    await expect(
      deleteMutation.mutateAsync({
        entityPropertyId: 'assignment-1',
        entityType: 'TASK',
        entityId: 'task-1',
      })
    ).rejects.toThrow('delete failed');

    addEntityPropertyOptionMock.mockResolvedValue(
      err([{ code: 'SERVER_ERROR', message: 'option failed' }])
    );
    await expect(
      addOptionMutation.mutateAsync({
        entityId: 'task-1',
        entityType: 'TASK',
        property,
        optionId: 'doing',
        optimisticOptionIds: ['doing'],
      })
    ).rejects.toThrow('option failed');

    bulkUpdateEntityPropertyOptionsMock.mockResolvedValue(
      err([{ code: 'SERVER_ERROR', message: 'bulk failed' }])
    );
    await expect(
      bulkOptionsMutation.mutateAsync({
        entityId: 'task-1',
        entityType: 'TASK',
        properties: [
          {
            property,
            currentOptionIds: [],
            nextOptionIds: ['doing'],
          },
        ],
      })
    ).rejects.toThrow('bulk failed');

    expect(testQueryClient.invalidateQueries).toHaveBeenCalledTimes(3);
  });

  it('keeps the existing TanStack lifecycle when GraphQL Soup is disabled', async () => {
    graphqlSoupEnabledMock.mockReturnValue(false);
    setRestEntityPropertyMock.mockResolvedValue(
      err([{ code: 'SERVER_ERROR', message: 'invalid property' }])
    );

    await expect(mutation.mutateAsync(variables)).rejects.toThrow(
      'One or more properties permanently failed to save'
    );

    expect(optimisticUpdateSoupEntityMock).toHaveBeenCalledOnce();
    expect(rollbackMock).toHaveBeenCalledOnce();
    expect(invalidateSoupEntityMock).toHaveBeenCalledWith('task-1');
    expect(testQueryClient.invalidateQueries).toHaveBeenCalled();
    expect(toastFailureMock).toHaveBeenCalledOnce();
  });

  const optionSelection = {
    entityId: 'task-1',
    entityType: 'TASK' as const,
    properties: [
      { property, currentOptionIds: ['todo'], nextOptionIds: ['doing'] },
    ],
  };

  it.each([true, false])(
    'keeps GraphQL refresh scope when the flag settles to %s',
    async (enabled) => {
      updateGraphqlEntityPropertyOptionsMock.mockImplementation(async () => {
        graphqlSoupEnabledMock.mockReturnValue(enabled);
        return [{ propertyDefinitionId: 'status-def', optionIds: ['doing'] }];
      });

      await expect(
        bulkOptionsMutation.mutateAsync(optionSelection)
      ).resolves.toEqual({
        selections: [
          { propertyDefinitionId: 'status-def', optionIds: ['doing'] },
        ],
        transport: 'graphql',
      });

      expect(updateGraphqlEntityPropertyOptionsMock).toHaveBeenCalledWith(
        optionSelection
      );
      expect(bulkUpdateEntityPropertyOptionsMock).not.toHaveBeenCalled();
      expect(refreshPropertyQueriesMock).toHaveBeenCalledWith('status-def', {
        includeOptionFilters: true,
        unmaintainedOnly: true,
      });
      expect(testQueryClient.invalidateQueries).toHaveBeenCalled();
    }
  );

  it('rolls back and reports a failed GraphQL option selection', async () => {
    updateGraphqlEntityPropertyOptionsMock.mockRejectedValue(
      new Error('options failed')
    );

    await expect(
      bulkOptionsMutation.mutateAsync(optionSelection)
    ).rejects.toThrow('options failed');

    expect(bulkUpdateEntityPropertyOptionsMock).not.toHaveBeenCalled();
    expect(rollbackMock).toHaveBeenCalledOnce();
    expect(refreshPropertyQueriesMock).not.toHaveBeenCalled();
    expect(testQueryClient.invalidateQueries).toHaveBeenCalled();
    expect(toastFailureMock).toHaveBeenCalledOnce();
  });

  it.each([false, true])(
    'keeps REST refresh scope when the flag settles to %s',
    async (enabled) => {
      graphqlSoupEnabledMock.mockReturnValue(false);
      bulkUpdateEntityPropertyOptionsMock.mockImplementationOnce(async () => {
        graphqlSoupEnabledMock.mockReturnValue(enabled);
        return ok({
          properties: [{ property_id: 'status-def', option_ids: ['doing'] }],
        });
      });

      await expect(
        bulkOptionsMutation.mutateAsync(optionSelection)
      ).resolves.toEqual({
        selections: [
          { propertyDefinitionId: 'status-def', optionIds: ['doing'] },
        ],
        transport: 'rest',
      });

      expect(bulkUpdateEntityPropertyOptionsMock).toHaveBeenCalledOnce();
      expect(updateGraphqlEntityPropertyOptionsMock).not.toHaveBeenCalled();
      expect(refreshPropertyQueriesMock).toHaveBeenCalledWith('status-def', {
        includeOptionFilters: true,
        unmaintainedOnly: false,
      });
      expect(testQueryClient.invalidateQueries).toHaveBeenCalled();
    }
  );
});