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
Seanaye/fix/refetch on create (#5965)
Sean Aye3ebb3e9c6b0e
diff --git a/apps/web/src/features/block-md/util/taskComposerProperties.ts b/apps/web/src/features/block-md/util/taskComposerProperties.tsindex b41796a85a..4a8333358d 100644--- a/apps/web/src/features/block-md/util/taskComposerProperties.ts+++ b/apps/web/src/features/block-md/util/taskComposerProperties.ts@@ -15,7 +15,6 @@ import type {} from '@property/types';import { useListPropertiesQuery } from '@queries/properties/definitions';import { useTagsQuery } from '@queries/properties/tags';-import { refetchSoupEntity } from '@queries/soup/cache';import type { PropertyDefinition } from '@service-properties/generated/schemas/propertyDefinition';import type { PropertyDefinitionDetailResponse } from '@service-properties/generated/schemas/propertyDefinitionDetailResponse';import { createStore, reconcile, type Store, unwrap } from 'solid-js/store';@@ -91,10 +90,7 @@ export async function createTaskWithProperties(return null;}- // refetchSoupEntity is already called inside createTask — just upsert to history- refetchSoupEntity(createdTask.documentId, 'document');-- // Upsert the new task to history+ // createTaskWithInitialSnapshot already revalidates Soup; just update history.upsertToHistory({itemId: createdTask.documentId,itemType: 'document',diff --git a/apps/web/src/features/next-soup/soup-view/soup-view-context.tsx b/apps/web/src/features/next-soup/soup-view/soup-view-context.tsxindex 608404828c..582fb9cfaa 100644--- a/apps/web/src/features/next-soup/soup-view/soup-view-context.tsx+++ b/apps/web/src/features/next-soup/soup-view/soup-view-context.tsx@@ -1001,6 +1001,7 @@ export const SoupViewContextProvider: FlowComponent<return {enabled: enabled() && !search.isSearching(),showSupportedForeignEntities: showSupportedForeignEntitiesFF().enabled,+ onBeforeGraphqlRefresh: () => groupQueries.resetToInitialPage(),meta: {itemFilter: (item) => soupItemMatchesActiveFilters(item, view),},diff --git a/apps/web/src/lib/core/util/create.ts b/apps/web/src/lib/core/util/create.tsindex 623321567d..0b285c8c7a 100644--- a/apps/web/src/lib/core/util/create.ts+++ b/apps/web/src/lib/core/util/create.ts@@ -66,7 +66,10 @@ export async function createMarkdownFile(name: args?.title ?? '',fileType: 'md',});- refetchSoupEntity(documentId, 'document', { ownTouch: true });+ refetchSoupEntity(documentId, 'document', {+ ownTouch: true,+ refreshGraphql: true,+ });analytics.track('create_entity', {entityType: 'md',@@ -162,7 +165,10 @@ async function createTaskResponse(args?: CreateTaskArgs) {fileType: 'md',subType: { type: 'task', is_completed: false },});- refetchSoupEntity(documentId, 'document', { ownTouch: true });+ refetchSoupEntity(documentId, 'document', {+ ownTouch: true,+ refreshGraphql: true,+ });analytics.track('create_entity', {entityType: 'task',@@ -221,7 +227,10 @@ export async function createSnippet(fileType: 'md',subType: { type: 'snippet' },});- refetchSoupEntity(documentId, 'document', { ownTouch: true });+ refetchSoupEntity(documentId, 'document', {+ ownTouch: true,+ refreshGraphql: true,+ });analytics.track('create_entity', {entityType: 'snippet',@@ -269,7 +278,10 @@ export async function createSkill(fileType: 'md',subType: { type: 'skill' },});- refetchSoupEntity(documentId, 'document', { ownTouch: true });+ refetchSoupEntity(documentId, 'document', {+ ownTouch: true,+ refreshGraphql: true,+ });analytics.track('create_entity', {entityType: 'skill',@@ -363,6 +375,7 @@ export async function createCodeFileFromText({});refetchSoupEntity(document.metadata.documentId, 'document', {ownTouch: true,+ refreshGraphql: true,});analytics.track('create_entity', {@@ -413,7 +426,10 @@ export async function createCanvasFileFromJsonString(args: {name: title ?? 'New Canvas',fileType: 'canvas',});- refetchSoupEntity(canvas.metadata.documentId, 'document', { ownTouch: true });+ refetchSoupEntity(canvas.metadata.documentId, 'document', {+ ownTouch: true,+ refreshGraphql: true,+ });analytics.track('create_entity', {entityType: 'canvas',@@ -450,7 +466,10 @@ export async function createChat(itemType: 'chat',name: args?.name ?? DEFAULT_CHAT_NAME,});- refetchSoupEntity(chat.id, 'chat', { ownTouch: true });+ refetchSoupEntity(chat.id, 'chat', {+ ownTouch: true,+ refreshGraphql: true,+ });analytics.track('create_entity', {entityType: 'chat',diff --git a/apps/web/src/lib/queries/soup/graphql/active-queries.test.ts b/apps/web/src/lib/queries/soup/graphql/active-queries.test.tsnew file mode 100644index 0000000000..b80d921236--- /dev/null+++ b/apps/web/src/lib/queries/soup/graphql/active-queries.test.ts@@ -0,0 +1,71 @@+import { describe, expect, it, vi } from 'vitest';+import {+ refreshActiveGraphqlSoupQueries,+ registerActiveGraphqlSoupQuery,+} from './active-queries';++describe('active GraphQL Soup queries', () => {+ it('refreshes only enabled registered queries', async () => {+ const enabledRefresh = vi.fn(async () => undefined);+ const disabledRefresh = vi.fn(async () => undefined);+ const unregisterEnabled = registerActiveGraphqlSoupQuery({+ isEnabled: () => true,+ refresh: enabledRefresh,+ });+ const unregisterDisabled = registerActiveGraphqlSoupQuery({+ isEnabled: () => false,+ refresh: disabledRefresh,+ });++ await refreshActiveGraphqlSoupQueries();++ expect(enabledRefresh).toHaveBeenCalledOnce();+ expect(disabledRefresh).not.toHaveBeenCalled();++ unregisterEnabled();+ unregisterDisabled();+ });++ it('stops refreshing a query after it unregisters', async () => {+ const refresh = vi.fn(async () => undefined);+ const unregister = registerActiveGraphqlSoupQuery({+ isEnabled: () => true,+ refresh,+ });+ unregister();++ await refreshActiveGraphqlSoupQueries();++ expect(refresh).not.toHaveBeenCalled();+ });++ it('isolates refresh failures so other active queries still refresh', async () => {+ const error = new Error('refresh failed');+ const consoleError = vi+ .spyOn(console, 'error')+ .mockImplementation(() => {});+ const unregisterFailure = registerActiveGraphqlSoupQuery({+ isEnabled: () => true,+ refresh: vi.fn(async () => {+ throw error;+ }),+ });+ const successfulRefresh = vi.fn(async () => undefined);+ const unregisterSuccess = registerActiveGraphqlSoupQuery({+ isEnabled: () => true,+ refresh: successfulRefresh,+ });++ await refreshActiveGraphqlSoupQueries();++ expect(successfulRefresh).toHaveBeenCalledOnce();+ expect(consoleError).toHaveBeenCalledWith(+ '[graphql-soup] failed to refresh active query',+ error+ );++ unregisterFailure();+ unregisterSuccess();+ consoleError.mockRestore();+ });+});diff --git a/apps/web/src/lib/queries/soup/graphql/active-queries.ts b/apps/web/src/lib/queries/soup/graphql/active-queries.tsnew file mode 100644index 0000000000..5268445520--- /dev/null+++ b/apps/web/src/lib/queries/soup/graphql/active-queries.ts@@ -0,0 +1,28 @@+type ActiveGraphqlSoupQuery = {+ isEnabled: () => boolean;+ refresh: () => Promise<void>;+};++const activeQueries = new Set<ActiveGraphqlSoupQuery>();++/** Registers a mounted GraphQL Soup query for mutation-driven revalidation. */+export function registerActiveGraphqlSoupQuery(+ query: ActiveGraphqlSoupQuery+): () => void {+ activeQueries.add(query);+ return () => activeQueries.delete(query);+}++/** Network-refreshes every mounted and enabled GraphQL Soup query. */+export async function refreshActiveGraphqlSoupQueries(): Promise<void> {+ await Promise.all(+ [...activeQueries].map(async (query) => {+ if (!query.isEnabled()) return;+ try {+ await query.refresh();+ } catch (error) {+ console.error('[graphql-soup] failed to refresh active query', error);+ }+ })+ );+}diff --git a/apps/web/src/lib/queries/soup/items.transport-refetch.test.ts b/apps/web/src/lib/queries/soup/items.transport-refetch.test.tsnew file mode 100644index 0000000000..3f8b95c5f4--- /dev/null+++ b/apps/web/src/lib/queries/soup/items.transport-refetch.test.ts@@ -0,0 +1,144 @@+import { createRoot } from 'solid-js';+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';++const testState = vi.hoisted(() => ({ graphqlEnabled: false }));+const restRefetch = vi.hoisted(() => vi.fn(async () => undefined));+const flatQuery = vi.hoisted(() => makeGraphqlQuery(false));+const groupedQuery = vi.hoisted(() => makeGraphqlQuery(true));++function makeGraphqlQuery(enabled: boolean) {+ return {+ data: vi.fn(),+ error: vi.fn(),+ isSupported: vi.fn(() => true),+ isEnabled: vi.fn(() => enabled),+ isLoading: vi.fn(() => false),+ isFetching: vi.fn(() => false),+ isFetchingNextPage: vi.fn(() => false),+ isPlaceholderData: vi.fn(() => false),+ hasNextPage: vi.fn(() => false),+ fetchNextPage: vi.fn(async () => undefined),+ resetToInitialPage: vi.fn(),+ refresh: vi.fn(async () => undefined),+ };+}++vi.mock('@app/features/next-soup/filters/query-filters', () => ({+ filterSoupItemByRequestBody: vi.fn(() => true),+}));+vi.mock('@app/lib/analytics/posthog', () => ({+ useFeatureFlag: vi.fn(() => () => ({ enabled: testState.graphqlEnabled })),+}));+vi.mock('@core/constant/featureFlags', () => ({+ ENABLE_GRAPHQL_SOUP_FLAG: 'enable-graphql-soup',+ ENABLE_GRAPHQL_SOUP_OVERRIDE: undefined,+}));+vi.mock('@core/util/result', () => ({ throwOnErr: vi.fn() }));+vi.mock('@queries/soup/grouped/api', () => ({+ groupedSortMethod: vi.fn(),+ makeGroupComparator: vi.fn(),+ parseGroupMeta: vi.fn(),+ serializeGroupByField: vi.fn(),+}));+vi.mock('@queries/soup/keys', () => ({+ soupKeys: {+ astItems: vi.fn(() => ({ queryKey: ['soup', 'ast'] })),+ },+}));+vi.mock('@queries/soup/transform-utils', () => ({+ isDisplayableSoupItem: vi.fn(() => true),+ isInstructionsMdDoc: vi.fn(() => false),+ mapApiSoupItemToEntity: vi.fn(),+ mapSoupPageToEntityList: vi.fn(),+}));+vi.mock('@queries/storage/instructions-md', () => ({+ useInstructionsMdIdQuery: vi.fn(() => ({})),+}));+vi.mock('@service-storage/client', () => ({+ storageServiceClient: { getSoupItems: vi.fn() },+}));+vi.mock('@tanstack/solid-query', () => ({+ useInfiniteQuery: vi.fn(() => ({+ data: undefined,+ error: null,+ isLoading: false,+ isFetching: false,+ isPlaceholderData: false,+ isFetchingNextPage: false,+ isEnabled: true,+ hasNextPage: false,+ fetchNextPage: vi.fn(async () => undefined),+ refetch: restRefetch,+ })),+}));+vi.mock('../client', () => ({+ queryClient: { setQueryData: vi.fn() },+}));+vi.mock('./graphql/items', () => ({+ createGraphqlSoupAstItemsQuery: vi.fn(() => flatQuery),+}));+vi.mock('./graphql/grouped-items', () => ({+ createGraphqlGroupedSoupAstItemsQuery: vi.fn(() => groupedQuery),+}));++import { refreshActiveGraphqlSoupQueries } from './graphql/active-queries';+import { type SoupAstItemsQuery, useSoupAstItemsQuery } from './items';++let disposeRoot: (() => void) | undefined;++function mountAutoTransportQuery(): SoupAstItemsQuery {+ let query: SoupAstItemsQuery | undefined;+ createRoot((dispose) => {+ disposeRoot = dispose;+ query = useSoupAstItemsQuery(() => ({+ params: {},+ body: {},+ groupBy: {+ type: 'property',+ propertyDefinitionId: 'priority',+ entityType: 'TASK',+ },+ }));+ });+ return query!;+}++describe('Soup refetch transport selection', () => {+ beforeEach(() => {+ testState.graphqlEnabled = false;+ vi.clearAllMocks();+ });++ afterEach(() => {+ disposeRoot?.();+ disposeRoot = undefined;+ });++ it('uses REST refetch and skips mutation-driven GraphQL refresh when the flag is off', async () => {+ const query = mountAutoTransportQuery();++ expect(query.transport).toBe('rest');+ await query.refetch();+ await refreshActiveGraphqlSoupQueries();++ expect(restRefetch).toHaveBeenCalledOnce();+ expect(groupedQuery.refresh).not.toHaveBeenCalled();+ });++ it('uses GraphQL refetch and mutation-driven refresh when the flag is on', async () => {+ testState.graphqlEnabled = true;+ const query = mountAutoTransportQuery();++ expect(query.transport).toBe('graphql');+ await query.refetch();+ expect(groupedQuery.refresh).toHaveBeenCalledOnce();+ expect(restRefetch).not.toHaveBeenCalled();++ vi.clearAllMocks();+ await refreshActiveGraphqlSoupQueries();++ expect(groupedQuery.resetToInitialPage).toHaveBeenCalledOnce();+ expect(groupedQuery.refresh).toHaveBeenCalledOnce();+ expect(restRefetch).not.toHaveBeenCalled();+ });+});diff --git a/apps/web/src/lib/queries/soup/items.ts b/apps/web/src/lib/queries/soup/items.tsindex cba3a1ab87..8fb5346980 100644--- a/apps/web/src/lib/queries/soup/items.ts+++ b/apps/web/src/lib/queries/soup/items.ts@@ -33,8 +33,9 @@ import {type StaleTime,useInfiniteQuery,} from '@tanstack/solid-query';-import type { Accessor } from 'solid-js';+import { type Accessor, onCleanup } from 'solid-js';import { queryClient } from '../client';+import { registerActiveGraphqlSoupQuery } from './graphql/active-queries';import { createGraphqlGroupedSoupAstItemsQuery } from './graphql/grouped-items';import { createGraphqlSoupAstItemsQuery } from './graphql/items';import {@@ -75,6 +76,8 @@ interface SoupItemsQueryOptions {itemFilter?: (item: SoupApiItem) => boolean;};showSupportedForeignEntities?: boolean;+ /** Resets view-owned GraphQL state before a mutation-driven network refresh. */+ onBeforeGraphqlRefresh?: () => void;}/**@@ -389,6 +392,17 @@ export function useSoupAstItemsQuery(};});+ onCleanup(+ registerActiveGraphqlSoupQuery({+ isEnabled: () => usesGraphql() && activeGraphqlQuery().isEnabled(),+ refresh: async () => {+ activeGraphqlQuery().resetToInitialPage();+ options?.().onBeforeGraphqlRefresh?.();+ await activeGraphqlQuery().refresh();+ },+ })+ );+const resetRestToInitialPage = () => {const { params, body, groupBy, transport } = args();queryClient.setQueryData<InfiniteData<SoupAstItemsPage, string | null>>(diff --git a/apps/web/src/lib/queries/soup/normalized-cache/operations.test.ts b/apps/web/src/lib/queries/soup/normalized-cache/operations.test.tsindex 9a4f059c95..7a3a3bc3a6 100644--- a/apps/web/src/lib/queries/soup/normalized-cache/operations.test.ts+++ b/apps/web/src/lib/queries/soup/normalized-cache/operations.test.ts@@ -11,6 +11,17 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';let testQueryClient: QueryClient;+const getSoupItemsMock = vi.hoisted(() => vi.fn());+const refreshActiveGraphqlSoupQueriesMock = vi.hoisted(() => vi.fn());++vi.mock('@service-storage/client', () => ({+ storageServiceClient: { getSoupItems: getSoupItemsMock },+}));++vi.mock('../graphql/active-queries', () => ({+ refreshActiveGraphqlSoupQueries: refreshActiveGraphqlSoupQueriesMock,+}));+vi.mock('../../client', () => ({get queryClient() {return testQueryClient;@@ -50,6 +61,7 @@ import {insertSoupEntity,optimisticUpdateSoupEntity,optimisticUpdateSoupItemUpdatedAt,+ refetchSoupEntity,removeSearchEntities,removeSoupEntities,removeSoupEntitiesFromDoneFilteredQueries,@@ -177,6 +189,11 @@ function getSearchQuery() {beforeEach(() => {vi.clearAllMocks();+ getSoupItemsMock.mockResolvedValue({+ isErr: () => false,+ value: { items: [] },+ });+ refreshActiveGraphqlSoupQueriesMock.mockResolvedValue(undefined);testQueryClient = new QueryClient({defaultOptions: {queries: { retry: false },@@ -270,6 +287,22 @@ describe('buildSingleEntityFilter', () => {});});+describe('refetchSoupEntity', () => {+ it('refreshes active GraphQL Soup queries when requested', async () => {+ await refetchSoupEntity('task-1', 'document', { refreshGraphql: true });++ expect(refreshActiveGraphqlSoupQueriesMock).toHaveBeenCalledOnce();+ expect(getSoupItemsMock).toHaveBeenCalledOnce();+ });++ it('does not refresh GraphQL Soup queries for legacy-only refetches', async () => {+ await refetchSoupEntity('task-1', 'document');++ expect(refreshActiveGraphqlSoupQueriesMock).not.toHaveBeenCalled();+ expect(getSoupItemsMock).toHaveBeenCalledOnce();+ });+});+describe('insertSoupEntity', () => {it('prepends item to first page only', () => {const page0 = [mockDocumentItem('d-1')];diff --git a/apps/web/src/lib/queries/soup/normalized-cache/operations.ts b/apps/web/src/lib/queries/soup/normalized-cache/operations.tsindex dcb0154e26..37bb8cfc14 100644--- a/apps/web/src/lib/queries/soup/normalized-cache/operations.ts+++ b/apps/web/src/lib/queries/soup/normalized-cache/operations.ts@@ -15,6 +15,7 @@ import {import { isAfter } from 'date-fns';import { match } from 'ts-pattern';import { queryClient } from '../../client';+import { refreshActiveGraphqlSoupQueries } from '../graphql/active-queries';import type { SoupApiItemFilter, SoupAstItemsPage } from '../items';import { soupKeys } from '../keys';import {@@ -552,12 +553,24 @@ export function removeSearchEntities(entityIds: Set<string>): SoupTransaction {* from the follow-up invalidation, which would replace their pages with* server state that can't include the entity until the activity consumer* catches up.+ *+ * `refreshGraphql` also network-refreshes mounted GraphQL Soup operations.+ * REST's normalized entity insertion cannot change GraphQL list or grouped-bin+ * membership, so creation callers must request this transport revalidation.*/export async function refetchSoupEntity(entityId: string,entityType: SoupEntityTag,- options?: { includeRoot?: boolean; ownTouch?: boolean }+ options?: {+ includeRoot?: boolean;+ ownTouch?: boolean;+ refreshGraphql?: boolean;+ }): Promise<void> {+ if (options?.refreshGraphql) {+ void refreshActiveGraphqlSoupQueries();+ }+const { storageServiceClient } = await import('@service-storage/client');const filter = buildSingleEntityFilter(entityType, entityId, options);