Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
import type { CacheHost } from '@graphql-cache/host/types';
import type { MutationSettlement } from '@graphql-cache/protocol';
import type { Property } from '@property/types';
import { registerGraphqlSoupRevalidations } from '@queries/soup/graphql/active-queries';
import type { EntityType } from '@service-properties/generated/schemas/entityType';
import type { SoupProperty } from '@service-storage/generated/schemas/soupProperty';
import { GroupSoupDocument } from '@service-storage/graphql/generated/graphql';
import {
type Client,
createClient,
type Exchange,
type Operation,
type OperationResult,
} from '@urql/core';
import { createRoot, createSignal } from 'solid-js';
import { validate as validateUuid } from 'uuid';
import {
afterEach,
beforeEach,
describe,
expect,
it,
onTestFinished,
vi,
} from 'vitest';
import { filter, makeSubject, mergeMap, pipe } from 'wonka';
const graphqlClientState = vi.hoisted(() => ({
current: undefined as Client | undefined,
host: undefined as CacheHost | undefined,
}));
const mapGraphqlPropertiesMock = vi.hoisted(() => vi.fn());
vi.mock('@service-storage/graphql-soup', () => ({
getGraphqlSoupClient: () => {
if (!graphqlClientState.current) throw new Error('GraphQL client not set');
return graphqlClientState.current;
},
getGraphqlCacheHost: () => graphqlClientState.host,
mapGraphqlProperties: mapGraphqlPropertiesMock,
}));
import {
buildEntityPropertiesInput,
createGraphqlAddEntityPropertyMutation,
createGraphqlBulkSaveEntityPropertiesMutation,
createGraphqlEntityPropertiesQuery,
entityPropertyOptimisticMutationUuid,
mapGraphqlEntityProperties,
refetchGraphqlInitiativeProperties,
toGraphqlSetPropertyValue,
} from './entity';
type ControlledRequest = {
operation: Operation;
next: (result?: Pick<OperationResult, 'data' | 'error'>) => void;
};
function makeControlledClient() {
const requests: ControlledRequest[] = [];
const exchange: Exchange = () => (operations$) =>
pipe(
operations$,
filter((operation) => operation.kind === 'query'),
mergeMap((operation) => {
const subject = makeSubject<OperationResult>();
requests.push({
operation,
next: (result = {}) =>
subject.next({
operation,
data: result.data,
error: result.error,
stale: false,
hasNext: false,
}),
});
return subject.source;
})
);
const client = createClient({
url: 'https://example.test/graphql',
exchanges: [exchange],
});
graphqlClientState.current = client;
return { client, requests };
}
function makeSettlementHost() {
const listeners = new Set<(settlement: MutationSettlement) => void>();
const unsubscribe = vi.fn();
const unsubscribeGeneration = vi.fn();
graphqlClientState.host = {
inspectQuery: vi.fn(async () => []),
inspectQueryVariants: vi.fn(async () => []),
onMutationSettled(callback: (settlement: MutationSettlement) => void) {
listeners.add(callback);
return () => {
listeners.delete(callback);
unsubscribe();
};
},
onCacheGenerationChanged: () => unsubscribeGeneration,
} as unknown as CacheHost;
return {
emit: (settlement: MutationSettlement) => {
for (const callback of listeners) callback(settlement);
},
unsubscribe,
unsubscribeGeneration,
};
}
afterEach(() => {
graphqlClientState.host = undefined;
});
const EMPTY_DATA = {
user: { id: 'user-1', soupEntity: null },
};
describe('buildEntityPropertiesInput', () => {
it.each([
['DOCUMENT', 'DOCUMENT'],
['TASK', 'DOCUMENT'],
['INITIATIVE', 'INITIATIVE'],
['PROJECT', 'PROJECT'],
['CHAT', 'CHAT'],
['THREAD', 'EMAIL_THREAD'],
['CHANNEL', 'CHANNEL'],
['CALL_RECORD', 'CALL'],
['COMPANY', 'CRM_COMPANY'],
['CALENDAR_EVENT', 'CALENDAR_EVENT'],
['DATABASE_ROW', 'DATABASE_ROW'],
] as const)('reads one %s as a %s Soup entity', (entityType, soupType) => {
expect(buildEntityPropertiesInput(entityType, 'entity-1')).toEqual({
entityType: soupType,
entityId: 'entity-1',
});
});
it.each(['USER', 'CONTACT'] as const)(
'returns undefined for %s, which carries no Soup properties',
(entityType) => {
expect(
buildEntityPropertiesInput(entityType, 'entity-1')
).toBeUndefined();
}
);
it('loads nothing for an entity type a newer service added', () => {
const fromNewerService = JSON.parse('"AGENT_SESSION"');
expect(
buildEntityPropertiesInput(fromNewerService, 'entity-1')
).toBeUndefined();
});
});
describe('mapGraphqlEntityProperties', () => {
beforeEach(() => {
vi.clearAllMocks();
});
it('maps only the requested entity properties', () => {
const property = { id: 'property-1' };
const mapped = [{ id: 'property-1' }] as SoupProperty[];
mapGraphqlPropertiesMock.mockReturnValue(mapped);
expect(
mapGraphqlEntityProperties(
{
user: {
id: 'user-1',
soupEntity: {
__typename: 'GraphqlSoupDocument',
id: 'entity-1',
properties: [property],
},
},
} as never,
'entity-1'
)
).toBe(mapped);
expect(mapGraphqlPropertiesMock).toHaveBeenCalledWith([property]);
});
it('maps an entity the viewer cannot see, or a different entity, as no properties', () => {
mapGraphqlPropertiesMock.mockReturnValue([]);
const other = {
__typename: 'GraphqlSoupDocument',
id: 'other-entity',
properties: [{ id: 'property-1' }],
};
for (const soupEntity of [null, other]) {
expect(
mapGraphqlEntityProperties(
{ user: { id: 'user-1', soupEntity } } as never,
'entity-1'
)
).toEqual([]);
}
expect(mapGraphqlPropertiesMock).toHaveBeenNthCalledWith(1, []);
expect(mapGraphqlPropertiesMock).toHaveBeenNthCalledWith(2, []);
});
it('retains the not-yet-loaded distinction', () => {
expect(mapGraphqlEntityProperties(undefined, 'entity-1')).toBeUndefined();
expect(
mapGraphqlEntityProperties(
{ user: { id: 'user-1' } } as never,
'entity-1'
)
).toBeUndefined();
expect(mapGraphqlPropertiesMock).not.toHaveBeenCalled();
});
});
describe('entityPropertyOptimisticMutationUuid', () => {
it('is stable per property slot and distinct across slots', () => {
const args = {
entityType: 'DOCUMENT' as const,
entityId: 'document-1',
propertyDefinitionId: 'property-1',
};
const uuid = entityPropertyOptimisticMutationUuid(args);
expect(validateUuid(uuid)).toBe(true);
expect(entityPropertyOptimisticMutationUuid(args)).toBe(uuid);
expect(
entityPropertyOptimisticMutationUuid({
...args,
propertyDefinitionId: 'property-2',
})
).not.toBe(uuid);
expect(
entityPropertyOptimisticMutationUuid({
...args,
entityId: 'document-1:property',
propertyDefinitionId: '1',
})
).not.toBe(
entityPropertyOptimisticMutationUuid({
...args,
entityId: 'document-1',
propertyDefinitionId: 'property:1',
})
);
});
});
describe('toGraphqlSetPropertyValue', () => {
it('refuses to send a value type this build does not know', () => {
const fromNewerBuild = JSON.parse('{"type":"color","value":"#ff0000"}');
expect(() => toGraphqlSetPropertyValue(fromNewerBuild)).toThrow(
'Unsupported property value type: color'
);
});
});
describe('GraphQL entity property mutations', () => {
let dispose: (() => void) | undefined;
afterEach(() => dispose?.());
it('executes add mutations through the urql-solid adapter', async () => {
const property = { id: 'property-1' };
const mutation = vi.fn(
(
_document: unknown,
_variables: unknown,
context: Record<string, unknown>
) => ({
toPromise: async () => ({
operation: {
kind: 'mutation',
context,
} as Operation,
data: { setEntityProperty: property },
stale: false,
hasNext: false,
}),
})
);
graphqlClientState.current = { mutation } as unknown as Client;
let result!: ReturnType<typeof createGraphqlAddEntityPropertyMutation>;
createRoot((rootDispose) => {
dispose = rootDispose;
result = createGraphqlAddEntityPropertyMutation();
});
await expect(
result.mutateAsync({
entityType: 'TASK',
entityId: 'task-1',
propertyDefinitionId: 'definition-1',
})
).resolves.toMatchObject({
data: { setEntityProperty: property },
});
expect(mutation).toHaveBeenCalledWith(
expect.anything(),
{
input: {
entityType: 'DOCUMENT',
entityId: 'task-1',
propertyDefinitionId: 'definition-1',
value: null,
},
},
{}
);
});
it('retains the queued acknowledgement but waits for the replacement to commit', async () => {
const settlements = makeSettlementHost();
const property = {
propertyId: 'assignment-1',
propertyDefinitionId: 'definition-1',
displayName: 'Status',
valueType: 'STRING',
isMultiSelect: false,
isSystemProperty: false,
isMetadata: false,
} as Property;
const mutation = vi.fn(
(
_document: unknown,
_variables: unknown,
context: Record<string, unknown>
) => ({
toPromise: async () => ({
operation: {
kind: 'mutation',
context,
} as Operation,
data: undefined,
extensions: {
normalizedCacheMutationDisposition: {
kind: 'superseded',
transactionId: 'transaction-1',
replacementTransactionId: 'transaction-2',
},
},
stale: false,
hasNext: false,
}),
})
);
graphqlClientState.current = { mutation } as unknown as Client;
let result!: ReturnType<
typeof createGraphqlBulkSaveEntityPropertiesMutation
>;
createRoot((rootDispose) => {
dispose = rootDispose;
result = createGraphqlBulkSaveEntityPropertiesMutation();
});
const pending = result.mutateAsync({
properties: [
{
entityType: 'DOCUMENT',
entityId: 'document-1',
property,
apiValues: { valueType: 'STRING', value: 'doing' },
},
],
});
await vi.waitFor(() => expect(mutation).toHaveBeenCalledOnce());
expect(result.isPending).toBe(true);
settlements.emit({ transactionId: 'transaction-2', status: 'committed' });
await expect(pending).resolves.toMatchObject({
data: {
setEntityProperty: expect.objectContaining({ id: 'assignment-1' }),
},
extensions: {
normalizedCacheMutationDisposition: {
kind: 'superseded',
transactionId: 'transaction-1',
replacementTransactionId: 'transaction-2',
},
},
});
expect(mutation).toHaveBeenCalledWith(
expect.anything(),
{
input: {
entityType: 'DOCUMENT',
entityId: 'document-1',
propertyDefinitionId: 'definition-1',
value: { string: 'doing' },
},
},
expect.objectContaining({
normalizedCacheOptimistic: expect.objectContaining({
optimisticResponse: {
setEntityProperty: expect.objectContaining({ id: 'assignment-1' }),
},
}),
})
);
});
});
describe('createGraphqlBulkSaveEntityPropertiesMutation', () => {
let dispose: (() => void) | undefined;
afterEach(() => dispose?.());
it('installs every bulk layer before the first HTTP result, while retaining enqueue order', async () => {
const onCommitted = vi.fn();
const acknowledgements: Array<() => void> = [];
const responses: Array<() => void> = [];
const mutation = vi.fn(
(
_document: unknown,
_variables: unknown,
context: Record<string, unknown>
) => ({
toPromise: () =>
new Promise((resolve) => {
acknowledgements.push(
context.normalizedCacheOptimisticEnqueued as () => void
);
responses.push(() =>
resolve({
operation: { kind: 'mutation', context },
data: { setEntityProperty: { id: 'assignment' } },
stale: false,
hasNext: false,
})
);
}),
})
);
graphqlClientState.current = { mutation } as unknown as Client;
const save = createRoot((rootDispose) => {
dispose = rootDispose;
return createGraphqlBulkSaveEntityPropertiesMutation({ onCommitted });
});
const property = {
propertyId: 'assignment',
propertyDefinitionId: 'priority',
displayName: 'Priority',
valueType: 'SELECT_STRING',
isMultiSelect: false,
} as Property;
const pending = save.mutateAsync({
properties: ['task-1', 'task-2'].map((entityId) => ({
entityId,
entityType: 'TASK',
property,
apiValues: { valueType: 'SELECT_STRING', values: ['urgent'] },
})),
});
await vi.waitFor(() => expect(mutation).toHaveBeenCalledTimes(1));
// Preparing the next relation recipe must wait for cache installation.
expect(onCommitted).not.toHaveBeenCalled();
acknowledgements[0]();
await vi.waitFor(() => expect(mutation).toHaveBeenCalledTimes(2));
expect(onCommitted).not.toHaveBeenCalled();
acknowledgements[1]();
expect(save.isPending).toBe(true);
responses[1]();
await vi.waitFor(() => expect(onCommitted).toHaveBeenCalledTimes(1));
expect(save.isPending).toBe(true);
responses[0]();
await pending;
expect(onCommitted).toHaveBeenCalledTimes(2);
expect(save.isPending).toBe(false);
});
it('prepares a bulk grouped edit once per active page without cache inspection', async () => {
makeSettlementHost();
const input = {
initial: {
groupBy: {
field: 'PROPERTY' as const,
propertyDefinitionId: 'priority',
},
},
};
onTestFinished(
registerGraphqlSoupRevalidations(() => [
{ document: GroupSoupDocument, variables: { input } },
{ document: GroupSoupDocument, variables: { input } },
])
);
const readQuery = vi.fn(async () => ({
kind: 'hit' as const,
data: {
user: {
groupSoup: {
bins: [
{
key: 'low',
totalCount: 2,
nextCursor: null,
items: ['task-1', 'task-2'].map((id) => ({
__typename: 'GraphqlSoupDocument',
id,
})),
},
],
},
},
},
}));
const inspect = vi.fn(async () => {
throw new Error('query inspection variant count 129 exceeds limit 128');
});
graphqlClientState.host = {
...graphqlClientState.host,
readQuery,
inspectQuery: inspect,
inspectQueryVariants: inspect,
} as unknown as CacheHost;
const mutation = vi.fn(
(
_document: unknown,
_variables: unknown,
context: Record<string, unknown>
) => ({
toPromise: async () => {
(context.normalizedCacheOptimisticEnqueued as () => void)();
return {
operation: { kind: 'mutation', context },
data: { setEntityProperty: { id: 'assignment' } },
stale: false,
hasNext: false,
};
},
})
);
graphqlClientState.current = { mutation } as unknown as Client;
const save = createRoot((rootDispose) => {
dispose = rootDispose;
return createGraphqlBulkSaveEntityPropertiesMutation();
});
await save.mutateAsync({
properties: ['task-1', 'task-2'].map((entityId) => ({
entityId,
entityType: 'TASK',
property: {
propertyId: `assignment-${entityId}`,
propertyDefinitionId: 'priority',
displayName: 'Priority',
valueType: 'SELECT_STRING',
value: ['low'],
isMultiSelect: false,
} as Property,
apiValues: { valueType: 'SELECT_STRING', values: ['urgent'] },
})),
});
expect(inspect).not.toHaveBeenCalled();
expect(readQuery).toHaveBeenCalledOnce();
expect(mutation).toHaveBeenCalledTimes(2);
for (const [index, call] of mutation.mock.calls.entries()) {
expect(call[2]).toMatchObject({
normalizedCacheOptimistic: {
linkPatches: [
{
recordRoot: {
entityKey: `GraphqlSoupDocument:task-${index + 1}`,
},
operation: {
kind: 'upsertByField',
entityKey: `GraphqlProperty:assignment-task-${index + 1}`,
whereField: 'propertyDefinitionId',
equals: 'priority',
},
},
{
operation: {
kind: 'removeEmbeddedLink',
entityKey: `GraphqlSoupDocument:task-${index + 1}`,
},
},
{
operation: {
kind: 'upsertEmbeddedLink',
entityKey: `GraphqlSoupDocument:task-${index + 1}`,
},
},
],
revalidations: [
{
operationName: 'EntityProperties',
onlyOnLinkFailure: true,
},
{
operationName: 'GroupSoupMembership',
variablesJson: JSON.stringify({ input }),
},
],
},
});
}
});
it.each(['committed', 'permanently-failed'] as const)(
'waits for later queued saves and reports their %s settlement',
async (status) => {
const settlements = makeSettlementHost();
const onCommitted = vi.fn();
const onSuccess = vi.fn();
const onError = vi.fn();
const onSettled = vi.fn();
let resolveFirst!: () => void;
let submitted = 0;
const mutation = vi.fn(
(
_document: unknown,
_variables: unknown,
context: Record<string, unknown>
) => ({
toPromise: async () => {
const index = submitted++;
(context.normalizedCacheOptimisticEnqueued as () => void)();
if (index === 0) {
await new Promise<void>((resolve) => {
resolveFirst = resolve;
});
}
return {
operation: { kind: 'mutation', context } as Operation,
data: { setEntityProperty: { id: `assignment-${index}` } },
extensions: {
normalizedCacheMutationDisposition:
index === 0
? { kind: 'committed', transactionId: 'first' }
: { kind: 'queued', transactionId: 'second' },
},
stale: false,
hasNext: false,
};
},
})
);
graphqlClientState.current = { mutation } as unknown as Client;
const save = createRoot((rootDispose) => {
dispose = rootDispose;
return createGraphqlBulkSaveEntityPropertiesMutation({
onCommitted,
onSuccess,
onError,
onSettled,
});
});
const property = {
propertyId: 'assignment',
propertyDefinitionId: 'priority',
displayName: 'Priority',
valueType: 'SELECT_STRING',
isMultiSelect: false,
} as Property;
const pending = save.mutateAsync({
properties: ['task-1', 'task-2'].map((entityId) => ({
entityId,
entityType: 'TASK',
property,
apiValues: { valueType: 'SELECT_STRING', values: ['urgent'] },
})),
});
await vi.waitFor(() => expect(mutation).toHaveBeenCalledTimes(2));
resolveFirst();
await vi.waitFor(() => expect(onCommitted).toHaveBeenCalledOnce());
expect(save.isPending).toBe(true);
expect(onSuccess).not.toHaveBeenCalled();
expect(onSettled).not.toHaveBeenCalled();
settlements.emit(
status === 'committed'
? { transactionId: 'second', status }
: {
transactionId: 'second',
status,
error: 'Second property rejected',
}
);
const result = await pending;
expect(save.isPending).toBe(false);
if (status === 'committed') {
expect(result.error).toBeUndefined();
expect(onCommitted).toHaveBeenCalledTimes(2);
expect(onCommitted).toHaveBeenLastCalledWith(
expect.objectContaining({ entityId: 'task-2' }),
{ kind: 'committed' }
);
expect(onSuccess).toHaveBeenCalledOnce();
expect(onError).not.toHaveBeenCalled();
} else {
expect(result.error?.message).toContain('Second property rejected');
expect(onCommitted).toHaveBeenCalledOnce();
expect(onSuccess).not.toHaveBeenCalled();
expect(onError).toHaveBeenCalledOnce();
}
expect(onSettled).toHaveBeenCalledOnce();
expect(settlements.unsubscribe).toHaveBeenCalledOnce();
expect(settlements.unsubscribeGeneration).toHaveBeenCalledOnce();
}
);
it('links an unset task property even when global Soup inspection exceeds its budget', async () => {
makeSettlementHost();
graphqlClientState.host = {
...graphqlClientState.host,
inspectQuery: vi.fn(async () => {
throw new Error('query inspection variant count 129 exceeds limit 128');
}),
inspectQueryVariants: vi.fn(async () => []),
} as unknown as CacheHost;
const mutation = vi.fn(
(
_document: unknown,
_variables: unknown,
context: Record<string, unknown>
) => ({
toPromise: async () => ({
operation: { kind: 'mutation', context },
data: { setEntityProperty: { id: 'server-assignment' } },
stale: false,
hasNext: false,
}),
})
);
graphqlClientState.current = { mutation } as unknown as Client;
const save = createRoot((rootDispose) => {
dispose = rootDispose;
return createGraphqlBulkSaveEntityPropertiesMutation();
});
try {
await save.mutateAsync({
properties: [
{
entityType: 'TASK',
entityId: 'task-1',
property: {
propertyId: 'pending:priority',
propertyDefinitionId: 'priority',
displayName: 'Priority',
valueType: 'SELECT_STRING',
isMultiSelect: false,
value: null,
} as Property,
apiValues: { valueType: 'SELECT_STRING', values: ['urgent'] },
},
],
});
expect(mutation).toHaveBeenCalledWith(
expect.anything(),
expect.anything(),
expect.objectContaining({
normalizedCacheOptimistic: expect.objectContaining({
optimisticResponse: {
setEntityProperty: expect.objectContaining({
id: 'optimistic-property:DOCUMENT:task-1:priority',
value: {
__typename: 'GraphqlSelectOptionPropertyValue',
optionIds: ['urgent'],
},
}),
},
revalidations: [
expect.objectContaining({
operationName: 'EntityProperties',
variablesJson: JSON.stringify({
input: buildEntityPropertiesInput('TASK', 'task-1'),
}),
}),
],
linkPatches: [
expect.objectContaining({
recordRoot: {
fragmentName: 'PropertyAssignmentParent',
entityKey: 'GraphqlSoupDocument:task-1',
},
path: [{ field: 'properties' }],
operation: {
kind: 'upsertByField',
entityKey:
'GraphqlProperty:optimistic-property:DOCUMENT:task-1:priority',
whereField: 'propertyDefinitionId',
equals: 'priority',
},
}),
],
}),
})
);
expect(graphqlClientState.host.inspectQuery).not.toHaveBeenCalled();
} finally {
graphqlClientState.host = undefined;
}
});
it('runs bulk side effects through mutation callbacks', async () => {
const events: string[] = [];
const property = {
propertyId: 'assignment-1',
propertyDefinitionId: 'definition-1',
displayName: 'Status',
valueType: 'STRING',
isMultiSelect: false,
isSystemProperty: false,
isMetadata: false,
} as Property;
const mutation = vi.fn(
(
_document: unknown,
_variables: unknown,
context: Record<string, unknown>
) => ({
toPromise: async () => ({
operation: { kind: 'mutation', context } as Operation,
data: { setEntityProperty: { id: 'assignment-1' } },
stale: false,
hasNext: false,
}),
})
);
graphqlClientState.current = { mutation } as unknown as Client;
let result!: ReturnType<
typeof createGraphqlBulkSaveEntityPropertiesMutation<{ source: string }>
>;
createRoot((rootDispose) => {
dispose = rootDispose;
result = createGraphqlBulkSaveEntityPropertiesMutation({
onMutate: () => {
events.push('mutate');
return { source: 'test' };
},
onCommitted: () => {
events.push('committed');
},
onSuccess: (_input, context) => {
events.push(`success:${context?.source}`);
},
onSettled: (error, _input, context) => {
events.push(`settled:${error?.message ?? context?.source}`);
},
});
});
await result.mutateAsync({
properties: [
{
entityType: 'DOCUMENT',
entityId: 'document-1',
property,
apiValues: { valueType: 'STRING', value: 'doing' },
},
],
});
expect(events).toEqual([
'mutate',
'committed',
'success:test',
'settled:test',
]);
});
it('saves values requested by an editor that has already closed', async () => {
const onSettled = vi.fn();
const mutation = vi.fn(
(
_document: unknown,
_variables: unknown,
context: Record<string, unknown>
) => ({
toPromise: async () => ({
operation: { kind: 'mutation', context } as Operation,
data: { setEntityProperty: { id: 'assignment-1' } },
stale: false,
hasNext: false,
}),
})
);
graphqlClientState.current = { mutation } as unknown as Client;
let save!: ReturnType<typeof createGraphqlBulkSaveEntityPropertiesMutation>;
// The project picker closes before its save settles, taking the owner of
// these mutations with it.
createRoot((rootDispose) => {
save = createGraphqlBulkSaveEntityPropertiesMutation({ onSettled });
rootDispose();
});
const result = await save.mutateAsync({
properties: [
{
entityType: 'TASK',
entityId: 'task-1',
property: {
propertyId: 'assignment-1',
propertyDefinitionId: 'project',
displayName: 'Project',
valueType: 'ENTITY',
isMultiSelect: false,
} as Property,
apiValues: {
valueType: 'ENTITY',
refs: [{ entity_id: 'project-1', entity_type: 'INITIATIVE' }],
},
},
],
});
expect(result.error).toBeUndefined();
expect(mutation).toHaveBeenCalledWith(
expect.anything(),
{
input: {
entityType: 'DOCUMENT',
entityId: 'task-1',
propertyDefinitionId: 'project',
value: {
entityReference: {
entityId: 'project-1',
entityType: 'INITIATIVE',
specificMessageId: null,
},
},
},
},
expect.anything()
);
expect(onSettled).toHaveBeenCalledOnce();
});
});
describe('createGraphqlEntityPropertiesQuery', () => {
let dispose: (() => void) | undefined;
beforeEach(() => {
vi.clearAllMocks();
graphqlClientState.current = undefined;
mapGraphqlPropertiesMock.mockReturnValue([]);
});
afterEach(() => dispose?.());
it('owns the live operation and refetches it network-only', async () => {
const { requests } = makeControlledClient();
const [entityType] = createSignal<EntityType>('DOCUMENT');
const [entityId] = createSignal('entity-1');
const [enabled] = createSignal(true);
let query!: ReturnType<typeof createGraphqlEntityPropertiesQuery>;
createRoot((rootDispose) => {
dispose = rootDispose;
query = createGraphqlEntityPropertiesQuery({
entityType,
entityId,
enabled,
});
});
await vi.waitFor(() => expect(requests).toHaveLength(1));
expect(requests[0]?.operation.context.requestPolicy).toBe(
'cache-and-network'
);
requests[0]?.next({ data: EMPTY_DATA });
await vi.waitFor(() => expect(query.result.data).toEqual([]));
const refetch = query.refetch();
await vi.waitFor(() => expect(requests).toHaveLength(2));
expect(requests[1]?.operation.context.requestPolicy).toBe('network-only');
requests[1]?.next({ data: EMPTY_DATA });
await refetch;
});
it('loads initiative properties through Soup and clears prior values on navigation', async () => {
const { requests } = makeControlledClient();
const [entityId, setEntityId] = createSignal('initiative-1');
let query!: ReturnType<typeof createGraphqlEntityPropertiesQuery>;
createRoot((rootDispose) => {
dispose = rootDispose;
query = createGraphqlEntityPropertiesQuery({
entityType: () => 'INITIATIVE',
entityId,
enabled: () => true,
});
});
await vi.waitFor(() => expect(requests).toHaveLength(1));
expect(query.isEnabled()).toBe(true);
expect(requests[0].operation.variables).toEqual({
input: buildEntityPropertiesInput('INITIATIVE', 'initiative-1'),
});
requests[0].next({
data: {
user: {
soupEntity: {
__typename: 'GraphqlSoupInitiative',
id: 'initiative-1',
properties: [],
},
},
},
});
await vi.waitFor(() => expect(query.result.data).toEqual([]));
setEntityId('initiative-2');
await vi.waitFor(() => expect(requests).toHaveLength(2));
expect(requests[1].operation.variables).toEqual({
input: buildEntityPropertiesInput('INITIATIVE', 'initiative-2'),
});
expect(query.result.data).toBeUndefined();
requests[1].next({
data: {
user: {
soupEntity: {
__typename: 'GraphqlSoupInitiative',
id: 'initiative-2',
properties: [],
},
},
},
});
await vi.waitFor(() => expect(query.result.data).toEqual([]));
});
it('refreshes the mounted project sidebar when a first property value is attached without a normalized cache', async () => {
const { requests } = makeControlledClient();
let query!: ReturnType<typeof createGraphqlEntityPropertiesQuery>;
createRoot((rootDispose) => {
dispose = rootDispose;
query = createGraphqlEntityPropertiesQuery({
entityType: () => 'INITIATIVE',
entityId: () => 'initiative-1',
enabled: () => true,
});
});
await vi.waitFor(() => expect(requests).toHaveLength(1));
const data = {
user: {
soupEntity: {
__typename: 'GraphqlSoupInitiative',
id: 'initiative-1',
properties: [],
},
},
};
requests[0].next({ data });
await vi.waitFor(() => expect(query.result.data).toEqual([]));
const property: SoupProperty = {
id: 'assignment-1',
definition: {
id: 'definition-1',
display_name: 'Status',
data_type: 'STRING',
is_multi_select: false,
is_system: false,
is_metadata: false,
specific_entity_type: null,
owner: { scope: 'system' },
created_at: '',
updated_at: '',
},
value: { type: 'String', value: 'In progress' },
};
mapGraphqlPropertiesMock.mockReturnValue([property]);
const refresh = refetchGraphqlInitiativeProperties('initiative-1');
await vi.waitFor(() => expect(requests).toHaveLength(2));
expect(requests[1].operation.context.requestPolicy).toBe('network-only');
// HTTP returns a new snapshot; reusing the prior object would advertise
// unchanged data to the live query selector despite changing the mapper.
requests[1].next({ data: structuredClone(data) });
await refresh;
await vi.waitFor(() =>
expect(query.result.data?.[0].value).toBe('In progress')
);
});
it('does not start an operation for unsupported entity types', () => {
const { requests } = makeControlledClient();
const [entityType] = createSignal<EntityType>('USER');
const [entityId] = createSignal('user-1');
const [enabled] = createSignal(true);
createRoot((rootDispose) => {
dispose = rootDispose;
const query = createGraphqlEntityPropertiesQuery({
entityType,
entityId,
enabled,
});
expect(query.isEnabled()).toBe(false);
});
expect(requests).toHaveLength(0);
});
});