From 3290f314336714ced0407192b96a550ef1b7ccc6 Mon Sep 17 00:00:00 2001 From: Vinh Trinh Date: Tue, 10 Nov 2026 13:35:48 -0800 Subject: [PATCH 1/5] [backport cloud/1.59] feat: Workflow-id links open the saved workflow on Comfy Cloud (#23051) Backport of #23051 to cloud/1.59. Conflicts resolved by hand: the generated ingest-types files take cloud/1.59's copy plus the sidebar-file route lines #23051 added, and imports use cloud/1.59's paths (@/platform/telemetry, @/platform/workspace, @/types). (cherry picked from commit fe18e387793cdf84cd777ea06fc72a177b447324) --- browser_tests/fixtures/workflowLinkFixture.ts | 200 +++++ .../tests/workflow/cloudWorkflowLink.spec.ts | 87 +++ ...workflow-links-through-the-sidebar-file.md | 67 ++ packages/ingest-types/src/index.ts | 6 + packages/ingest-types/src/types.gen.ts | 70 ++ packages/ingest-types/src/zod.gen.ts | 25 + src/composables/useUrlActionLoaders.test.ts | 223 ++++++ src/composables/useUrlActionLoaders.ts | 75 +- src/locales/en/main.json | 2 + .../preservedQueryDefinitions.test.ts | 32 +- .../navigation/preservedQueryDefinitions.ts | 5 + .../navigation/preservedQueryNamespaces.ts | 3 +- src/platform/telemetry/TelemetryRegistry.ts | 5 + .../cloud/PostHogTelemetryProvider.test.ts | 24 + .../cloud/PostHogTelemetryProvider.ts | 5 + src/platform/telemetry/types.ts | 21 + .../composables/useLinkedWorkflowUrlLoader.ts | 21 + .../useWorkflowLinkUrlLoader.test.ts | 727 ++++++++++++++++++ .../composables/useWorkflowLinkUrlLoader.ts | 337 ++++++++ .../useWorkflowPersistenceV2.test.ts | 60 ++ .../composables/useWorkflowPersistenceV2.ts | 31 +- 21 files changed, 1999 insertions(+), 27 deletions(-) create mode 100644 browser_tests/fixtures/workflowLinkFixture.ts create mode 100644 browser_tests/tests/workflow/cloudWorkflowLink.spec.ts create mode 100644 docs/adr/WORKFLOW-LINKS-0053-open-workflow-links-through-the-sidebar-file.md create mode 100644 src/platform/workflow/management/composables/useLinkedWorkflowUrlLoader.ts create mode 100644 src/platform/workflow/management/composables/useWorkflowLinkUrlLoader.test.ts create mode 100644 src/platform/workflow/management/composables/useWorkflowLinkUrlLoader.ts diff --git a/browser_tests/fixtures/workflowLinkFixture.ts b/browser_tests/fixtures/workflowLinkFixture.ts new file mode 100644 index 00000000000..081a43fc150 --- /dev/null +++ b/browser_tests/fixtures/workflowLinkFixture.ts @@ -0,0 +1,200 @@ +import type { Page, Route } from '@playwright/test' + +import type { UserDataFullInfo } from '@/types' +import type { + ErrorResponse, + WorkflowSidebarFileResponse +} from '@comfyorg/ingest-types' + +import enMessages from '@/locales/en/main.json' with { type: 'json' } +import type { RemoteConfig } from '@/platform/remoteConfig/types' +import type { operations } from '@/types/comfyRegistryTypes' + +import linkedWorkflow from '@e2e/assets/nodes/note_nodes.json' with { type: 'json' } +import { + cloudAppExpect, + cloudAppFixture, + waitForCloudApp +} from '@e2e/fixtures/cloudAppFixture' +import { + CLOUD_SELF_EMAIL, + CloudAuthHelper +} from '@e2e/fixtures/helpers/CloudAuthHelper' +import { + bootCloud, + mockCloudBoot, + preselectCloudUser +} from '@e2e/fixtures/utils/cloudBootMocks' +import { jsonRoute } from '@e2e/fixtures/utils/jsonRoute' +import type { WorkspaceStore } from '@e2e/types/globals' + +const APP_URL = process.env.PLAYWRIGHT_TEST_URL || 'http://localhost:8188' +const BOOT_FEATURES = {} satisfies RemoteConfig +const BOOT_SETTINGS = { + 'Comfy.TutorialCompleted': true, + 'Comfy.Workflow.Persist': true +} + +type CreateCustomerResponse = + operations['createCustomer']['responses']['201']['content']['application/json'] + +export const workflowLinkScenario = { + workflowId: '82b98188-0c8f-41d2-9b91-617b9152b809', + path: 'workflows/links/linked-workflow.json', + tabName: 'linked-workflow', + notOpenedToast: enMessages.toastMessages.linkedWorkflowNotOpened +} as const + +const linkedWorkflowBody = JSON.stringify(linkedWorkflow) + +const listedFile: UserDataFullInfo = { + path: workflowLinkScenario.path.slice('workflows/'.length), + size: linkedWorkflowBody.length, + modified: 1_793_000_000_000 +} + +const sidebarFile: WorkflowSidebarFileResponse = { + ...listedFile, + path: workflowLinkScenario.path +} + +const outOfSync: ErrorResponse = { + code: 'WORKFLOW_OUT_OF_SYNC', + message: 'The workflow record does not match its sidebar file.', + details: { reason: 'content_mismatch' } +} + +function userdataFile(route: Route): string { + const { pathname } = new URL(route.request().url()) + return decodeURIComponent(pathname.split('/userdata/')[1] ?? '') +} + +class WorkflowLinkHelper { + readonly linkUrl = `${APP_URL}/?workflowId=${workflowLinkScenario.workflowId}` + private readonly savedPaths: string[] = [] + + constructor(private readonly page: Page) {} + + async mockSignedIn(): Promise { + await this.mockBoot() + await bootCloud(this.page) + } + + async mockSignedOut(): Promise { + await this.mockBoot() + await preselectCloudUser(this.page) + await this.page.route('**/customers', (route) => { + if (route.request().method() !== 'POST') return route.fallback() + return route.fulfill({ + status: 201, + json: { id: 'test-customer-e2e' } satisfies CreateCustomerResponse + }) + }) + await new CloudAuthHelper(this.page).mockLiveEmailSignIn() + } + + async serveLinkedFile(): Promise { + await this.page.route(this.sidebarFileUrl(), (route) => + route.fulfill(jsonRoute(sidebarFile)) + ) + await this.serveWorkflowsFolder() + } + + async refuseLinkedFile(): Promise { + await this.page.route(this.sidebarFileUrl(), (route) => + route.fulfill({ status: 409, json: outOfSync }) + ) + } + + async open(url: string): Promise { + await this.page.goto(url) + await waitForCloudApp(this.page) + } + + async openWithRestoredTabs(): Promise { + await this.open(APP_URL) + await this.page.reload() + await waitForCloudApp(this.page) + } + + async signInWithEmail(): Promise { + await cloudAppExpect( + this.page.getByRole('heading', { name: 'Log in to your account' }) + ).toBeVisible() + await this.page.getByRole('button', { name: 'Use email instead' }).click() + await this.page.locator('#cloud-sign-in-email').fill(CLOUD_SELF_EMAIL) + await this.page + .locator('#cloud-sign-in-password') + .fill('correct-horse-battery-staple') + await this.page.locator('#cloud-sign-in-password').blur() + await this.page.getByRole('button', { name: 'Sign in' }).click() + await waitForCloudApp(this.page) + } + + getActiveWorkflowPath(): Promise { + return this.page.evaluate( + () => + (window.app!.extensionManager as WorkspaceStore).workflow.activeWorkflow + ?.path + ) + } + + hasLinkInUrl(): boolean { + return new URL(this.page.url()).searchParams.has('workflowId') + } + + getSavedWorkflowPaths(): string[] { + return [...this.savedPaths] + } + + private sidebarFileUrl(): string { + return `**/api/workflows/${workflowLinkScenario.workflowId}/sidebar-file` + } + + private async mockBoot(): Promise { + await mockCloudBoot(this.page, { + features: BOOT_FEATURES, + settings: BOOT_SETTINGS + }) + } + + private async serveWorkflowsFolder(): Promise { + await this.page.route('**/api/userdata?*', (route) => { + const request = route.request() + const url = new URL(request.url()) + if (request.method() !== 'GET') return route.fallback() + if (url.searchParams.get('dir') !== 'workflows') return route.fallback() + return route.fulfill(jsonRoute([listedFile])) + }) + + await this.page.route('**/api/userdata/*', (route) => { + const method = route.request().method() + const file = userdataFile(route) + if (method === 'GET' && file === workflowLinkScenario.path) + return route.fulfill({ + contentType: 'application/json', + body: linkedWorkflowBody + }) + if ( + method !== 'POST' || + !file.startsWith('workflows/') || + file === 'workflows/.index.json' + ) + return route.fallback() + this.savedPaths.push(file) + return route.fulfill( + jsonRoute({ ...listedFile, path: file } satisfies UserDataFullInfo) + ) + }) + } +} + +export const workflowLinkFixture = cloudAppFixture.extend<{ + workflowLink: WorkflowLinkHelper +}>({ + workflowLink: async ({ page }, use) => { + await use(new WorkflowLinkHelper(page)) + } +}) + +export { cloudAppExpect as expect } diff --git a/browser_tests/tests/workflow/cloudWorkflowLink.spec.ts b/browser_tests/tests/workflow/cloudWorkflowLink.spec.ts new file mode 100644 index 00000000000..059502a4bf7 --- /dev/null +++ b/browser_tests/tests/workflow/cloudWorkflowLink.spec.ts @@ -0,0 +1,87 @@ +import { Topbar } from '@e2e/fixtures/components/Topbar' +import { + expect, + workflowLinkFixture as test, + workflowLinkScenario +} from '@e2e/fixtures/workflowLinkFixture' + +test.describe('Cloud workflow-id link', { tag: '@cloud' }, () => { + test.describe('when Cloud finds the sidebar file', () => { + test.beforeEach(async ({ workflowLink }) => { + await workflowLink.mockSignedIn() + await workflowLink.serveLinkedFile() + }) + + test('opens the file, clears the link and saves back to the same file', async ({ + page, + workflowLink + }) => { + const topbar = new Topbar(page) + + await workflowLink.open(workflowLink.linkUrl) + + await expect + .poll(() => workflowLink.getActiveWorkflowPath()) + .toBe(workflowLinkScenario.path) + await expect(topbar.getActiveTab()).toContainText( + workflowLinkScenario.tabName + ) + await expect.poll(() => workflowLink.hasLinkInUrl()).toBe(false) + + await topbar.triggerTopbarCommand(['File', 'Save']) + + await expect + .poll(() => workflowLink.getSavedWorkflowPaths()) + .toEqual([workflowLinkScenario.path]) + }) + }) + + test.describe('when Cloud refuses the link', () => { + test.beforeEach(async ({ workflowLink }) => { + await workflowLink.mockSignedIn() + await workflowLink.refuseLinkedFile() + }) + + test('shows the error and leaves the restored tabs as they were', async ({ + page, + toast, + workflowLink + }) => { + const topbar = new Topbar(page) + await workflowLink.openWithRestoredTabs() + await expect(topbar.tabs.first()).toBeVisible() + const restoredTabs = await topbar.getTabNames() + const restoredActiveTab = await topbar.getActiveTabName() + + await workflowLink.open(workflowLink.linkUrl) + + await expect( + toast.withText(workflowLinkScenario.notOpenedToast) + ).toBeVisible() + await expect.poll(() => topbar.getTabNames()).toEqual(restoredTabs) + expect(await topbar.getActiveTabName()).toBe(restoredActiveTab) + await expect.poll(() => workflowLink.hasLinkInUrl()).toBe(false) + }) + }) + + test.describe('when the visitor is signed out', () => { + test.beforeEach(async ({ workflowLink }) => { + await workflowLink.mockSignedOut() + await workflowLink.serveLinkedFile() + }) + + test('keeps the link through sign-in and opens the file after it', async ({ + page, + workflowLink + }) => { + await page.goto(workflowLink.linkUrl) + + await workflowLink.signInWithEmail() + + await expect + .poll(() => workflowLink.getActiveWorkflowPath()) + .toBe(workflowLinkScenario.path) + await expect.poll(() => workflowLink.hasLinkInUrl()).toBe(false) + }) + }) +}) diff --git a/docs/adr/WORKFLOW-LINKS-0053-open-workflow-links-through-the-sidebar-file.md b/docs/adr/WORKFLOW-LINKS-0053-open-workflow-links-through-the-sidebar-file.md new file mode 100644 index 00000000000..0bcba1719d3 --- /dev/null +++ b/docs/adr/WORKFLOW-LINKS-0053-open-workflow-links-through-the-sidebar-file.md @@ -0,0 +1,67 @@ +# ADR-WORKFLOW-LINKS-0053: Open Workflow Links Through the Sidebar File + +Date: 2026-11-09 + +## Status + +Proposed + +## Context + +A Cloud link of the form `?workflowId=` names one workflow. Cloud +keeps two copies of a saved workflow: the sidebar file, which the editor opens +and saves, and a workflow record with its own id, copied from that file on each +save. The copy is best effort, so the record can fall behind the file. Folder +links cannot name one file, and a path in the link breaks when the file is +renamed. + +## Decision + +Ask Cloud for the record's sidebar file with +`GET /api/workflows/{workflow_id}/sidebar-file`. Cloud answers with the file's +path only after it has checked that the file exists, that exactly one record +has that name, and that the file's bytes match the record's newest version. +Open that path through the existing workflow service, so Save writes back to +the same sidebar file. + +Fail closed. A 404 or any 409 `WORKFLOW_OUT_OF_SYNC` shows "Couldn't open this +workflow" and opens nothing. The editor never falls back to a folder link or to +the record's own content, and restored tabs stay as they were. + +Preserve the query through sign-in and onboarding. Defer the lookup while a +deployment or workspace link can reload the page, then resolve it after those +loaders finish. A workflow-id link takes precedence over a folder link, even +when it cannot be opened. Final handling clears both intents, and only for the +link it handled. A link the loader has not settled, such as a newer link the +browser navigated to meanwhile, stays in the URL and the stash. Nothing opens +it until the next page load. A workflow that opened stays open when another +navigation cancels that cleanup; the final URL-action sweep clears the link it +left. Only a reload in flight stops the URL actions. A link that is not settled +does not stop them: the other loaders run, and the final sweep removes their +params but leaves `workflowId` and its stash. A navigation guard can hold a +newer link in the stash while the URL still shows the old one. While the stash +holds a link the loader never started and the URL does not show, the sweep +makes no replace, so that link's navigation is not cancelled. + +The reply and the 409 body are validated with the generated +`@comfyorg/ingest-types` schemas. The spec types the 409 as `ErrorResponse` and +lists the `details.reason` values only in prose, saying the set may grow. The +loader keeps its list of known reasons as a telemetry classification and +records any other value as `unknown`. + +## Alternatives considered + +- Open the record's own content: rejected because Save would write to a file + the record may not match, and an out-of-date copy would open without notice. +- Link by a new id on the sidebar file: rejected because Cloud's existing + `/api/workflows/{workflow_id}` routes already name a workflow by the record's + id, and a second id for the same workflow would need its own storage. +- Extend the folder loader: rejected because folder filtering and a single + checked lookup have different failure and selection rules. + +## Consequences + +The link resolves the current sidebar path at open time. Workflow state stays +path based after opening. PostHog records the result, the 409 reason and the +workspace, never a workflow name, path or id. A record that has fallen behind +its file cannot be opened from a link until the next save copies it again. diff --git a/packages/ingest-types/src/index.ts b/packages/ingest-types/src/index.ts index cb4f795ef0c..2adf22e2cff 100644 --- a/packages/ingest-types/src/index.ts +++ b/packages/ingest-types/src/index.ts @@ -1042,6 +1042,11 @@ export type { GetWorkflowErrors, GetWorkflowResponse, GetWorkflowResponses, + GetWorkflowSidebarFileData, + GetWorkflowSidebarFileError, + GetWorkflowSidebarFileErrors, + GetWorkflowSidebarFileResponse, + GetWorkflowSidebarFileResponses, GetWorkflowTemplatesData, GetWorkflowTemplatesResponse, GetWorkflowTemplatesResponses, @@ -1641,6 +1646,7 @@ export type { WorkflowListResponse, WorkflowPublishInfo, WorkflowResponse, + WorkflowSidebarFileResponse, WorkflowUploadUrlRequest, WorkflowVersionContentResponse, WorkflowVersionResponse, diff --git a/packages/ingest-types/src/types.gen.ts b/packages/ingest-types/src/types.gen.ts index 9fd50f26720..9eb7b3efef9 100644 --- a/packages/ingest-types/src/types.gen.ts +++ b/packages/ingest-types/src/types.gen.ts @@ -284,6 +284,24 @@ export type WorkflowVersionContentResponse = { } } +/** + * The sidebar file a workflow was copied from, when the two agree. No content and no userdata id: open the path through the userdata API. + */ +export type WorkflowSidebarFileResponse = { + /** + * UNIX timestamp of the last modification in milliseconds, the same unit as GET /api/userdata?full_info=true. + */ + modified: number + /** + * The userdata path, `workflows/.json`. + */ + path: string + /** + * File size in bytes. + */ + size: number +} + /** * Workflow metadata captured at mint time. The subsequent PUT body is the * raw workflow JSON document and nothing else, so everything that would @@ -19524,6 +19542,58 @@ export type ForkWorkflowResponses = { export type ForkWorkflowResponse = ForkWorkflowResponses[keyof ForkWorkflowResponses] +export type GetWorkflowSidebarFileData = { + body?: never + path: { + /** + * The UUID of the workflow. Parsed by the handler, so a malformed id answers 404. + */ + workflow_id: string + } + query?: never + url: '/api/workflows/{workflow_id}/sidebar-file' +} + +export type GetWorkflowSidebarFileErrors = { + /** + * `code` is `workspace_id_invalid`: the `X-Comfy-Workspace-ID` header or `workspace_id` query value is malformed, or conflicts with another value or with the workspace the credential resolves to. Answered only while `web_session_enabled` is on for the user. See the `WebSessionAuth` scheme. + */ + 400: ErrorResponse + /** + * Unauthorized + */ + 401: ErrorResponse + /** + * A refused request. For a web session, `code` is `workspace_access_denied` (the selected workspace is unknown, deleted, or the user is not a member; the three look the same), `no_workspace_access` (the account has no personal workspace and is a member of no live workspace), `origin_not_allowed` or `cross_site_request`; see the `WebSessionAuth` scheme. For any credential, `sso_required` means an SSO organization holds the account (its email is on the organization's verified domains) and the credential is not an SSO sign-in, or the workspace is an SSO organization's and the account is not on its domains or the credential is not an SSO sign-in; `organization_id`, when present, names the organization to sign in with. `account_outside_organization` means the workspace is an SSO organization's and the account is on none of its domains, so no sign-in admits it; `organization_id` names the workspace's organization. `personal_workspace_disabled` means the workspace is the account's personal one and an SSO organization holds the account, so it cannot use it; `organization_id` names that organization. `FORBIDDEN` is the route's own authorization check failing, such as an unverified email. On `GET /api/billing/churnkey/auth`, `NOT_ORIGINAL_OWNER` means the caller is not the workspace's creator; it is returned only when the rollout mode is `creator`. A credential this route does not take gets AuthTypeNotAllowedError instead, and so does the session while `web_session_enabled` is off for the user, unless the operation says it takes the session whatever `web_session_enabled` says. + */ + 403: ForbiddenError + /** + * `code` is `NOT_FOUND`: no live workflow with this id that the caller created in this workspace. + */ + 404: ErrorResponse + /** + * `code` is `WORKFLOW_OUT_OF_SYNC` and `details.reason` is one of `no_sidebar_path`, `name_ambiguous`, `file_missing` or `content_mismatch`. Clients open nothing on this answer. The set of reasons may grow, and clients treat an unknown reason as out of sync. + */ + 409: ErrorResponse + /** + * Internal server error + */ + 500: ErrorResponse +} + +export type GetWorkflowSidebarFileError = + GetWorkflowSidebarFileErrors[keyof GetWorkflowSidebarFileErrors] + +export type GetWorkflowSidebarFileResponses = { + /** + * The workflow and its sidebar file agree. + */ + 200: WorkflowSidebarFileResponse +} + +export type GetWorkflowSidebarFileResponse = + GetWorkflowSidebarFileResponses[keyof GetWorkflowSidebarFileResponses] + export type CreateWorkflowVersionData = { body: CreateWorkflowVersionRequest path: { diff --git a/packages/ingest-types/src/zod.gen.ts b/packages/ingest-types/src/zod.gen.ts index 902239e776d..7706daf4539 100644 --- a/packages/ingest-types/src/zod.gen.ts +++ b/packages/ingest-types/src/zod.gen.ts @@ -176,6 +176,22 @@ export const zWorkflowVersionContentResponse = z.object({ workflow_json: z.record(z.string(), z.unknown()) }) +/** + * The sidebar file a workflow was copied from, when the two agree. No content and no userdata id: open the path through the userdata API. + */ +export const zWorkflowSidebarFileResponse = z.object({ + modified: z.coerce + .bigint() + .min(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808' + }) + .max(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807' + }), + path: z.string(), + size: z.int() +}) + /** * Workflow metadata captured at mint time. The subsequent PUT body is the * raw workflow JSON document and nothing else, so everything that would @@ -7554,6 +7570,15 @@ export const zForkWorkflowPath = z.object({ */ export const zForkWorkflowResponse = zWorkflowResponse +export const zGetWorkflowSidebarFilePath = z.object({ + workflow_id: z.string() +}) + +/** + * The workflow and its sidebar file agree. + */ +export const zGetWorkflowSidebarFileResponse = zWorkflowSidebarFileResponse + export const zCreateWorkflowVersionBody = zCreateWorkflowVersionRequest export const zCreateWorkflowVersionPath = z.object({ diff --git a/src/composables/useUrlActionLoaders.test.ts b/src/composables/useUrlActionLoaders.test.ts index df17a4332d3..400dc00eb35 100644 --- a/src/composables/useUrlActionLoaders.test.ts +++ b/src/composables/useUrlActionLoaders.test.ts @@ -9,6 +9,7 @@ import { PRESERVED_QUERY_NAMESPACES } from '@/platform/navigation/preservedQuery import { useSubscriptionDialog } from '@/platform/billing/subscription/composables/useSubscriptionDialog' import { useUrlActionLoaders } from './useUrlActionLoaders' +import type { useWorkflowLinkUrlLoader } from '@/platform/workflow/management/composables/useWorkflowLinkUrlLoader' const mockIsCloud = vi.hoisted(() => ({ value: true })) vi.mock(import('@/platform/distribution/types'), () => ({ @@ -17,6 +18,22 @@ vi.mock(import('@/platform/distribution/types'), () => ({ } })) +const workflowLinkUrlLoader = vi.hoisted(() => ({ + openWorkflowLinkFromUrl: vi.fn< + ReturnType['openWorkflowLinkFromUrl'] + >(async () => 'absent'), + isLinkSettled: vi.fn< + ReturnType['isLinkSettled'] + >(() => false), + hasLinkInFlight: vi.fn< + ReturnType['hasLinkInFlight'] + >(() => false) +})) +vi.mock( + import('@/platform/workflow/management/composables/useWorkflowLinkUrlLoader'), + () => ({ useWorkflowLinkUrlLoader: () => workflowLinkUrlLoader }) +) + const mocks = vi.hoisted(() => ({ reportError: vi.fn(), loadDeployment: vi.fn(async (): Promise => false), @@ -344,6 +361,212 @@ describe('useUrlActionLoaders', () => { ).toBeUndefined() }) + it.for(['deployment', 'workspace'] as const)( + 'preserves the workflow-id link across a %s reload without opening it', + async (kind) => { + await router.replace({ + query: { workflowId: 'workflow-id', workflows: 'ignored' } + }) + capturePreservedQuery( + PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID, + { workflowId: 'workflow-id' }, + ['workflowId'] + ) + const loader = + kind === 'deployment' ? mocks.loadDeployment : mocks.loadWorkspace + loader.mockResolvedValueOnce(true) + + await useUrlActionLoaders().runUrlActionLoaders() + + expect( + workflowLinkUrlLoader.openWorkflowLinkFromUrl + ).not.toHaveBeenCalled() + expect(router.currentRoute.value.query.workflowId).toBe('workflow-id') + expect( + getPreservedQueryParam( + PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID, + 'workflowId' + ) + ).toBe('workflow-id') + } + ) + + it('finishes the workflow-id link after navigation and clears the URL and stash', async () => { + await router.replace({ query: { workflowId: 'workflow-id', keep: 'yes' } }) + workflowLinkUrlLoader.isLinkSettled.mockReturnValue(true) + capturePreservedQuery( + PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID, + { workflowId: 'workflow-id' }, + ['workflowId'] + ) + + await useUrlActionLoaders().runUrlActionLoaders() + + expect( + workflowLinkUrlLoader.openWorkflowLinkFromUrl + ).toHaveBeenCalledExactlyOnceWith(true) + expect( + workflowLinkUrlLoader.openWorkflowLinkFromUrl.mock.invocationCallOrder[0] + ).toBeGreaterThan(mocks.loadWorkspace.mock.invocationCallOrder[0]) + expect(router.currentRoute.value.query).toEqual({ keep: 'yes' }) + expect( + getPreservedQueryParam( + PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID, + 'workflowId' + ) + ).toBeUndefined() + }) + + it('leaves a workflow-id link the browser navigated to after the settled one', async () => { + await router.replace({ query: { workflowId: 'workflow-a', keep: 'yes' } }) + workflowLinkUrlLoader.isLinkSettled.mockImplementation( + (workflowId) => workflowId === 'workflow-a' + ) + workflowLinkUrlLoader.openWorkflowLinkFromUrl.mockImplementation( + async () => { + await router.replace({ + query: { workflowId: 'workflow-b', keep: 'yes' } + }) + capturePreservedQuery( + PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID, + { workflowId: 'workflow-b' }, + ['workflowId'] + ) + return 'opened' + } + ) + + await useUrlActionLoaders().runUrlActionLoaders() + + expect(router.currentRoute.value.query).toEqual({ + workflowId: 'workflow-b', + keep: 'yes' + }) + expect( + getPreservedQueryParam( + PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID, + 'workflowId' + ) + ).toBe('workflow-b') + }) + + it('runs the later loaders and clears their params while a workflow-id link is pending', async () => { + await router.replace({ + query: { workflowId: 'workflow-id', invite: 'inv-1', settings: 'x' } + }) + capturePreservedQuery( + PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID, + { workflowId: 'workflow-id' }, + ['workflowId'] + ) + workflowLinkUrlLoader.openWorkflowLinkFromUrl.mockResolvedValue('pending') + + await useUrlActionLoaders().runUrlActionLoaders() + + expect(mocks.loadInvite).toHaveBeenCalledOnce() + expect(mocks.loadSettings).toHaveBeenCalledOnce() + expect(mocks.loadLocalHandoff).toHaveBeenCalledOnce() + expect(router.currentRoute.value.query).toEqual({ + workflowId: 'workflow-id' + }) + expect( + getPreservedQueryParam( + PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID, + 'workflowId' + ) + ).toBe('workflow-id') + expect( + useSubscriptionDialog().resumePendingPricingFlow + ).toHaveBeenCalledOnce() + }) + + it('clears the other params but leaves a newer workflow-id link and its stash', async () => { + await router.replace({ query: { workflowId: 'workflow-a', topup: '1' } }) + workflowLinkUrlLoader.isLinkSettled.mockImplementation( + (workflowId) => workflowId === 'workflow-a' + ) + workflowLinkUrlLoader.openWorkflowLinkFromUrl.mockImplementation( + async () => { + await router.replace({ + query: { workflowId: 'workflow-b', topup: '1' } + }) + capturePreservedQuery( + PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID, + { workflowId: 'workflow-b' }, + ['workflowId'] + ) + return 'opened' + } + ) + + await useUrlActionLoaders().runUrlActionLoaders() + + expect(mocks.loadTopUp).toHaveBeenCalledOnce() + expect(router.currentRoute.value.query).toEqual({ + workflowId: 'workflow-b' + }) + expect( + getPreservedQueryParam( + PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID, + 'workflowId' + ) + ).toBe('workflow-b') + expect( + useSubscriptionDialog().resumePendingPricingFlow + ).toHaveBeenCalledOnce() + }) + + it('lets a newer workflow-id link held in a navigation guard land instead of cancelling it', async () => { + await router.replace({ query: { workflowId: 'workflow-a', topup: '1' } }) + workflowLinkUrlLoader.openWorkflowLinkFromUrl.mockResolvedValue('opened') + workflowLinkUrlLoader.isLinkSettled.mockImplementation( + (workflowId) => workflowId === 'workflow-a' + ) + workflowLinkUrlLoader.hasLinkInFlight.mockReturnValue(true) + let releaseGuard: () => void = () => {} + const removeGuard = router.beforeEach(() => { + removeGuard() + return new Promise((resolve) => { + releaseGuard = resolve + }) + }) + const newerLink = router.push({ query: { workflowId: 'workflow-b' } }) + + await useUrlActionLoaders().runUrlActionLoaders() + releaseGuard() + await newerLink + + expect(mocks.loadTopUp).toHaveBeenCalledOnce() + expect(router.currentRoute.value.query).toEqual({ + workflowId: 'workflow-b' + }) + expect( + useSubscriptionDialog().resumePendingPricingFlow + ).toHaveBeenCalledOnce() + }) + + it('retains a deferred workflow-id URL and stash after identity changes', async () => { + await router.replace({ + query: { workflowId: 'workflow-id', workflows: 'ignored' } + }) + capturePreservedQuery( + PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID, + { workflowId: 'workflow-id' }, + ['workflowId'] + ) + workflowLinkUrlLoader.openWorkflowLinkFromUrl.mockResolvedValue('pending') + + await useUrlActionLoaders().runUrlActionLoaders() + + expect(router.currentRoute.value.query.workflowId).toBe('workflow-id') + expect( + getPreservedQueryParam( + PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID, + 'workflowId' + ) + ).toBe('workflow-id') + }) + it('clears a deployment param no loader acted on', async () => { await router.replace({ path: '/', diff --git a/src/composables/useUrlActionLoaders.ts b/src/composables/useUrlActionLoaders.ts index 738af44f5f0..2a202b6d0db 100644 --- a/src/composables/useUrlActionLoaders.ts +++ b/src/composables/useUrlActionLoaders.ts @@ -1,4 +1,5 @@ import { useRouter } from 'vue-router' +import type { LocationQuery } from 'vue-router' import { useAssetsUrlLoader } from '@/platform/assets/composables/useAssetsUrlLoader' import { usePricingTableUrlLoader } from '@/platform/billing/subscription/composables/usePricingTableUrlLoader' @@ -9,12 +10,16 @@ import { STRIPE_RETURN_PARAMS } from '@/platform/billing/subscription/utils/paymentReturnUrl' import { isCloud } from '@/platform/distribution/types' -import { clearPreservedQuery } from '@/platform/navigation/preservedQueryManager' +import { + clearPreservedQuery, + getPreservedQueryParam +} from '@/platform/navigation/preservedQueryManager' import { PRESERVED_QUERY_NAMESPACES } from '@/platform/navigation/preservedQueryNamespaces' import { useLocalHandoffUrlLoader } from '@/platform/openOnCloud/composables/useLocalHandoffUrlLoader' import { LOCAL_HANDOFF_PARAM } from '@/platform/openOnCloud/localHandoffProtocol' import { useSettingsUrlLoader } from '@/platform/settings/composables/useSettingsUrlLoader' import { reportError } from '@/platform/telemetry/reportError' +import { useWorkflowLinkUrlLoader } from '@/platform/workflow/management/composables/useWorkflowLinkUrlLoader' import { useCreateWorkspaceUrlLoader } from '@/platform/workspace/composables/useCreateWorkspaceUrlLoader' import { useDeploymentUrlLoader } from '@/platform/workspace/composables/useDeploymentUrlLoader' import { useInviteUrlLoader } from '@/platform/workspace/composables/useInviteUrlLoader' @@ -30,6 +35,7 @@ interface UrlActionStep { } type UrlActionLoaders = { + workflowLinkUrlLoader: ReturnType | null deploymentUrlLoader: ReturnType | null workspaceUrlLoader: ReturnType | null inviteUrlLoader: ReturnType | null @@ -90,6 +96,57 @@ function deploymentLinkSteps( ] } +function workflowLinkSteps( + loader: UrlActionLoaders['workflowLinkUrlLoader'] +): UrlActionStep[] { + if (!loader) return [] + return [ + { + failureMessage: 'Failed to open the linked workflow from URL:', + run: async () => { + await loader.openWorkflowLinkFromUrl(true) + } + } + ] +} + +function sweptWorkflowLinkParams( + loader: UrlActionLoaders['workflowLinkUrlLoader'], + query: LocationQuery +): string[] { + if (!loader) return [] + const stashed = getPreservedQueryParam( + PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID, + 'workflowId' + ) + if (stashed !== undefined && loader.isLinkSettled(stashed)) + clearPreservedQuery(PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID) + return 'workflowId' in query && loader.isLinkSettled(query.workflowId) + ? ['workflowId'] + : [] +} + +function sweepStep( + loader: UrlActionLoaders['workflowLinkUrlLoader'], + router: ReturnType +): UrlActionStep { + return { + failureMessage: 'Failed to clear handled deep-link params from the URL:', + run: async () => { + if (loader?.hasLinkInFlight()) return + clearPreservedQuery(PRESERVED_QUERY_NAMESPACES.WORKFLOWS) + const query = { ...router.currentRoute.value.query } + const params = [ + ...HANDLED_PARAMS.filter((param) => param in query), + ...sweptWorkflowLinkParams(loader, query) + ] + if (params.length === 0) return + for (const param of params) delete query[param] + await router.replace({ query }) + } + } +} + /** * Orders the deep-link loaders: the deployment link first, since with * `?deployment` it owns `?workspace` too (it switches, then picks after the @@ -111,6 +168,7 @@ function buildUrlActionSteps( run: () => loader.loadWorkspaceFromUrl() }) } + steps.push(...workflowLinkSteps(loaders.workflowLinkUrlLoader)) if (loaders.inviteUrlLoader) { const loader = loaders.inviteUrlLoader steps.push({ @@ -162,16 +220,7 @@ function buildUrlActionSteps( }) } - steps.push({ - failureMessage: 'Failed to clear handled deep-link params from the URL:', - run: async () => { - clearPreservedQuery(PRESERVED_QUERY_NAMESPACES.WORKFLOWS) - const query = { ...router.currentRoute.value.query } - if (!HANDLED_PARAMS.some((param) => param in query)) return - for (const param of HANDLED_PARAMS) delete query[param] - await router.replace({ query }) - } - }) + steps.push(sweepStep(loaders.workflowLinkUrlLoader, router)) return steps } @@ -225,7 +274,7 @@ function useIfCloud(create: () => T): T | null { /** * Aggregates the query-param "deep link" loaders the cloud app checks on mount - * (`?deployment`, `?workspace`, `?invite`, `?create_workspace`, `?pricing`, + * (`?deployment`, `?workspace`, `?workflowId`, `?invite`, `?create_workspace`, `?pricing`, * `?topup`, `?settings`, `?assets`), then recovers an interrupted checkout. The loaders * are instantiated in setup so their `useRoute`/`useRouter` resolve; call * `runUrlActionLoaders()` from `onMounted` once the app is ready. @@ -233,6 +282,7 @@ function useIfCloud(create: () => T): T | null { export function useUrlActionLoaders() { const router = useRouter() + const workflowLinkUrlLoader = useIfCloud(useWorkflowLinkUrlLoader) const deploymentUrlLoader = useIfCloud(useDeploymentUrlLoader) const workspaceUrlLoader = useIfCloud(useWorkspaceUrlLoader) const inviteUrlLoader = useIfCloud(useInviteUrlLoader) @@ -247,6 +297,7 @@ export function useUrlActionLoaders() { const steps = isCloud ? buildUrlActionSteps( { + workflowLinkUrlLoader, deploymentUrlLoader, workspaceUrlLoader, inviteUrlLoader, diff --git a/src/locales/en/main.json b/src/locales/en/main.json index 5e944b06364..984345dece9 100644 --- a/src/locales/en/main.json +++ b/src/locales/en/main.json @@ -2603,6 +2603,8 @@ "nothingToQueue": "Nothing to queue", "pleaseSelectOutputNodes": "Please select output nodes", "failedToQueue": "Failed to queue", + "linkedWorkflowNotOpened": "Couldn't open this workflow", + "linkedWorkflowLoadFailed": "Couldn't open this workflow. Please try again.", "failedToSaveDraft": "Failed to save workflow draft", "failedExecutionPathResolution": "Could not resolve path to selected nodes", "no3dScene": "No 3D scene to apply texture", diff --git a/src/platform/navigation/preservedQueryDefinitions.test.ts b/src/platform/navigation/preservedQueryDefinitions.test.ts index 802f4b8c04b..9872a05b966 100644 --- a/src/platform/navigation/preservedQueryDefinitions.test.ts +++ b/src/platform/navigation/preservedQueryDefinitions.test.ts @@ -1,4 +1,10 @@ -import { describe, expect, it } from 'vitest' +import { createMemoryHistory, createRouter } from 'vue-router' +import { + clearPreservedQuery, + getPreservedQueryParam +} from '@/platform/navigation/preservedQueryManager' +import { installPreservedQueryTracker } from '@/platform/navigation/preservedQueryTracker' +import { beforeEach, describe, expect, it } from 'vitest' import { PRESERVED_QUERY_DEFINITIONS } from '@/platform/navigation/preservedQueryDefinitions' import { PRESERVED_QUERY_NAMESPACES } from '@/platform/navigation/preservedQueryNamespaces' @@ -24,11 +30,33 @@ describe('PRESERVED_QUERY_DEFINITIONS', () => { [PRESERVED_QUERY_NAMESPACES.WORKSPACE, 'workspace'], [PRESERVED_QUERY_NAMESPACES.DEPLOYMENT, 'deployment'], [PRESERVED_QUERY_NAMESPACES.WORKFLOWS, 'workflows'], - [PRESERVED_QUERY_NAMESPACES.LOCAL_HANDOFF, 'from_local'] + [PRESERVED_QUERY_NAMESPACES.LOCAL_HANDOFF, 'from_local'], + [PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID, 'workflowId'] ])('captures %s so a redirect cannot lose it', ([namespace, key]) => { expect(registered.get(namespace)).toContain(key) }) + beforeEach(() => clearPreservedQuery(PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID)) + + it('preserves a workflow-id link through sign-in and onboarding redirects', async () => { + const router = createRouter({ + history: createMemoryHistory(), + routes: [{ path: '/:pathMatch(.*)*', component: {} }] + }) + installPreservedQueryTracker(router, PRESERVED_QUERY_DEFINITIONS) + + await router.push('/?workflowId=82b98188-0c8f-41d2-9b91-617b9152b809') + await router.push('/login') + await router.push('/onboarding') + + expect( + getPreservedQueryParam( + PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID, + 'workflowId' + ) + ).toBe('82b98188-0c8f-41d2-9b91-617b9152b809') + }) + it('registers each namespace once', () => { expect(registered.size).toBe(PRESERVED_QUERY_DEFINITIONS.length) }) diff --git a/src/platform/navigation/preservedQueryDefinitions.ts b/src/platform/navigation/preservedQueryDefinitions.ts index ce6b53a2e2e..54691bcdd8f 100644 --- a/src/platform/navigation/preservedQueryDefinitions.ts +++ b/src/platform/navigation/preservedQueryDefinitions.ts @@ -9,6 +9,11 @@ import type { PreservedQueryDefinition } from '@/platform/navigation/preservedQu * belongs in this list too. */ export const PRESERVED_QUERY_DEFINITIONS: PreservedQueryDefinition[] = [ + { + namespace: PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID, + keys: ['workflowId'], + rejectRepeated: true + }, { namespace: PRESERVED_QUERY_NAMESPACES.TEMPLATE, keys: ['template', 'source', 'mode'] diff --git a/src/platform/navigation/preservedQueryNamespaces.ts b/src/platform/navigation/preservedQueryNamespaces.ts index 2d65e7cf041..955b2958d5d 100644 --- a/src/platform/navigation/preservedQueryNamespaces.ts +++ b/src/platform/navigation/preservedQueryNamespaces.ts @@ -13,5 +13,6 @@ export const PRESERVED_QUERY_NAMESPACES = { WORKSPACE: 'workspace', DEPLOYMENT: 'deployment', WORKFLOWS: 'workflows', - LOCAL_HANDOFF: 'local_handoff' + LOCAL_HANDOFF: 'local_handoff', + WORKFLOW_ID: 'workflowId' } as const diff --git a/src/platform/telemetry/TelemetryRegistry.ts b/src/platform/telemetry/TelemetryRegistry.ts index 7dd3e5396ce..9777eda6573 100644 --- a/src/platform/telemetry/TelemetryRegistry.ts +++ b/src/platform/telemetry/TelemetryRegistry.ts @@ -93,6 +93,7 @@ import type { WidgetFavoriteToggledMetadata, WorkflowCreatedMetadata, WorkflowImportMetadata, + WorkflowLinkOpenedMetadata, WorkflowSavedMetadata, WorkspaceInviteFailedMetadata, WorkspaceInviteMetadata, @@ -330,6 +331,10 @@ export class TelemetryRegistry implements TelemetryDispatcher { this.dispatch((provider) => provider.trackWorkflowOpened?.(metadata)) } + trackWorkflowLinkOpened(metadata: WorkflowLinkOpenedMetadata): void { + this.dispatch((provider) => provider.trackWorkflowLinkOpened?.(metadata)) + } + trackWorkflowSaved(metadata: WorkflowSavedMetadata): void { this.dispatch((provider) => provider.trackWorkflowSaved?.(metadata)) } diff --git a/src/platform/telemetry/providers/cloud/PostHogTelemetryProvider.test.ts b/src/platform/telemetry/providers/cloud/PostHogTelemetryProvider.test.ts index 47dbcd9e426..80fa02229fb 100644 --- a/src/platform/telemetry/providers/cloud/PostHogTelemetryProvider.test.ts +++ b/src/platform/telemetry/providers/cloud/PostHogTelemetryProvider.test.ts @@ -183,6 +183,30 @@ describe('PostHogTelemetryProvider', () => { setLocation('') }) + it.for([ + { outcome: 'opened', workspace_id: 'workspace-1' }, + { outcome: 'not_found', workspace_id: 'workspace-1' }, + { outcome: 'error', workspace_id: null }, + { + outcome: 'out_of_sync', + reason: 'content_mismatch', + workspace_id: 'workspace-1' + } + ] as const)( + 'records the workflow-id link result $outcome with no workflow name, path or id', + async (metadata) => { + const provider = createProvider() + await vi.dynamicImportSettled() + + provider.trackWorkflowLinkOpened(metadata) + + expect(hoisted.mockCapture).toHaveBeenCalledExactlyOnceWith( + 'app:workflow_link_opened', + metadata + ) + } + ) + describe('initialization', () => { it('disables itself when posthog_project_token is not provided', async () => { const provider = createProvider({ posthog_project_token: undefined }) diff --git a/src/platform/telemetry/providers/cloud/PostHogTelemetryProvider.ts b/src/platform/telemetry/providers/cloud/PostHogTelemetryProvider.ts index aaab6249a7e..a7ad0e892d8 100644 --- a/src/platform/telemetry/providers/cloud/PostHogTelemetryProvider.ts +++ b/src/platform/telemetry/providers/cloud/PostHogTelemetryProvider.ts @@ -113,6 +113,7 @@ import type { WidgetFavoriteToggledMetadata, WorkflowCreatedMetadata, WorkflowImportMetadata, + WorkflowLinkOpenedMetadata, WorkflowSavedMetadata, WorkspaceInviteFailedMetadata, WorkspaceInviteMetadata @@ -703,6 +704,10 @@ export class PostHogTelemetryProvider implements TelemetryProvider { this.trackEvent(TelemetryEvents.WORKFLOW_OPENED, metadata) } + trackWorkflowLinkOpened(metadata: WorkflowLinkOpenedMetadata): void { + this.trackEvent(TelemetryEvents.WORKFLOW_LINK_OPENED, metadata) + } + trackWorkflowSaved(metadata: WorkflowSavedMetadata): void { this.trackEvent(TelemetryEvents.WORKFLOW_SAVED, metadata) } diff --git a/src/platform/telemetry/types.ts b/src/platform/telemetry/types.ts index d15fd652f85..f298d3708da 100644 --- a/src/platform/telemetry/types.ts +++ b/src/platform/telemetry/types.ts @@ -469,6 +469,24 @@ export interface EnterLinearMetadata { source?: string } +export type WorkflowLinkOutOfSyncReason = + | 'no_sidebar_path' + | 'name_ambiguous' + | 'file_missing' + | 'content_mismatch' + | 'unknown' + +export type WorkflowLinkOpenedMetadata = + | { + outcome: 'opened' | 'not_found' | 'error' + workspace_id: string | null + } + | { + outcome: 'out_of_sync' + reason: WorkflowLinkOutOfSyncReason + workspace_id: string | null + } + export interface WorkflowSavedMetadata { is_app: boolean is_new: boolean @@ -1567,6 +1585,7 @@ export interface TelemetryProvider { // Workflow management events trackWorkflowImported?(metadata: WorkflowImportMetadata): void trackWorkflowOpened?(metadata: WorkflowImportMetadata): void + trackWorkflowLinkOpened?(metadata: WorkflowLinkOpenedMetadata): void trackWorkflowSaved?(metadata: WorkflowSavedMetadata): void trackDefaultViewSet?(metadata: DefaultViewSetMetadata): void trackEnterLinear?(metadata: EnterLinearMetadata): void @@ -1764,6 +1783,7 @@ export const TelemetryEvents = { // Workflow Management WORKFLOW_IMPORTED: 'app:workflow_imported', WORKFLOW_OPENED: 'app:workflow_opened', + WORKFLOW_LINK_OPENED: 'app:workflow_link_opened', ENTER_LINEAR_MODE: 'app:app_mode_opened', SHARE_FLOW: 'app:share_flow', SHARE_LINK_OPENED: 'app:share_link_opened', @@ -1949,6 +1969,7 @@ export type TelemetryEventProperties = | EnterLinearMetadata | ShareFlowMetadata | ShareLinkOpenedMetadata + | WorkflowLinkOpenedMetadata | WorkflowSavedMetadata | DefaultViewSetMetadata | SubscriptionMetadata diff --git a/src/platform/workflow/management/composables/useLinkedWorkflowUrlLoader.ts b/src/platform/workflow/management/composables/useLinkedWorkflowUrlLoader.ts new file mode 100644 index 00000000000..ede1b8b9f3c --- /dev/null +++ b/src/platform/workflow/management/composables/useLinkedWorkflowUrlLoader.ts @@ -0,0 +1,21 @@ +import { useFolderWorkflowsUrlLoader } from '@/platform/workflow/management/composables/useFolderWorkflowsUrlLoader' +import { useWorkflowLinkUrlLoader } from '@/platform/workflow/management/composables/useWorkflowLinkUrlLoader' + +/** Opens the workflow a boot URL links to: a workflow id first, else a folder. */ +export function useLinkedWorkflowUrlLoader() { + const workflowLinkUrlLoader = useWorkflowLinkUrlLoader() + const folderWorkflowsUrlLoader = useFolderWorkflowsUrlLoader() + + async function openLinkedWorkflowFromUrl(): Promise< + 'opened' | 'pending' | 'none' + > { + const status = await workflowLinkUrlLoader.openWorkflowLinkFromUrl() + if (status === 'absent') { + const opened = await folderWorkflowsUrlLoader.openFolderWorkflowsFromUrl() + return opened ? 'opened' : 'none' + } + return status === 'failed' ? 'none' : status + } + + return { openLinkedWorkflowFromUrl } +} diff --git a/src/platform/workflow/management/composables/useWorkflowLinkUrlLoader.test.ts b/src/platform/workflow/management/composables/useWorkflowLinkUrlLoader.test.ts new file mode 100644 index 00000000000..0ae8b0392e3 --- /dev/null +++ b/src/platform/workflow/management/composables/useWorkflowLinkUrlLoader.test.ts @@ -0,0 +1,727 @@ +import { + assert, + beforeEach, + describe, + expect, + it, + onTestFinished, + vi +} from 'vitest' +import { effectScope } from 'vue' +import type { EffectScope } from 'vue' +import { useRoute, useRouter } from 'vue-router' +import type { NavigationFailure, RouteLocationNormalized } from 'vue-router' + +import { useToast } from '@/components/ui/toast/toastStore' +import { useUrlActionLoaders } from '@/composables/useUrlActionLoaders' +import { + capturePreservedQuery, + clearPreservedQuery, + getPreservedQueryParam +} from '@/platform/navigation/preservedQueryManager' +import { PRESERVED_QUERY_NAMESPACES } from '@/platform/navigation/preservedQueryNamespaces' +import { useTelemetry } from '@/platform/telemetry' +import { reportError } from '@/platform/telemetry/reportError' +import { useWorkflowService } from '@/platform/workflow/core/services/workflowService' +import { useLinkedWorkflowUrlLoader } from '@/platform/workflow/management/composables/useLinkedWorkflowUrlLoader' +import { useWorkflowStore } from '@/platform/workflow/management/stores/workflowStore' +import { useTeamWorkspaceStore } from '@/platform/workspace/stores/teamWorkspaceStore' +import { api } from '@/scripts/api' +import { blankGraph } from '@/scripts/defaultGraph' +import '@/scripts/changeTracker' + +import { useWorkflowLinkUrlLoader } from './useWorkflowLinkUrlLoader' + +vi.mock(import('vue-router')) +vi.mock(import('@/scripts/app')) +vi.mock(import('@/platform/telemetry')) +vi.mock(import('@/platform/workflow/core/services/workflowService')) +vi.mock(import('@/platform/workspace/composables/useDeploymentUrlLoader')) +vi.mock(import('@/platform/workspace/composables/useWorkspaceUrlLoader')) +vi.mock(import('@/platform/workspace/composables/useInviteUrlLoader')) +vi.mock(import('@/platform/workspace/composables/useCreateWorkspaceUrlLoader')) +vi.mock( + import('@/platform/billing/subscription/composables/usePricingTableUrlLoader') +) +vi.mock(import('@/platform/billing/subscription/composables/useTopUpUrlLoader')) +vi.mock( + import('@/platform/billing/subscription/composables/useSubscriptionDialog') +) +vi.mock(import('@/platform/settings/composables/useSettingsUrlLoader')) +vi.mock(import('@/platform/assets/composables/useAssetsUrlLoader')) +vi.mock(import('@/platform/openOnCloud/composables/useLocalHandoffUrlLoader')) + +const distribution = vi.hoisted(() => ({ isCloud: true })) +vi.mock(import('@/platform/distribution/types'), () => ({ + get isCloud() { + return distribution.isCloud + } +})) + +const ID = '82b98188-0c8f-41d2-9b91-617b9152b809' +const NEXT_ID = '5d1c7f0e-3a4b-4c2d-8e9f-0a1b2c3d4e5f' +const NAMESPACE = PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID +const PATH = 'workflows/Car swap.json' +const MODIFIED_MS = 1_793_000_000_000 + +function serveFile(path = PATH) { + vi.spyOn(api, 'fetchApi').mockResolvedValue( + Response.json({ path, size: 12, modified: MODIFIED_MS }) + ) + vi.spyOn(api, 'getUserData').mockImplementation(async () => + Response.json(blankGraph) + ) + vi.spyOn(api, 'listUserDataFullInfo').mockResolvedValue([ + { path: path.slice('workflows/'.length), size: 12, modified: MODIFIED_MS } + ]) +} + +function holdLookup() { + serveFile() + let respond: () => void = () => {} + vi.mocked(api.fetchApi).mockReturnValueOnce( + new Promise((resolve) => { + respond = () => + resolve(Response.json({ path: PATH, size: 12, modified: MODIFIED_MS })) + }) + ) + return () => respond() +} + +function navigateToLink(workflowId: string) { + const query = useRoute().query + Object.keys(query).forEach((key) => { + delete query[key] + }) + query.workflowId = workflowId + capturePreservedQuery(NAMESPACE, { workflowId }, ['workflowId']) +} + +function stashLink(workflowId: string) { + capturePreservedQuery(NAMESPACE, { workflowId }, ['workflowId']) +} + +const HOME: RouteLocationNormalized = { + path: '/', + fullPath: '/', + name: undefined, + params: {}, + query: {}, + hash: '', + matched: [], + meta: {}, + redirectedFrom: undefined +} + +function cancelledNavigation(): NavigationFailure { + const cancelled: NavigationFailure['type'] = 8 + return Object.assign(new Error('Navigation cancelled'), { + type: cancelled, + from: HOME, + to: HOME + }) +} + +function refuse(status: number, body: object) { + vi.spyOn(api, 'fetchApi').mockResolvedValue(Response.json(body, { status })) +} + +async function openExistingTab() { + const store = useWorkflowStore() + const existing = store.createTemporary('Existing.json') + await store.openWorkflow(existing) + return { store, existing, active: store.activeWorkflow } +} + +describe('workflow-id links', () => { + let loader: ReturnType + let scope: EffectScope + beforeEach(() => { + scope = effectScope() + onTestFinished(() => scope.stop()) + const scopedLoader = scope.run(useWorkflowLinkUrlLoader) + assert.exists(scopedLoader) + loader = scopedLoader + distribution.isCloud = true + clearPreservedQuery(NAMESPACE) + clearPreservedQuery(PRESERVED_QUERY_NAMESPACES.WORKFLOWS) + clearPreservedQuery(PRESERVED_QUERY_NAMESPACES.DEPLOYMENT) + clearPreservedQuery(PRESERVED_QUERY_NAMESPACES.WORKSPACE) + Object.assign(useTeamWorkspaceStore(), { activeWorkspaceId: 'workspace-1' }) + vi.mocked(useRouter().replace).mockImplementation(async (to) => { + const query = useRoute().query + Object.keys(query).forEach((key) => { + delete query[key] + }) + if (typeof to === 'object' && 'query' in to) + Object.assign(query, to.query) + }) + }) + + it('opens the sidebar file the workflow id names, in front of restored tabs', async () => { + serveFile() + Object.assign(useRoute().query, { + workflowId: ID, + workflows: 'other', + keep: 'yes' + }) + const { store, existing } = await openExistingTab() + vi.mocked(useWorkflowService().openWorkflow).mockImplementation( + async (workflow) => { + await store.openWorkflow(workflow) + return true + } + ) + + expect(await loader.openWorkflowLinkFromUrl()).toBe('opened') + + expect(api.fetchApi).toHaveBeenCalledExactlyOnceWith( + `/workflows/${ID}/sidebar-file` + ) + expect(store.activeWorkflow?.path).toBe(PATH) + expect(store.activeWorkflow?.isTemporary).toBe(false) + expect(store.openWorkflows.map(({ path }) => path)).toEqual([ + existing.path, + PATH + ]) + expect(useRoute().query).toEqual({ keep: 'yes' }) + expect( + useTelemetry()?.trackWorkflowLinkOpened + ).toHaveBeenCalledExactlyOnceWith({ + outcome: 'opened', + workspace_id: 'workspace-1' + }) + expect(await loader.openWorkflowLinkFromUrl()).toBe('absent') + expect(useTelemetry()?.trackWorkflowLinkOpened).toHaveBeenCalledTimes(1) + }) + + it('opens a link preserved through sign-in and onboarding and clears the stash', async () => { + serveFile() + sessionStorage.setItem( + 'Comfy.PreservedQuery.workflowId', + JSON.stringify({ workflowId: ID }) + ) + capturePreservedQuery( + PRESERVED_QUERY_NAMESPACES.WORKFLOWS, + { workflows: 'ignored' }, + ['workflows'] + ) + + expect(await loader.openWorkflowLinkFromUrl()).toBe('opened') + + expect(getPreservedQueryParam(NAMESPACE, 'workflowId')).toBeUndefined() + expect( + getPreservedQueryParam(PRESERVED_QUERY_NAMESPACES.WORKFLOWS, 'workflows') + ).toBeUndefined() + expect(sessionStorage.getItem('Comfy.PreservedQuery.workflowId')).toBeNull() + }) + + it('opens a sidebar file saved after the bootstrap listing was cached', async () => { + serveFile() + vi.mocked(api.listUserDataFullInfo).mockResolvedValueOnce([ + { path: 'old.json', size: 12, modified: MODIFIED_MS } + ]) + const store = useWorkflowStore() + await store.loadWorkflows() + Object.assign(useRoute().query, { workflowId: ID }) + vi.mocked(useWorkflowService().openWorkflow).mockImplementation( + async (workflow) => { + await store.openWorkflow(workflow) + return true + } + ) + + expect(await loader.openWorkflowLinkFromUrl()).toBe('opened') + expect(store.activeWorkflow?.path).toBe(PATH) + expect(useToast().toasts).toEqual([]) + }) + + it('reports one result across boot consumers when URL cleanup fails', async () => { + serveFile() + Object.assign(useRoute().query, { workflowId: ID }) + vi.mocked(useRouter().replace).mockRejectedValueOnce(new Error('cancelled')) + vi.mocked(useWorkflowService().openWorkflow).mockResolvedValue(true) + const scope = effectScope() + try { + const consumers = scope.run(() => [ + useWorkflowLinkUrlLoader(), + useWorkflowLinkUrlLoader() + ]) + assert.exists(consumers) + + expect(await consumers[0].openWorkflowLinkFromUrl()).toBe('opened') + await consumers[1].openWorkflowLinkFromUrl(true) + + expect(api.fetchApi).toHaveBeenCalledTimes(1) + expect(useTelemetry()?.trackWorkflowLinkOpened).toHaveBeenCalledTimes(1) + expect(useRoute().query).toEqual({}) + } finally { + scope.stop() + } + }) + + it('opens nothing and leaves restored tabs on 404', async () => { + refuse(404, { code: 'NOT_FOUND', message: 'not found' }) + Object.assign(useRoute().query, { workflowId: ID }) + const { store, existing, active } = await openExistingTab() + + expect(await loader.openWorkflowLinkFromUrl()).toBe('failed') + + expect(store.activeWorkflow).toBe(active) + expect(store.openWorkflows).toEqual([existing]) + expect(useToast().toasts.map(({ title }) => title)).toEqual([ + "Couldn't open this workflow" + ]) + expect(useWorkflowService().openWorkflow).not.toHaveBeenCalled() + expect(useRoute().query).toEqual({}) + expect( + useTelemetry()?.trackWorkflowLinkOpened + ).toHaveBeenCalledExactlyOnceWith({ + outcome: 'not_found', + workspace_id: 'workspace-1' + }) + }) + + it.for([ + { + name: 'no sidebar path in details', + body: { details: { reason: 'no_sidebar_path' } }, + reason: 'no_sidebar_path' + }, + { + name: 'an ambiguous name in details', + body: { details: { reason: 'name_ambiguous' } }, + reason: 'name_ambiguous' + }, + { + name: 'a missing file in details', + body: { details: { reason: 'file_missing' } }, + reason: 'file_missing' + }, + { + name: 'mismatched content in details', + body: { details: { reason: 'content_mismatch' } }, + reason: 'content_mismatch' + }, + { + name: 'a reason outside details', + body: { reason: 'content_mismatch' }, + reason: 'unknown' + }, + { + name: 'a reason this release does not know', + body: { details: { reason: 'Car swap.json renamed' } }, + reason: 'unknown' + }, + { + name: 'no reason', + body: {}, + reason: 'unknown' + } + ] as const)( + 'refuses an out-of-sync workflow with $name and opens nothing', + async ({ body, reason }) => { + refuse(409, { + code: 'WORKFLOW_OUT_OF_SYNC', + message: 'workflows/Car swap.json is out of sync', + ...body + }) + Object.assign(useRoute().query, { workflowId: ID, workflows: 'Car swap' }) + const { store, existing, active } = await openExistingTab() + const contentRead = vi.spyOn(api, 'getUserData') + + expect(await loader.openWorkflowLinkFromUrl()).toBe('failed') + + expect(api.fetchApi).toHaveBeenCalledTimes(1) + expect(contentRead).not.toHaveBeenCalled() + expect(useWorkflowService().openWorkflow).not.toHaveBeenCalled() + expect(store.activeWorkflow).toBe(active) + expect(store.openWorkflows).toEqual([existing]) + expect(useToast().toasts.map(({ title }) => title)).toEqual([ + "Couldn't open this workflow" + ]) + expect(useRoute().query).toEqual({}) + expect( + useTelemetry()?.trackWorkflowLinkOpened + ).toHaveBeenCalledExactlyOnceWith({ + outcome: 'out_of_sync', + reason, + workspace_id: 'workspace-1' + }) + } + ) + + it.for([ + { + name: 'another code', + response: () => Response.json({ code: 'CONFLICT' }, { status: 409 }) + }, + { + name: 'a body that is not JSON', + response: () => new Response('{', { status: 409 }) + } + ])( + 'treats a 409 with $name as out of sync for an unknown reason', + async ({ response }) => { + vi.spyOn(api, 'fetchApi').mockResolvedValue(response()) + Object.assign(useRoute().query, { workflowId: ID }) + + expect(await loader.openWorkflowLinkFromUrl()).toBe('failed') + + expect(useToast().toasts[0]?.title).toBe("Couldn't open this workflow") + expect( + useTelemetry()?.trackWorkflowLinkOpened + ).toHaveBeenCalledExactlyOnceWith({ + outcome: 'out_of_sync', + reason: 'unknown', + workspace_id: 'workspace-1' + }) + } + ) + + it.for(['invalid', '', null, [ID, ID]])( + 'rejects malformed workflowId %j without a request', + async (workflowId) => { + const request = vi.spyOn(api, 'fetchApi') + Object.assign(useRoute().query, { workflowId }) + + expect(await loader.openWorkflowLinkFromUrl()).toBe('failed') + + expect(request).not.toHaveBeenCalled() + expect(useToast().toasts[0]?.title).toBe("Couldn't open this workflow") + expect(useRoute().query).toEqual({}) + } + ) + + it.for(['workspace', 'deployment'])( + 'keeps a stashed link until the %s navigation finishes', + async (namespace) => { + const request = vi.spyOn(api, 'fetchApi') + capturePreservedQuery(NAMESPACE, { workflowId: ID }, ['workflowId']) + capturePreservedQuery(namespace, { [namespace]: 'destination' }, [ + namespace + ]) + + expect(await loader.openWorkflowLinkFromUrl()).toBe('pending') + + expect(request).not.toHaveBeenCalled() + expect(useToast().toasts).toEqual([]) + expect(useTelemetry()?.trackWorkflowLinkOpened).not.toHaveBeenCalled() + expect(getPreservedQueryParam(NAMESPACE, 'workflowId')).toBe(ID) + clearPreservedQuery(namespace) + serveFile() + + expect(await loader.openWorkflowLinkFromUrl(true)).toBe('opened') + expect(useTelemetry()?.trackWorkflowLinkOpened).toHaveBeenCalledTimes(1) + } + ) + + it('does nothing outside Cloud', async () => { + distribution.isCloud = false + const request = vi.spyOn(api, 'fetchApi') + Object.assign(useRoute().query, { workflowId: ID }) + + expect(await loader.openWorkflowLinkFromUrl()).toBe('absent') + + expect(request).not.toHaveBeenCalled() + expect(useRoute().query).toEqual({ workflowId: ID }) + expect(useTelemetry()?.trackWorkflowLinkOpened).not.toHaveBeenCalled() + }) + + it.for([ + { + name: 'server error', + response: () => new Response(null, { status: 500 }) + }, + { name: 'invalid JSON', response: () => new Response('{') }, + { + name: 'a reply without a path', + response: () => Response.json({ size: 1, modified: MODIFIED_MS }) + }, + { + name: 'a path outside the workflows folder', + response: () => + Response.json({ + path: 'comfy.settings.json', + size: 1, + modified: MODIFIED_MS + }) + }, + { + name: 'a path that leaves the workflows folder', + response: () => + Response.json({ + path: 'workflows/../secrets.json', + size: 1, + modified: MODIFIED_MS + }) + } + ])( + 'reports $name as an opening error rather than a missing workflow', + async ({ response }) => { + vi.spyOn(api, 'fetchApi').mockResolvedValue(response()) + Object.assign(useRoute().query, { workflowId: ID }) + + expect(await loader.openWorkflowLinkFromUrl()).toBe('failed') + + expect(useWorkflowService().openWorkflow).not.toHaveBeenCalled() + expect(useToast().toasts[0]?.title).toBe( + "Couldn't open this workflow. Please try again." + ) + expect(reportError).toHaveBeenCalledWith( + expect.any(Error), + expect.objectContaining({ + errorType: 'error_loading_workflow_link' + }) + ) + expect( + useTelemetry()?.trackWorkflowLinkOpened + ).toHaveBeenCalledExactlyOnceWith({ + outcome: 'error', + workspace_id: 'workspace-1' + }) + } + ) + + it('keeps the intent if the workspace changes during the lookup', async () => { + vi.spyOn(api, 'fetchApi').mockImplementation(async () => { + Object.assign(useTeamWorkspaceStore(), { + activeWorkspaceId: 'workspace-2' + }) + return new Response(null, { status: 404 }) + }) + Object.assign(useRoute().query, { workflowId: ID }) + + expect(await loader.openWorkflowLinkFromUrl()).toBe('pending') + + expect(useRoute().query.workflowId).toBe(ID) + expect(useToast().toasts).toEqual([]) + expect(useTelemetry()?.trackWorkflowLinkOpened).not.toHaveBeenCalled() + }) + + it('leaves a link the browser navigated to while an earlier lookup waited', async () => { + const respond = holdLookup() + navigateToLink(ID) + vi.mocked(useWorkflowService().openWorkflow).mockResolvedValue(true) + + const attempt = loader.openWorkflowLinkFromUrl() + navigateToLink(NEXT_ID) + respond() + + expect(await attempt).toBe('pending') + expect(useWorkflowService().openWorkflow).not.toHaveBeenCalled() + expect(useRoute().query).toEqual({ workflowId: NEXT_ID }) + expect(getPreservedQueryParam(NAMESPACE, 'workflowId')).toBe(NEXT_ID) + expect(useToast().toasts).toEqual([]) + expect(useTelemetry()?.trackWorkflowLinkOpened).not.toHaveBeenCalled() + }) + + it('opens and clears nothing when the editor unmounts while the lookup waits', async () => { + const respond = holdLookup() + navigateToLink(ID) + vi.mocked(useWorkflowService().openWorkflow).mockResolvedValue(true) + + const attempt = loader.openWorkflowLinkFromUrl() + scope.stop() + respond() + + expect(await attempt).toBe('pending') + expect(useWorkflowService().openWorkflow).not.toHaveBeenCalled() + expect(useRoute().query).toEqual({ workflowId: ID }) + expect(getPreservedQueryParam(NAMESPACE, 'workflowId')).toBe(ID) + expect(useToast().toasts).toEqual([]) + expect(useTelemetry()?.trackWorkflowLinkOpened).not.toHaveBeenCalled() + }) + + it.for([ + { + name: 'finished navigating there', + navigate: async () => navigateToLink(NEXT_ID), + route: NEXT_ID, + stash: NEXT_ID + }, + { + name: 'holds it in a navigation guard', + navigate: async () => { + stashLink(NEXT_ID) + return cancelledNavigation() + }, + route: ID, + stash: NEXT_ID + }, + { + name: 'cancelled the cleanup first', + navigate: async () => cancelledNavigation(), + route: ID, + stash: ID + } + ])( + 'leaves a newer link when the browser $name while an opened link cleared the URL', + async ({ navigate, route, stash }) => { + serveFile() + navigateToLink(ID) + vi.mocked(useWorkflowService().openWorkflow).mockResolvedValue(true) + vi.mocked(useRouter().replace).mockImplementation(navigate) + + expect(await loader.openWorkflowLinkFromUrl(true)).toBe('opened') + + expect(useRoute().query.workflowId).toBe(route) + expect(getPreservedQueryParam(NAMESPACE, 'workflowId')).toBe(stash) + expect( + useTelemetry()?.trackWorkflowLinkOpened + ).toHaveBeenCalledExactlyOnceWith({ + outcome: 'opened', + workspace_id: 'workspace-1' + }) + } + ) + + it('leaves a newer link the browser navigated to while a settled link cleared the URL again', async () => { + serveFile() + navigateToLink(ID) + vi.mocked(useWorkflowService().openWorkflow).mockResolvedValue(true) + vi.mocked(useRouter().replace).mockRejectedValueOnce(new Error('cancelled')) + expect(await loader.openWorkflowLinkFromUrl()).toBe('opened') + vi.mocked(useRouter().replace).mockImplementation(async () => { + stashLink(NEXT_ID) + return cancelledNavigation() + }) + + expect(await loader.openWorkflowLinkFromUrl(true)).toBe('opened') + + expect(api.fetchApi).toHaveBeenCalledTimes(1) + expect(useRoute().query.workflowId).toBe(ID) + expect(getPreservedQueryParam(NAMESPACE, 'workflowId')).toBe(NEXT_ID) + expect(useTelemetry()?.trackWorkflowLinkOpened).toHaveBeenCalledTimes(1) + }) + + it('keeps a boot link opened when an unrelated navigation cancels its URL cleanup, and clears it later without reopening', async () => { + serveFile() + navigateToLink(ID) + const { store } = await openExistingTab() + vi.mocked(useWorkflowService().openWorkflow).mockImplementation( + async (workflow) => { + await store.openWorkflow(workflow) + return true + } + ) + vi.mocked(useRouter().replace).mockResolvedValueOnce(cancelledNavigation()) + const linkedLoader = scope.run(useLinkedWorkflowUrlLoader) + assert.exists(linkedLoader) + + expect(await linkedLoader.openLinkedWorkflowFromUrl()).toBe('opened') + expect(store.activeWorkflow?.path).toBe(PATH) + expect(useRoute().query).toEqual({ workflowId: ID }) + + expect(await loader.openWorkflowLinkFromUrl(true)).toBe('opened') + + expect(useWorkflowService().openWorkflow).toHaveBeenCalledOnce() + expect(store.activeWorkflow?.path).toBe(PATH) + expect(useRoute().query).toEqual({}) + expect(getPreservedQueryParam(NAMESPACE, 'workflowId')).toBeUndefined() + expect(useTelemetry()?.trackWorkflowLinkOpened).toHaveBeenCalledTimes(1) + }) + + function runUrlActions() { + Object.assign(useRouter(), { currentRoute: { value: useRoute() } }) + const urlActions = scope.run(useUrlActionLoaders) + assert.exists(urlActions) + return urlActions.runUrlActionLoaders() + } + + function holdNewerLinkInGuard() { + vi.mocked(useRouter().replace).mockImplementation(async () => { + stashLink(NEXT_ID) + return cancelledNavigation() + }) + } + + it('runs the URL actions without another replace while a newer link waits in a navigation guard', async () => { + serveFile() + navigateToLink(ID) + vi.mocked(useWorkflowService().openWorkflow).mockResolvedValue(true) + holdNewerLinkInGuard() + + await runUrlActions() + + expect(useWorkflowService().openWorkflow).toHaveBeenCalledOnce() + expect(useRouter().replace).toHaveBeenCalledOnce() + expect(useRoute().query).toEqual({ workflowId: ID }) + expect(getPreservedQueryParam(NAMESPACE, 'workflowId')).toBe(NEXT_ID) + }) + + it('keeps a boot link opened and makes no other replace while a newer link waits in a navigation guard', async () => { + serveFile() + navigateToLink(ID) + const { store } = await openExistingTab() + vi.mocked(useWorkflowService().openWorkflow).mockImplementation( + async (workflow) => { + await store.openWorkflow(workflow) + return true + } + ) + vi.mocked(useRouter().replace).mockResolvedValueOnce(cancelledNavigation()) + const linkedLoader = scope.run(useLinkedWorkflowUrlLoader) + assert.exists(linkedLoader) + expect(await linkedLoader.openLinkedWorkflowFromUrl()).toBe('opened') + holdNewerLinkInGuard() + + await runUrlActions() + + expect(useWorkflowService().openWorkflow).toHaveBeenCalledOnce() + expect(store.activeWorkflow?.path).toBe(PATH) + expect(useRouter().replace).toHaveBeenCalledTimes(2) + expect(useRoute().query).toEqual({ workflowId: ID }) + expect(getPreservedQueryParam(NAMESPACE, 'workflowId')).toBe(NEXT_ID) + }) + + it('clears the other URL actions while a link from the stash waits for a workspace change', async () => { + vi.spyOn(api, 'fetchApi').mockImplementation(async () => { + Object.assign(useTeamWorkspaceStore(), { + activeWorkspaceId: 'workspace-2' + }) + return new Response(null, { status: 404 }) + }) + stashLink(ID) + Object.assign(useRoute().query, { topup: '1' }) + + await runUrlActions() + + expect(useRouter().replace).toHaveBeenCalledOnce() + expect(useRoute().query).toEqual({}) + expect(getPreservedQueryParam(NAMESPACE, 'workflowId')).toBe(ID) + expect(useTelemetry()?.trackWorkflowLinkOpened).not.toHaveBeenCalled() + }) + + it('reports an opening error when the sidebar file is not in the workflow list after a sync', async () => { + serveFile() + vi.mocked(api.listUserDataFullInfo).mockResolvedValue([]) + Object.assign(useRoute().query, { workflowId: ID }) + + expect(await loader.openWorkflowLinkFromUrl()).toBe('failed') + + expect(useWorkflowService().openWorkflow).not.toHaveBeenCalled() + expect(reportError).toHaveBeenCalledWith( + expect.any(Error), + expect.objectContaining({ + surface: 'graph', + errorType: 'error_opening_workflow_link' + }) + ) + }) + + it('keeps tabs unchanged when the sidebar file cannot be opened', async () => { + serveFile() + Object.assign(useRoute().query, { workflowId: ID }) + const { store, existing, active } = await openExistingTab() + vi.mocked(useWorkflowService().openWorkflow).mockResolvedValue(false) + + expect(await loader.openWorkflowLinkFromUrl()).toBe('failed') + + expect(store.activeWorkflow).toBe(active) + expect(store.openWorkflows).toEqual([existing]) + expect(useToast().toasts[0]?.title).toBe( + "Couldn't open this workflow. Please try again." + ) + }) +}) diff --git a/src/platform/workflow/management/composables/useWorkflowLinkUrlLoader.ts b/src/platform/workflow/management/composables/useWorkflowLinkUrlLoader.ts new file mode 100644 index 00000000000..1f85b7425eb --- /dev/null +++ b/src/platform/workflow/management/composables/useWorkflowLinkUrlLoader.ts @@ -0,0 +1,337 @@ +import { + zErrorResponse, + zWorkflowSidebarFileResponse +} from '@comfyorg/ingest-types/zod' +import { createSharedComposable } from '@vueuse/core' +import { onScopeDispose } from 'vue' +import { useRoute, useRouter } from 'vue-router' +import { z } from 'zod' + +import { useToast } from '@/components/ui/toast/toastStore' +import { t } from '@/i18n' +import { isCloud } from '@/platform/distribution/types' +import { + clearPreservedQuery, + getPreservedQueryParam, + hydratePreservedQuery, + mergePreservedQueryIntoQuery +} from '@/platform/navigation/preservedQueryManager' +import { PRESERVED_QUERY_NAMESPACES } from '@/platform/navigation/preservedQueryNamespaces' +import { useTelemetry } from '@/platform/telemetry' +import { reportError } from '@/platform/telemetry/reportError' +import type { + WorkflowLinkOpenedMetadata, + WorkflowLinkOutOfSyncReason +} from '@/platform/telemetry/types' +import { useWorkflowService } from '@/platform/workflow/core/services/workflowService' +import { useWorkflowStore } from '@/platform/workflow/management/stores/workflowStore' +import { useTeamWorkspaceStore } from '@/platform/workspace/stores/teamWorkspaceStore' +import { api } from '@/scripts/api' + +const NAMESPACE = PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID +const workflowIdSchema = z.uuid() +const outOfSyncReasonSchema = z.enum([ + 'no_sidebar_path', + 'name_ambiguous', + 'file_missing', + 'content_mismatch' +]) +const outOfSyncBodySchema = zErrorResponse.pick({ code: true, details: true }) + +type WorkflowLinkLoadStatus = 'absent' | 'pending' | 'opened' | 'failed' +type LinkOutcome = + | { kind: 'opened' } + | { kind: 'not_found' } + | { kind: 'out_of_sync'; reason: WorkflowLinkOutOfSyncReason } + | { kind: 'error' } +type ResolveOutcome = LinkOutcome | { kind: 'pending' } +type LookupResult = + | { kind: 'found'; path: string } + | Exclude +type LinkCarriers = { route: unknown; stash: string | undefined } +type Ownership = { + owns: () => boolean + unreplaced: () => boolean +} + +function isWorkflowPath(path: string): boolean { + return ( + path.startsWith('workflows/') && + path.endsWith('.json') && + !path.includes('\\') && + path + .split('/') + .every((part) => part !== '' && part !== '.' && part !== '..') + ) +} + +async function readOutOfSyncReason( + response: Response +): Promise { + const body: unknown = await response.json().catch(() => undefined) + const parsed = outOfSyncBodySchema.safeParse(body) + if (!parsed.success || parsed.data.code !== 'WORKFLOW_OUT_OF_SYNC') + return 'unknown' + const reason = outOfSyncReasonSchema.safeParse(parsed.data.details?.reason) + return reason.success ? reason.data : 'unknown' +} + +async function readLookupResponse(response: Response): Promise { + if (response.status === 404) return { kind: 'not_found' } + if (response.status === 409) + return { kind: 'out_of_sync', reason: await readOutOfSyncReason(response) } + if (!response.ok) { + reportError(new Error('Workflow link lookup failed'), { + surface: 'graph', + errorType: 'error_loading_workflow_link', + context: { status: response.status } + }) + return { kind: 'error' } + } + const body: unknown = await response.json() + const parsed = zWorkflowSidebarFileResponse.safeParse(body) + if (!parsed.success || !isWorkflowPath(parsed.data.path)) { + reportError(new Error('Invalid workflow link lookup response'), { + surface: 'graph', + errorType: 'error_loading_workflow_link' + }) + return { kind: 'error' } + } + return { kind: 'found', path: parsed.data.path } +} + +async function lookupSidebarFile(workflowId: string): Promise { + try { + const response = await api.fetchApi(`/workflows/${workflowId}/sidebar-file`) + return await readLookupResponse(response) + } catch (cause) { + reportError(new Error('Could not read workflow link', { cause }), { + surface: 'graph', + errorType: 'error_loading_workflow_link' + }) + return { kind: 'error' } + } +} + +function navigationPending(query: Record): boolean { + return [ + PRESERVED_QUERY_NAMESPACES.WORKSPACE, + PRESERVED_QUERY_NAMESPACES.DEPLOYMENT + ].some( + (namespace) => + namespace in query || + getPreservedQueryParam(namespace, namespace) !== undefined + ) +} + +function toTelemetry( + outcome: LinkOutcome, + workspaceId: string | null +): WorkflowLinkOpenedMetadata { + return outcome.kind === 'out_of_sync' + ? { + outcome: 'out_of_sync', + reason: outcome.reason, + workspace_id: workspaceId + } + : { outcome: outcome.kind, workspace_id: workspaceId } +} + +function useWorkflowLinkUrlLoaderInternal() { + const route = useRoute() + const router = useRouter() + const workflowStore = useWorkflowStore() + const workspaceStore = useTeamWorkspaceStore() + const toast = useToast() + let completed: + | { + value: unknown + workspaceId: string | null + status: 'opened' | 'failed' + } + | undefined + const startedLinks = new Set() + let disposed = false + onScopeDispose(() => { + disposed = true + }) + + async function stripLinkFromUrl(): Promise { + if (!('workflowId' in route.query) && !('workflows' in route.query)) + return true + const query = { ...route.query } + delete query.workflowId + delete query.workflows + try { + return (await router.replace({ query })) === undefined + } catch (cause) { + reportError(new Error('Could not clear workflow link', { cause }), { + surface: 'graph', + errorType: 'error_clearing_workflow_link' + }) + return true + } + } + + async function clearOwnedIntent(ownership: Ownership) { + if (!ownership.owns()) return + hydratePreservedQuery(PRESERVED_QUERY_NAMESPACES.WORKFLOWS) + if (!(await stripLinkFromUrl()) || !ownership.unreplaced()) return + clearPreservedQuery(NAMESPACE) + clearPreservedQuery(PRESERVED_QUERY_NAMESPACES.WORKFLOWS) + } + + async function openPath( + path: string, + isCurrent: () => boolean + ): Promise { + try { + await workflowStore.loadWorkflows() + if (!isCurrent()) return { kind: 'pending' } + let workflow = workflowStore.getWorkflowByPath(path) + if (!workflow) { + await workflowStore.syncWorkflows() + if (!isCurrent()) return { kind: 'pending' } + workflow = workflowStore.getWorkflowByPath(path) + } + if (!workflow) { + reportError( + new Error('Workflow link file is not in the workflow list'), + { + surface: 'graph', + errorType: 'error_opening_workflow_link' + } + ) + return { kind: 'error' } + } + const opened = await useWorkflowService().openWorkflow(workflow, { + isCurrent + }) + return opened ? { kind: 'opened' } : { kind: 'error' } + } catch (cause) { + reportError(new Error('Could not open workflow link', { cause }), { + surface: 'graph', + errorType: 'error_opening_workflow_link' + }) + return { kind: 'error' } + } + } + + async function resolveLink( + value: unknown, + isCurrent: () => boolean + ): Promise { + if (typeof value !== 'string' || !workflowIdSchema.safeParse(value).success) + return { kind: 'not_found' } + const result = await lookupSidebarFile(value) + if (!isCurrent()) return { kind: 'pending' } + return result.kind === 'found' ? openPath(result.path, isCurrent) : result + } + + function reportOutcome(outcome: LinkOutcome, workspaceId: string | null) { + if (outcome.kind !== 'opened') { + toast.error( + t( + outcome.kind === 'error' + ? 'toastMessages.linkedWorkflowLoadFailed' + : 'toastMessages.linkedWorkflowNotOpened' + ) + ) + } + useTelemetry()?.trackWorkflowLinkOpened(toTelemetry(outcome, workspaceId)) + } + + function linkQuery() { + hydratePreservedQuery(NAMESPACE) + return 'workflowId' in route.query + ? route.query + : (mergePreservedQueryIntoQuery(NAMESPACE, route.query) ?? route.query) + } + + function linkCarriers(): LinkCarriers { + return { + route: route.query.workflowId, + stash: getPreservedQueryParam(NAMESPACE, 'workflowId') + } + } + + function keepsCapturedLink(captured: LinkCarriers): boolean { + const current = linkCarriers() + return ( + (current.route === undefined || current.route === captured.route) && + (current.stash === undefined || current.stash === captured.stash) + ) + } + + function hasLink(): boolean { + const current = linkCarriers() + return current.route !== undefined || current.stash !== undefined + } + + function attemptOwnership(workspaceId: string | null): Ownership { + const captured = linkCarriers() + const unreplaced = () => + !disposed && + workspaceStore.activeWorkspaceId === workspaceId && + keepsCapturedLink(captured) + return { owns: () => hasLink() && unreplaced(), unreplaced } + } + + function completedStatus(value: unknown, workspaceId: string | null) { + if ( + !completed || + completed.value !== value || + completed.workspaceId !== workspaceId + ) + return undefined + return completed.status + } + + async function openWorkflowLinkFromUrl( + afterNavigation = false + ): Promise { + if (!isCloud) return 'absent' + const query = linkQuery() + if (!('workflowId' in query)) return 'absent' + if (!afterNavigation && navigationPending(query)) return 'pending' + return settleLink(query.workflowId, workspaceStore.activeWorkspaceId) + } + + async function settleLink( + workflowId: unknown, + workspaceId: string | null + ): Promise { + startedLinks.add(workflowId) + const ownership = attemptOwnership(workspaceId) + const priorStatus = completedStatus(workflowId, workspaceId) + if (priorStatus) { + await clearOwnedIntent(ownership) + return priorStatus + } + const outcome = await resolveLink(workflowId, ownership.owns) + if (outcome.kind === 'pending' || !ownership.owns()) return 'pending' + const status = outcome.kind === 'opened' ? 'opened' : 'failed' + completed = { value: workflowId, workspaceId, status } + await clearOwnedIntent(ownership) + reportOutcome(outcome, workspaceId) + return status + } + + function isLinkSettled(workflowId: unknown): boolean { + return ( + completedStatus(workflowId, workspaceStore.activeWorkspaceId) !== + undefined + ) + } + + function hasLinkInFlight(): boolean { + const { route, stash } = linkCarriers() + return stash !== undefined && stash !== route && !startedLinks.has(stash) + } + + return { openWorkflowLinkFromUrl, isLinkSettled, hasLinkInFlight } +} + +export const useWorkflowLinkUrlLoader = createSharedComposable( + useWorkflowLinkUrlLoaderInternal +) diff --git a/src/platform/workflow/persistence/composables/useWorkflowPersistenceV2.test.ts b/src/platform/workflow/persistence/composables/useWorkflowPersistenceV2.test.ts index 55e4fe40012..22e61b3c0ae 100644 --- a/src/platform/workflow/persistence/composables/useWorkflowPersistenceV2.test.ts +++ b/src/platform/workflow/persistence/composables/useWorkflowPersistenceV2.test.ts @@ -25,6 +25,7 @@ import { StorageKeys } from '@/platform/workflow/persistence/base/storageKeys' import * as storageIO from '@/platform/workflow/persistence/base/storageIO' import { useWorkflowDraftStoreV2 } from '@/platform/workflow/persistence/stores/workflowDraftStoreV2' import { useWorkflowPersistenceV2 } from './useWorkflowPersistenceV2' +import type { useWorkflowLinkUrlLoader } from '@/platform/workflow/management/composables/useWorkflowLinkUrlLoader' const apiEvents: EventTarget = api @@ -62,6 +63,23 @@ vi.mock( }) ) +const workflowLinkUrlLoader = vi.hoisted(() => ({ + openWorkflowLinkFromUrl: vi.fn< + ReturnType['openWorkflowLinkFromUrl'] + >(async () => 'absent'), + isLinkSettled: vi.fn< + ReturnType['isLinkSettled'] + >(() => false), + hasLinkInFlight: vi.fn< + ReturnType['hasLinkInFlight'] + >(() => false) +})) + +vi.mock( + import('@/platform/workflow/management/composables/useWorkflowLinkUrlLoader'), + () => ({ useWorkflowLinkUrlLoader: () => workflowLinkUrlLoader }) +) + const folderWorkflowsUrlLoader = vi.hoisted(() => ({ openFolderWorkflowsFromUrl: vi.fn(async () => false) })) @@ -853,6 +871,48 @@ describe('useWorkflowPersistenceV2', () => { ) }) + describe('a workflow-id link', () => { + it('defers Getting Started while a workflow-id link waits for navigation', async () => { + workflowLinkUrlLoader.openWorkflowLinkFromUrl.mockResolvedValue('pending') + vi.spyOn(useWorkflowStore(), 'loadWorkflows').mockResolvedValue() + + await expect( + mountWorkflowPersistence().initializeWorkflow() + ).resolves.toBe('url-intent') + }) + + it.for(['opened', 'failed', 'pending'] as const)( + 'does not fall back to a folder when the workflow-id link result is %s', + async (status) => { + workflowLinkUrlLoader.openWorkflowLinkFromUrl.mockResolvedValue(status) + vi.spyOn(useWorkflowStore(), 'loadWorkflows').mockResolvedValue() + const { initializeWorkflow } = mountWorkflowPersistence() + + await initializeWorkflow() + + expect( + folderWorkflowsUrlLoader.openFolderWorkflowsFromUrl + ).not.toHaveBeenCalled() + } + ) + + it('keeps restored tabs behind the linked workflow without replacing the active tab', async () => { + const store = useWorkflowStore() + vi.spyOn(store, 'loadWorkflows').mockResolvedValue() + const previous = store.createTemporary('Previous.json') + writeTabState([previous.path], 0) + workflowLinkUrlLoader.openWorkflowLinkFromUrl.mockResolvedValue('opened') + const { initializeWorkflow, restoreWorkflowTabsState } = + mountWorkflowPersistence() + + await initializeWorkflow() + await restoreWorkflowTabsState() + + expect(store.openWorkflows).toEqual([previous]) + expect(openWorkflowMock).not.toHaveBeenCalled() + }) + }) + describe('a link that names a workflows folder', () => { it('opens the folder instead of restoring the last workflow', async () => { const workflowStore = useWorkflowStore() diff --git a/src/platform/workflow/persistence/composables/useWorkflowPersistenceV2.ts b/src/platform/workflow/persistence/composables/useWorkflowPersistenceV2.ts index cd165415b36..2f0396bbd92 100644 --- a/src/platform/workflow/persistence/composables/useWorkflowPersistenceV2.ts +++ b/src/platform/workflow/persistence/composables/useWorkflowPersistenceV2.ts @@ -24,7 +24,7 @@ import { PRESERVED_QUERY_NAMESPACES } from '@/platform/navigation/preservedQuery import { isCloud } from '@/platform/distribution/types' import { LOCAL_HANDOFF_PARAM } from '@/platform/openOnCloud/localHandoffProtocol' import { useSettingStore } from '@/platform/settings/settingStore' -import { useFolderWorkflowsUrlLoader } from '@/platform/workflow/management/composables/useFolderWorkflowsUrlLoader' +import { useLinkedWorkflowUrlLoader } from '@/platform/workflow/management/composables/useLinkedWorkflowUrlLoader' import { useTeamWorkspaceStore } from '@/platform/workspace/stores/teamWorkspaceStore' import { useWorkflowService } from '@/platform/workflow/core/services/workflowService' import { @@ -57,8 +57,8 @@ export function useWorkflowPersistenceV2() { const router = useRouter() const sharedWorkflowUrlLoader = useSharedWorkflowUrlLoader() const templateUrlLoader = useTemplateUrlLoader() - const folderWorkflowsUrlLoader = useFolderWorkflowsUrlLoader() - let openedFolderWorkflows = false + const linkedWorkflowUrlLoader = useLinkedWorkflowUrlLoader() + let openedLinkedWorkflow = false const TEMPLATE_NAMESPACE = PRESERVED_QUERY_NAMESPACES.TEMPLATE const SHARE_NAMESPACE = PRESERVED_QUERY_NAMESPACES.SHARE const LOCAL_HANDOFF_NAMESPACE = PRESERVED_QUERY_NAMESPACES.LOCAL_HANDOFF @@ -299,7 +299,9 @@ export function useWorkflowPersistenceV2() { flags.openOnCloudEnabled && hasPreservedIntent(LOCAL_HANDOFF_NAMESPACE, LOCAL_HANDOFF_PARAM) - const resolveStartupOutcome = async (): Promise => { + const resolveStartupOutcome = async ( + workflowLinkPending = false + ): Promise => { if (settingStore.get('Comfy.TutorialCompleted')) { await comfyApp.loadGraphData() return 'restored' @@ -308,7 +310,8 @@ export function useWorkflowPersistenceV2() { await useWorkflowService().loadBlankWorkflow() await nextTick() discardStartupBlankDraft() - return hasSharedWorkflowIntent() || + return workflowLinkPending || + hasSharedWorkflowIntent() || hasTemplateUrlIntent() || hasLocalHandoffIntent() ? 'url-intent' @@ -328,12 +331,14 @@ export function useWorkflowPersistenceV2() { } const initializeWorkflow = async (): Promise => { - openedFolderWorkflows = - await folderWorkflowsUrlLoader.openFolderWorkflowsFromUrl() - if (openedFolderWorkflows) return 'restored' + const linkedWorkflow = + await linkedWorkflowUrlLoader.openLinkedWorkflowFromUrl() + const workflowLinkPending = linkedWorkflow === 'pending' + openedLinkedWorkflow = linkedWorkflow === 'opened' + if (openedLinkedWorkflow) return 'restored' if (!workflowPersistenceEnabled.value) { - return await resolveStartupOutcome() + return await resolveStartupOutcome(workflowLinkPending) } const isRestoreCurrent = await waitForRestoreIdentity() @@ -347,10 +352,12 @@ export function useWorkflowPersistenceV2() { if (!isRestoreCurrent()) return 'restored' const restored = await loadPreviousWorkflowFromStorage(isRestoreCurrent) if (!isRestoreCurrent()) return 'restored' - return restored ? 'restored' : await resolveStartupOutcome() + return restored + ? 'restored' + : await resolveStartupOutcome(workflowLinkPending) } catch (err) { console.error('Error loading previous workflow', err) - return await resolveStartupOutcome() + return await resolveStartupOutcome(workflowLinkPending) } } @@ -500,7 +507,7 @@ export function useWorkflowPersistenceV2() { }) tabStateRestored = true - if (openedFolderWorkflows) return + if (openedLinkedWorkflow) return const activePath = storedWorkflows[storedActiveIndex] const workflow = activePath From a1731d2a1b77e0d8919cd4f2039b5a6bd53d6571 Mon Sep 17 00:00:00 2001 From: Vinh Trinh Date: Tue, 10 Nov 2026 13:55:16 -0800 Subject: [PATCH 2/5] fix(backport): fit the workflow-link loader to cloud/1.59's domain zones cloud/1.59 classifies src/platform/workflow/management/composables as workflow-management, whose zone may not import telemetry, toast, i18n, navigation, workspace or the API client, and which app-host and workflow-persistence may not import. Move the workflow-id loader, its test and the linked-workflow loader to unclassified src/composables, where the other cross-domain URL loaders already live, and move the settled-link sweep out of useUrlActionLoaders so its navigation import stays as the base has it. Move the redirect round-trip test to preservedQueryTracker.test.ts, whose zone may import the tracker and manager, and cover the registry's trackWorkflowLinkOpened dispatch. Behavior is unchanged. --- src/composables/sweptWorkflowLinkParams.ts | 25 ++++++++++++++++ .../composables/useLinkedWorkflowUrlLoader.ts | 2 +- src/composables/useUrlActionLoaders.test.ts | 9 +++--- src/composables/useUrlActionLoaders.ts | 25 ++-------------- .../useWorkflowLinkUrlLoader.test.ts | 2 +- .../composables/useWorkflowLinkUrlLoader.ts | 0 .../preservedQueryDefinitions.test.ts | 29 +------------------ .../navigation/preservedQueryTracker.test.ts | 22 ++++++++++++++ .../telemetry/TelemetryRegistry.test.ts | 17 +++++++++++ .../useWorkflowPersistenceV2.test.ts | 9 +++--- .../composables/useWorkflowPersistenceV2.ts | 2 +- 11 files changed, 79 insertions(+), 63 deletions(-) create mode 100644 src/composables/sweptWorkflowLinkParams.ts rename src/{platform/workflow/management => }/composables/useLinkedWorkflowUrlLoader.ts (87%) rename src/{platform/workflow/management => }/composables/useWorkflowLinkUrlLoader.test.ts (99%) rename src/{platform/workflow/management => }/composables/useWorkflowLinkUrlLoader.ts (100%) diff --git a/src/composables/sweptWorkflowLinkParams.ts b/src/composables/sweptWorkflowLinkParams.ts new file mode 100644 index 00000000000..492c29f2645 --- /dev/null +++ b/src/composables/sweptWorkflowLinkParams.ts @@ -0,0 +1,25 @@ +import type { LocationQuery } from 'vue-router' + +import type { useWorkflowLinkUrlLoader } from '@/composables/useWorkflowLinkUrlLoader' +import { + clearPreservedQuery, + getPreservedQueryParam +} from '@/platform/navigation/preservedQueryManager' +import { PRESERVED_QUERY_NAMESPACES } from '@/platform/navigation/preservedQueryNamespaces' + +/** The settled workflow-id params the deep-link sweep may drop; clears a settled stash. */ +export function sweptWorkflowLinkParams( + loader: ReturnType | null, + query: LocationQuery +): string[] { + if (!loader) return [] + const stashed = getPreservedQueryParam( + PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID, + 'workflowId' + ) + if (stashed !== undefined && loader.isLinkSettled(stashed)) + clearPreservedQuery(PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID) + return 'workflowId' in query && loader.isLinkSettled(query.workflowId) + ? ['workflowId'] + : [] +} diff --git a/src/platform/workflow/management/composables/useLinkedWorkflowUrlLoader.ts b/src/composables/useLinkedWorkflowUrlLoader.ts similarity index 87% rename from src/platform/workflow/management/composables/useLinkedWorkflowUrlLoader.ts rename to src/composables/useLinkedWorkflowUrlLoader.ts index ede1b8b9f3c..93ea0707896 100644 --- a/src/platform/workflow/management/composables/useLinkedWorkflowUrlLoader.ts +++ b/src/composables/useLinkedWorkflowUrlLoader.ts @@ -1,5 +1,5 @@ +import { useWorkflowLinkUrlLoader } from '@/composables/useWorkflowLinkUrlLoader' import { useFolderWorkflowsUrlLoader } from '@/platform/workflow/management/composables/useFolderWorkflowsUrlLoader' -import { useWorkflowLinkUrlLoader } from '@/platform/workflow/management/composables/useWorkflowLinkUrlLoader' /** Opens the workflow a boot URL links to: a workflow id first, else a folder. */ export function useLinkedWorkflowUrlLoader() { diff --git a/src/composables/useUrlActionLoaders.test.ts b/src/composables/useUrlActionLoaders.test.ts index 400dc00eb35..4a37346fe01 100644 --- a/src/composables/useUrlActionLoaders.test.ts +++ b/src/composables/useUrlActionLoaders.test.ts @@ -9,7 +9,7 @@ import { PRESERVED_QUERY_NAMESPACES } from '@/platform/navigation/preservedQuery import { useSubscriptionDialog } from '@/platform/billing/subscription/composables/useSubscriptionDialog' import { useUrlActionLoaders } from './useUrlActionLoaders' -import type { useWorkflowLinkUrlLoader } from '@/platform/workflow/management/composables/useWorkflowLinkUrlLoader' +import type { useWorkflowLinkUrlLoader } from '@/composables/useWorkflowLinkUrlLoader' const mockIsCloud = vi.hoisted(() => ({ value: true })) vi.mock(import('@/platform/distribution/types'), () => ({ @@ -29,10 +29,9 @@ const workflowLinkUrlLoader = vi.hoisted(() => ({ ReturnType['hasLinkInFlight'] >(() => false) })) -vi.mock( - import('@/platform/workflow/management/composables/useWorkflowLinkUrlLoader'), - () => ({ useWorkflowLinkUrlLoader: () => workflowLinkUrlLoader }) -) +vi.mock(import('@/composables/useWorkflowLinkUrlLoader'), () => ({ + useWorkflowLinkUrlLoader: () => workflowLinkUrlLoader +})) const mocks = vi.hoisted(() => ({ reportError: vi.fn(), diff --git a/src/composables/useUrlActionLoaders.ts b/src/composables/useUrlActionLoaders.ts index 2a202b6d0db..b8017cd8754 100644 --- a/src/composables/useUrlActionLoaders.ts +++ b/src/composables/useUrlActionLoaders.ts @@ -1,6 +1,7 @@ import { useRouter } from 'vue-router' -import type { LocationQuery } from 'vue-router' +import { sweptWorkflowLinkParams } from '@/composables/sweptWorkflowLinkParams' +import { useWorkflowLinkUrlLoader } from '@/composables/useWorkflowLinkUrlLoader' import { useAssetsUrlLoader } from '@/platform/assets/composables/useAssetsUrlLoader' import { usePricingTableUrlLoader } from '@/platform/billing/subscription/composables/usePricingTableUrlLoader' import { useSubscriptionDialog } from '@/platform/billing/subscription/composables/useSubscriptionDialog' @@ -10,16 +11,12 @@ import { STRIPE_RETURN_PARAMS } from '@/platform/billing/subscription/utils/paymentReturnUrl' import { isCloud } from '@/platform/distribution/types' -import { - clearPreservedQuery, - getPreservedQueryParam -} from '@/platform/navigation/preservedQueryManager' +import { clearPreservedQuery } from '@/platform/navigation/preservedQueryManager' import { PRESERVED_QUERY_NAMESPACES } from '@/platform/navigation/preservedQueryNamespaces' import { useLocalHandoffUrlLoader } from '@/platform/openOnCloud/composables/useLocalHandoffUrlLoader' import { LOCAL_HANDOFF_PARAM } from '@/platform/openOnCloud/localHandoffProtocol' import { useSettingsUrlLoader } from '@/platform/settings/composables/useSettingsUrlLoader' import { reportError } from '@/platform/telemetry/reportError' -import { useWorkflowLinkUrlLoader } from '@/platform/workflow/management/composables/useWorkflowLinkUrlLoader' import { useCreateWorkspaceUrlLoader } from '@/platform/workspace/composables/useCreateWorkspaceUrlLoader' import { useDeploymentUrlLoader } from '@/platform/workspace/composables/useDeploymentUrlLoader' import { useInviteUrlLoader } from '@/platform/workspace/composables/useInviteUrlLoader' @@ -110,22 +107,6 @@ function workflowLinkSteps( ] } -function sweptWorkflowLinkParams( - loader: UrlActionLoaders['workflowLinkUrlLoader'], - query: LocationQuery -): string[] { - if (!loader) return [] - const stashed = getPreservedQueryParam( - PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID, - 'workflowId' - ) - if (stashed !== undefined && loader.isLinkSettled(stashed)) - clearPreservedQuery(PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID) - return 'workflowId' in query && loader.isLinkSettled(query.workflowId) - ? ['workflowId'] - : [] -} - function sweepStep( loader: UrlActionLoaders['workflowLinkUrlLoader'], router: ReturnType diff --git a/src/platform/workflow/management/composables/useWorkflowLinkUrlLoader.test.ts b/src/composables/useWorkflowLinkUrlLoader.test.ts similarity index 99% rename from src/platform/workflow/management/composables/useWorkflowLinkUrlLoader.test.ts rename to src/composables/useWorkflowLinkUrlLoader.test.ts index 0ae8b0392e3..a7e7a21c426 100644 --- a/src/platform/workflow/management/composables/useWorkflowLinkUrlLoader.test.ts +++ b/src/composables/useWorkflowLinkUrlLoader.test.ts @@ -13,6 +13,7 @@ import { useRoute, useRouter } from 'vue-router' import type { NavigationFailure, RouteLocationNormalized } from 'vue-router' import { useToast } from '@/components/ui/toast/toastStore' +import { useLinkedWorkflowUrlLoader } from '@/composables/useLinkedWorkflowUrlLoader' import { useUrlActionLoaders } from '@/composables/useUrlActionLoaders' import { capturePreservedQuery, @@ -23,7 +24,6 @@ import { PRESERVED_QUERY_NAMESPACES } from '@/platform/navigation/preservedQuery import { useTelemetry } from '@/platform/telemetry' import { reportError } from '@/platform/telemetry/reportError' import { useWorkflowService } from '@/platform/workflow/core/services/workflowService' -import { useLinkedWorkflowUrlLoader } from '@/platform/workflow/management/composables/useLinkedWorkflowUrlLoader' import { useWorkflowStore } from '@/platform/workflow/management/stores/workflowStore' import { useTeamWorkspaceStore } from '@/platform/workspace/stores/teamWorkspaceStore' import { api } from '@/scripts/api' diff --git a/src/platform/workflow/management/composables/useWorkflowLinkUrlLoader.ts b/src/composables/useWorkflowLinkUrlLoader.ts similarity index 100% rename from src/platform/workflow/management/composables/useWorkflowLinkUrlLoader.ts rename to src/composables/useWorkflowLinkUrlLoader.ts diff --git a/src/platform/navigation/preservedQueryDefinitions.test.ts b/src/platform/navigation/preservedQueryDefinitions.test.ts index 9872a05b966..ed4f3653dc2 100644 --- a/src/platform/navigation/preservedQueryDefinitions.test.ts +++ b/src/platform/navigation/preservedQueryDefinitions.test.ts @@ -1,10 +1,4 @@ -import { createMemoryHistory, createRouter } from 'vue-router' -import { - clearPreservedQuery, - getPreservedQueryParam -} from '@/platform/navigation/preservedQueryManager' -import { installPreservedQueryTracker } from '@/platform/navigation/preservedQueryTracker' -import { beforeEach, describe, expect, it } from 'vitest' +import { describe, expect, it } from 'vitest' import { PRESERVED_QUERY_DEFINITIONS } from '@/platform/navigation/preservedQueryDefinitions' import { PRESERVED_QUERY_NAMESPACES } from '@/platform/navigation/preservedQueryNamespaces' @@ -36,27 +30,6 @@ describe('PRESERVED_QUERY_DEFINITIONS', () => { expect(registered.get(namespace)).toContain(key) }) - beforeEach(() => clearPreservedQuery(PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID)) - - it('preserves a workflow-id link through sign-in and onboarding redirects', async () => { - const router = createRouter({ - history: createMemoryHistory(), - routes: [{ path: '/:pathMatch(.*)*', component: {} }] - }) - installPreservedQueryTracker(router, PRESERVED_QUERY_DEFINITIONS) - - await router.push('/?workflowId=82b98188-0c8f-41d2-9b91-617b9152b809') - await router.push('/login') - await router.push('/onboarding') - - expect( - getPreservedQueryParam( - PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID, - 'workflowId' - ) - ).toBe('82b98188-0c8f-41d2-9b91-617b9152b809') - }) - it('registers each namespace once', () => { expect(registered.size).toBe(PRESERVED_QUERY_DEFINITIONS.length) }) diff --git a/src/platform/navigation/preservedQueryTracker.test.ts b/src/platform/navigation/preservedQueryTracker.test.ts index c0af29dcff6..33834ee64f2 100644 --- a/src/platform/navigation/preservedQueryTracker.test.ts +++ b/src/platform/navigation/preservedQueryTracker.test.ts @@ -6,6 +6,8 @@ import { clearPreservedQuery, getPreservedQueryParam } from '@/platform/navigation/preservedQueryManager' +import { PRESERVED_QUERY_DEFINITIONS } from '@/platform/navigation/preservedQueryDefinitions' +import { PRESERVED_QUERY_NAMESPACES } from '@/platform/navigation/preservedQueryNamespaces' import { installPreservedQueryTracker } from '@/platform/navigation/preservedQueryTracker' const STRIPPED_NAMESPACE = 'test_strip' @@ -296,3 +298,23 @@ describe('installPreservedQueryTracker', () => { ).toBeUndefined() }) }) + +describe('installPreservedQueryTracker with the app definitions', () => { + beforeEach(() => clearPreservedQuery(PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID)) + + it('preserves a workflow-id link through sign-in and onboarding redirects', async () => { + const router = createTestRouter() + installPreservedQueryTracker(router, PRESERVED_QUERY_DEFINITIONS) + + await router.push('/?workflowId=82b98188-0c8f-41d2-9b91-617b9152b809') + await router.push('/login') + await router.push('/onboarding') + + expect( + getPreservedQueryParam( + PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID, + 'workflowId' + ) + ).toBe('82b98188-0c8f-41d2-9b91-617b9152b809') + }) +}) diff --git a/src/platform/telemetry/TelemetryRegistry.test.ts b/src/platform/telemetry/TelemetryRegistry.test.ts index 5628c3e5d7f..d4d290eb655 100644 --- a/src/platform/telemetry/TelemetryRegistry.test.ts +++ b/src/platform/telemetry/TelemetryRegistry.test.ts @@ -276,6 +276,23 @@ describe('TelemetryRegistry', () => { expect(b.trackCheckoutJourneyEvent).toHaveBeenCalledExactlyOnceWith(event) }) + it('dispatches trackWorkflowLinkOpened to every supporting provider', () => { + const a: TelemetryProvider = { trackWorkflowLinkOpened: vi.fn() } + const b: TelemetryProvider = {} + const registry = new TelemetryRegistry() + registry.registerProvider(a) + registry.registerProvider(b) + + const metadata = { + outcome: 'out_of_sync' as const, + reason: 'content_mismatch' as const, + workspace_id: 'ws-1' + } + registry.trackWorkflowLinkOpened(metadata) + + expect(a.trackWorkflowLinkOpened).toHaveBeenCalledExactlyOnceWith(metadata) + }) + it('dispatches trackWidgetFavoriteToggled to every registered provider', () => { const a: TelemetryProvider = { trackWidgetFavoriteToggled: vi.fn() } const b: TelemetryProvider = { trackWidgetFavoriteToggled: vi.fn() } diff --git a/src/platform/workflow/persistence/composables/useWorkflowPersistenceV2.test.ts b/src/platform/workflow/persistence/composables/useWorkflowPersistenceV2.test.ts index 22e61b3c0ae..148f755a6d7 100644 --- a/src/platform/workflow/persistence/composables/useWorkflowPersistenceV2.test.ts +++ b/src/platform/workflow/persistence/composables/useWorkflowPersistenceV2.test.ts @@ -25,7 +25,7 @@ import { StorageKeys } from '@/platform/workflow/persistence/base/storageKeys' import * as storageIO from '@/platform/workflow/persistence/base/storageIO' import { useWorkflowDraftStoreV2 } from '@/platform/workflow/persistence/stores/workflowDraftStoreV2' import { useWorkflowPersistenceV2 } from './useWorkflowPersistenceV2' -import type { useWorkflowLinkUrlLoader } from '@/platform/workflow/management/composables/useWorkflowLinkUrlLoader' +import type { useWorkflowLinkUrlLoader } from '@/composables/useWorkflowLinkUrlLoader' const apiEvents: EventTarget = api @@ -75,10 +75,9 @@ const workflowLinkUrlLoader = vi.hoisted(() => ({ >(() => false) })) -vi.mock( - import('@/platform/workflow/management/composables/useWorkflowLinkUrlLoader'), - () => ({ useWorkflowLinkUrlLoader: () => workflowLinkUrlLoader }) -) +vi.mock(import('@/composables/useWorkflowLinkUrlLoader'), () => ({ + useWorkflowLinkUrlLoader: () => workflowLinkUrlLoader +})) const folderWorkflowsUrlLoader = vi.hoisted(() => ({ openFolderWorkflowsFromUrl: vi.fn(async () => false) diff --git a/src/platform/workflow/persistence/composables/useWorkflowPersistenceV2.ts b/src/platform/workflow/persistence/composables/useWorkflowPersistenceV2.ts index 2f0396bbd92..9f4ee6cc76a 100644 --- a/src/platform/workflow/persistence/composables/useWorkflowPersistenceV2.ts +++ b/src/platform/workflow/persistence/composables/useWorkflowPersistenceV2.ts @@ -24,7 +24,7 @@ import { PRESERVED_QUERY_NAMESPACES } from '@/platform/navigation/preservedQuery import { isCloud } from '@/platform/distribution/types' import { LOCAL_HANDOFF_PARAM } from '@/platform/openOnCloud/localHandoffProtocol' import { useSettingStore } from '@/platform/settings/settingStore' -import { useLinkedWorkflowUrlLoader } from '@/platform/workflow/management/composables/useLinkedWorkflowUrlLoader' +import { useLinkedWorkflowUrlLoader } from '@/composables/useLinkedWorkflowUrlLoader' import { useTeamWorkspaceStore } from '@/platform/workspace/stores/teamWorkspaceStore' import { useWorkflowService } from '@/platform/workflow/core/services/workflowService' import { From 76d5c6909d070c681eb05cdd96aa447abecacf8a Mon Sep 17 00:00:00 2001 From: Vinh Trinh Date: Tue, 10 Nov 2026 14:01:39 -0800 Subject: [PATCH 3/5] fix: keep a newer workflow link when cleanup runs for an opened one A navigation guard can hold a newer ?workflowId while the URL still shows the link that just opened. The URL-action pass then cleaned up for the opened link: its router.replace cancelled the held navigation and the cleanup cleared the newer link's stash, so the newer link was lost. Ownership of the URL and the stash now belongs to the link being handled. When the URL and the stash name different links, the loader treats the stash as a navigation still in flight and leaves both alone, even for a link it already opened. The loader tests now run on a real memory router with the preserved-query tracker, and hold navigations in real guards instead of faking cancellation through a replace mock. On cloud/1.59 reportError has no shared mock, so the test file mocks it; without that, the six tests that assert a report failed. --- ...workflow-links-through-the-sidebar-file.md | 9 +- .../useWorkflowLinkUrlLoader.test.ts | 366 +++++++++--------- src/composables/useWorkflowLinkUrlLoader.ts | 32 +- 3 files changed, 221 insertions(+), 186 deletions(-) diff --git a/docs/adr/WORKFLOW-LINKS-0053-open-workflow-links-through-the-sidebar-file.md b/docs/adr/WORKFLOW-LINKS-0053-open-workflow-links-through-the-sidebar-file.md index 0bcba1719d3..a486c42d2d8 100644 --- a/docs/adr/WORKFLOW-LINKS-0053-open-workflow-links-through-the-sidebar-file.md +++ b/docs/adr/WORKFLOW-LINKS-0053-open-workflow-links-through-the-sidebar-file.md @@ -39,9 +39,12 @@ navigation cancels that cleanup; the final URL-action sweep clears the link it left. Only a reload in flight stops the URL actions. A link that is not settled does not stop them: the other loaders run, and the final sweep removes their params but leaves `workflowId` and its stash. A navigation guard can hold a -newer link in the stash while the URL still shows the old one. While the stash -holds a link the loader never started and the URL does not show, the sweep -makes no replace, so that link's navigation is not cancelled. +newer link in the stash while the URL still shows the old one. While the URL +and the stash name different links, the loader treats the stash as a navigation +still in flight: it makes no replace and clears neither carrier, even for a +link it already opened. While the stash holds a link the loader never started +and the URL does not show, the sweep makes no replace either, so that link's +navigation is not cancelled. The reply and the 409 body are validated with the generated `@comfyorg/ingest-types` schemas. The spec types the 409 as `ErrorResponse` and diff --git a/src/composables/useWorkflowLinkUrlLoader.test.ts b/src/composables/useWorkflowLinkUrlLoader.test.ts index a7e7a21c426..5141885f912 100644 --- a/src/composables/useWorkflowLinkUrlLoader.test.ts +++ b/src/composables/useWorkflowLinkUrlLoader.test.ts @@ -7,10 +7,14 @@ import { onTestFinished, vi } from 'vitest' -import { effectScope } from 'vue' -import type { EffectScope } from 'vue' -import { useRoute, useRouter } from 'vue-router' -import type { NavigationFailure, RouteLocationNormalized } from 'vue-router' +import { createApp, effectScope } from 'vue' +import type { App, EffectScope } from 'vue' +import { createMemoryHistory, createRouter } from 'vue-router' +import type { + LocationQueryRaw, + RouteLocationNormalized, + Router +} from 'vue-router' import { useToast } from '@/components/ui/toast/toastStore' import { useLinkedWorkflowUrlLoader } from '@/composables/useLinkedWorkflowUrlLoader' @@ -20,7 +24,9 @@ import { clearPreservedQuery, getPreservedQueryParam } from '@/platform/navigation/preservedQueryManager' +import { PRESERVED_QUERY_DEFINITIONS } from '@/platform/navigation/preservedQueryDefinitions' import { PRESERVED_QUERY_NAMESPACES } from '@/platform/navigation/preservedQueryNamespaces' +import { installPreservedQueryTracker } from '@/platform/navigation/preservedQueryTracker' import { useTelemetry } from '@/platform/telemetry' import { reportError } from '@/platform/telemetry/reportError' import { useWorkflowService } from '@/platform/workflow/core/services/workflowService' @@ -32,9 +38,9 @@ import '@/scripts/changeTracker' import { useWorkflowLinkUrlLoader } from './useWorkflowLinkUrlLoader' -vi.mock(import('vue-router')) vi.mock(import('@/scripts/app')) vi.mock(import('@/platform/telemetry')) +vi.mock(import('@/platform/telemetry/reportError')) vi.mock(import('@/platform/workflow/core/services/workflowService')) vi.mock(import('@/platform/workspace/composables/useDeploymentUrlLoader')) vi.mock(import('@/platform/workspace/composables/useWorkspaceUrlLoader')) @@ -88,40 +94,6 @@ function holdLookup() { return () => respond() } -function navigateToLink(workflowId: string) { - const query = useRoute().query - Object.keys(query).forEach((key) => { - delete query[key] - }) - query.workflowId = workflowId - capturePreservedQuery(NAMESPACE, { workflowId }, ['workflowId']) -} - -function stashLink(workflowId: string) { - capturePreservedQuery(NAMESPACE, { workflowId }, ['workflowId']) -} - -const HOME: RouteLocationNormalized = { - path: '/', - fullPath: '/', - name: undefined, - params: {}, - query: {}, - hash: '', - matched: [], - meta: {}, - redirectedFrom: undefined -} - -function cancelledNavigation(): NavigationFailure { - const cancelled: NavigationFailure['type'] = 8 - return Object.assign(new Error('Navigation cancelled'), { - type: cancelled, - from: HOME, - to: HOME - }) -} - function refuse(status: number, body: object) { vi.spyOn(api, 'fetchApi').mockResolvedValue(Response.json(body, { status })) } @@ -133,38 +105,84 @@ async function openExistingTab() { return { store, existing, active: store.activeWorkflow } } +function isUrlCleanup(to: RouteLocationNormalized): boolean { + return !('workflowId' in to.query) +} + +function isNewerLink(to: RouteLocationNormalized): boolean { + return to.query.workflowId === NEXT_ID +} + describe('workflow-id links', () => { - let loader: ReturnType + let router: Router + let app: App let scope: EffectScope - beforeEach(() => { - scope = effectScope() - onTestFinished(() => scope.stop()) - const scopedLoader = scope.run(useWorkflowLinkUrlLoader) - assert.exists(scopedLoader) - loader = scopedLoader + let loader: ReturnType + + function inApp(composable: () => T): T { + const result = app.runWithContext(() => scope.run(composable)) + assert.exists(result) + return result + } + + function currentQuery() { + return router.currentRoute.value.query + } + + async function navigate(query: LocationQueryRaw) { + await router.push({ path: '/', query }) + } + + function holdNavigation(matches: (to: RouteLocationNormalized) => boolean) { + let arrive: () => void = () => {} + let release: () => void = () => {} + const arrived = new Promise((resolve) => { + arrive = resolve + }) + const released = new Promise((resolve) => { + release = resolve + }) + const removeGuard = router.beforeEach(async (to) => { + if (!matches(to)) return + arrive() + await released + }) + return { + arrived, + release: () => { + removeGuard() + release() + } + } + } + + function runUrlActions() { + return inApp(useUrlActionLoaders).runUrlActionLoaders() + } + + beforeEach(async () => { distribution.isCloud = true clearPreservedQuery(NAMESPACE) clearPreservedQuery(PRESERVED_QUERY_NAMESPACES.WORKFLOWS) clearPreservedQuery(PRESERVED_QUERY_NAMESPACES.DEPLOYMENT) clearPreservedQuery(PRESERVED_QUERY_NAMESPACES.WORKSPACE) Object.assign(useTeamWorkspaceStore(), { activeWorkspaceId: 'workspace-1' }) - vi.mocked(useRouter().replace).mockImplementation(async (to) => { - const query = useRoute().query - Object.keys(query).forEach((key) => { - delete query[key] - }) - if (typeof to === 'object' && 'query' in to) - Object.assign(query, to.query) + router = createRouter({ + history: createMemoryHistory(), + routes: [{ path: '/:pathMatch(.*)*', component: { render: () => null } }] }) + installPreservedQueryTracker(router, PRESERVED_QUERY_DEFINITIONS) + app = createApp({}) + app.use(router) + await router.push('/') + scope = effectScope() + onTestFinished(() => scope.stop()) + loader = inApp(useWorkflowLinkUrlLoader) }) it('opens the sidebar file the workflow id names, in front of restored tabs', async () => { serveFile() - Object.assign(useRoute().query, { - workflowId: ID, - workflows: 'other', - keep: 'yes' - }) + await navigate({ workflowId: ID, workflows: 'other', keep: 'yes' }) const { store, existing } = await openExistingTab() vi.mocked(useWorkflowService().openWorkflow).mockImplementation( async (workflow) => { @@ -184,7 +202,7 @@ describe('workflow-id links', () => { existing.path, PATH ]) - expect(useRoute().query).toEqual({ keep: 'yes' }) + expect(currentQuery()).toEqual({ keep: 'yes' }) expect( useTelemetry()?.trackWorkflowLinkOpened ).toHaveBeenCalledExactlyOnceWith({ @@ -223,7 +241,7 @@ describe('workflow-id links', () => { ]) const store = useWorkflowStore() await store.loadWorkflows() - Object.assign(useRoute().query, { workflowId: ID }) + await navigate({ workflowId: ID }) vi.mocked(useWorkflowService().openWorkflow).mockImplementation( async (workflow) => { await store.openWorkflow(workflow) @@ -238,31 +256,30 @@ describe('workflow-id links', () => { it('reports one result across boot consumers when URL cleanup fails', async () => { serveFile() - Object.assign(useRoute().query, { workflowId: ID }) - vi.mocked(useRouter().replace).mockRejectedValueOnce(new Error('cancelled')) + await navigate({ workflowId: ID }) vi.mocked(useWorkflowService().openWorkflow).mockResolvedValue(true) - const scope = effectScope() - try { - const consumers = scope.run(() => [ - useWorkflowLinkUrlLoader(), - useWorkflowLinkUrlLoader() - ]) - assert.exists(consumers) + const failCleanupOnce = vi + .fn(() => true) + .mockImplementationOnce(() => { + throw new Error('cancelled') + }) + router.beforeEach(failCleanupOnce) + const consumers = [ + inApp(useWorkflowLinkUrlLoader), + inApp(useWorkflowLinkUrlLoader) + ] - expect(await consumers[0].openWorkflowLinkFromUrl()).toBe('opened') - await consumers[1].openWorkflowLinkFromUrl(true) + expect(await consumers[0].openWorkflowLinkFromUrl()).toBe('opened') + await consumers[1].openWorkflowLinkFromUrl(true) - expect(api.fetchApi).toHaveBeenCalledTimes(1) - expect(useTelemetry()?.trackWorkflowLinkOpened).toHaveBeenCalledTimes(1) - expect(useRoute().query).toEqual({}) - } finally { - scope.stop() - } + expect(api.fetchApi).toHaveBeenCalledTimes(1) + expect(useTelemetry()?.trackWorkflowLinkOpened).toHaveBeenCalledTimes(1) + expect(currentQuery()).toEqual({}) }) it('opens nothing and leaves restored tabs on 404', async () => { refuse(404, { code: 'NOT_FOUND', message: 'not found' }) - Object.assign(useRoute().query, { workflowId: ID }) + await navigate({ workflowId: ID }) const { store, existing, active } = await openExistingTab() expect(await loader.openWorkflowLinkFromUrl()).toBe('failed') @@ -273,7 +290,7 @@ describe('workflow-id links', () => { "Couldn't open this workflow" ]) expect(useWorkflowService().openWorkflow).not.toHaveBeenCalled() - expect(useRoute().query).toEqual({}) + expect(currentQuery()).toEqual({}) expect( useTelemetry()?.trackWorkflowLinkOpened ).toHaveBeenCalledExactlyOnceWith({ @@ -326,7 +343,7 @@ describe('workflow-id links', () => { message: 'workflows/Car swap.json is out of sync', ...body }) - Object.assign(useRoute().query, { workflowId: ID, workflows: 'Car swap' }) + await navigate({ workflowId: ID, workflows: 'Car swap' }) const { store, existing, active } = await openExistingTab() const contentRead = vi.spyOn(api, 'getUserData') @@ -340,7 +357,7 @@ describe('workflow-id links', () => { expect(useToast().toasts.map(({ title }) => title)).toEqual([ "Couldn't open this workflow" ]) - expect(useRoute().query).toEqual({}) + expect(currentQuery()).toEqual({}) expect( useTelemetry()?.trackWorkflowLinkOpened ).toHaveBeenCalledExactlyOnceWith({ @@ -364,7 +381,7 @@ describe('workflow-id links', () => { 'treats a 409 with $name as out of sync for an unknown reason', async ({ response }) => { vi.spyOn(api, 'fetchApi').mockResolvedValue(response()) - Object.assign(useRoute().query, { workflowId: ID }) + await navigate({ workflowId: ID }) expect(await loader.openWorkflowLinkFromUrl()).toBe('failed') @@ -383,13 +400,13 @@ describe('workflow-id links', () => { 'rejects malformed workflowId %j without a request', async (workflowId) => { const request = vi.spyOn(api, 'fetchApi') - Object.assign(useRoute().query, { workflowId }) + await navigate({ workflowId }) expect(await loader.openWorkflowLinkFromUrl()).toBe('failed') expect(request).not.toHaveBeenCalled() expect(useToast().toasts[0]?.title).toBe("Couldn't open this workflow") - expect(useRoute().query).toEqual({}) + expect(currentQuery()).toEqual({}) } ) @@ -397,10 +414,8 @@ describe('workflow-id links', () => { 'keeps a stashed link until the %s navigation finishes', async (namespace) => { const request = vi.spyOn(api, 'fetchApi') - capturePreservedQuery(NAMESPACE, { workflowId: ID }, ['workflowId']) - capturePreservedQuery(namespace, { [namespace]: 'destination' }, [ - namespace - ]) + await navigate({ workflowId: ID, [namespace]: 'destination' }) + await navigate({}) expect(await loader.openWorkflowLinkFromUrl()).toBe('pending') @@ -419,12 +434,12 @@ describe('workflow-id links', () => { it('does nothing outside Cloud', async () => { distribution.isCloud = false const request = vi.spyOn(api, 'fetchApi') - Object.assign(useRoute().query, { workflowId: ID }) + await navigate({ workflowId: ID }) expect(await loader.openWorkflowLinkFromUrl()).toBe('absent') expect(request).not.toHaveBeenCalled() - expect(useRoute().query).toEqual({ workflowId: ID }) + expect(currentQuery()).toEqual({ workflowId: ID }) expect(useTelemetry()?.trackWorkflowLinkOpened).not.toHaveBeenCalled() }) @@ -460,7 +475,7 @@ describe('workflow-id links', () => { 'reports $name as an opening error rather than a missing workflow', async ({ response }) => { vi.spyOn(api, 'fetchApi').mockResolvedValue(response()) - Object.assign(useRoute().query, { workflowId: ID }) + await navigate({ workflowId: ID }) expect(await loader.openWorkflowLinkFromUrl()).toBe('failed') @@ -490,27 +505,27 @@ describe('workflow-id links', () => { }) return new Response(null, { status: 404 }) }) - Object.assign(useRoute().query, { workflowId: ID }) + await navigate({ workflowId: ID }) expect(await loader.openWorkflowLinkFromUrl()).toBe('pending') - expect(useRoute().query.workflowId).toBe(ID) + expect(currentQuery().workflowId).toBe(ID) expect(useToast().toasts).toEqual([]) expect(useTelemetry()?.trackWorkflowLinkOpened).not.toHaveBeenCalled() }) it('leaves a link the browser navigated to while an earlier lookup waited', async () => { const respond = holdLookup() - navigateToLink(ID) + await navigate({ workflowId: ID }) vi.mocked(useWorkflowService().openWorkflow).mockResolvedValue(true) const attempt = loader.openWorkflowLinkFromUrl() - navigateToLink(NEXT_ID) + await navigate({ workflowId: NEXT_ID }) respond() expect(await attempt).toBe('pending') expect(useWorkflowService().openWorkflow).not.toHaveBeenCalled() - expect(useRoute().query).toEqual({ workflowId: NEXT_ID }) + expect(currentQuery()).toEqual({ workflowId: NEXT_ID }) expect(getPreservedQueryParam(NAMESPACE, 'workflowId')).toBe(NEXT_ID) expect(useToast().toasts).toEqual([]) expect(useTelemetry()?.trackWorkflowLinkOpened).not.toHaveBeenCalled() @@ -518,7 +533,7 @@ describe('workflow-id links', () => { it('opens and clears nothing when the editor unmounts while the lookup waits', async () => { const respond = holdLookup() - navigateToLink(ID) + await navigate({ workflowId: ID }) vi.mocked(useWorkflowService().openWorkflow).mockResolvedValue(true) const attempt = loader.openWorkflowLinkFromUrl() @@ -527,7 +542,7 @@ describe('workflow-id links', () => { expect(await attempt).toBe('pending') expect(useWorkflowService().openWorkflow).not.toHaveBeenCalled() - expect(useRoute().query).toEqual({ workflowId: ID }) + expect(currentQuery()).toEqual({ workflowId: ID }) expect(getPreservedQueryParam(NAMESPACE, 'workflowId')).toBe(ID) expect(useToast().toasts).toEqual([]) expect(useTelemetry()?.trackWorkflowLinkOpened).not.toHaveBeenCalled() @@ -535,37 +550,32 @@ describe('workflow-id links', () => { it.for([ { - name: 'finished navigating there', - navigate: async () => navigateToLink(NEXT_ID), + name: 'finished navigating to a newer link', + newer: { workflowId: NEXT_ID }, route: NEXT_ID, stash: NEXT_ID }, { - name: 'holds it in a navigation guard', - navigate: async () => { - stashLink(NEXT_ID) - return cancelledNavigation() - }, - route: ID, - stash: NEXT_ID - }, - { - name: 'cancelled the cleanup first', - navigate: async () => cancelledNavigation(), + name: 'navigated elsewhere with the same link', + newer: { workflowId: ID, keep: 'yes' }, route: ID, stash: ID } ])( - 'leaves a newer link when the browser $name while an opened link cleared the URL', - async ({ navigate, route, stash }) => { + 'leaves the link when the browser $name while an opened link cleared the URL', + async ({ newer, route, stash }) => { serveFile() - navigateToLink(ID) + await navigate({ workflowId: ID }) vi.mocked(useWorkflowService().openWorkflow).mockResolvedValue(true) - vi.mocked(useRouter().replace).mockImplementation(navigate) + const cleanup = holdNavigation(isUrlCleanup) - expect(await loader.openWorkflowLinkFromUrl(true)).toBe('opened') + const attempt = loader.openWorkflowLinkFromUrl(true) + await cleanup.arrived + await navigate(newer) + cleanup.release() - expect(useRoute().query.workflowId).toBe(route) + expect(await attempt).toBe('opened') + expect(currentQuery().workflowId).toBe(route) expect(getPreservedQueryParam(NAMESPACE, 'workflowId')).toBe(stash) expect( useTelemetry()?.trackWorkflowLinkOpened @@ -576,28 +586,30 @@ describe('workflow-id links', () => { } ) - it('leaves a newer link the browser navigated to while a settled link cleared the URL again', async () => { + it('leaves a newer link a navigation guard holds while an opened link cleared the URL', async () => { serveFile() - navigateToLink(ID) + await navigate({ workflowId: ID }) vi.mocked(useWorkflowService().openWorkflow).mockResolvedValue(true) - vi.mocked(useRouter().replace).mockRejectedValueOnce(new Error('cancelled')) - expect(await loader.openWorkflowLinkFromUrl()).toBe('opened') - vi.mocked(useRouter().replace).mockImplementation(async () => { - stashLink(NEXT_ID) - return cancelledNavigation() - }) + const cleanup = holdNavigation(isUrlCleanup) + const signIn = holdNavigation(isNewerLink) - expect(await loader.openWorkflowLinkFromUrl(true)).toBe('opened') + const attempt = loader.openWorkflowLinkFromUrl(true) + await cleanup.arrived + const newerLink = navigate({ workflowId: NEXT_ID }) + await signIn.arrived + cleanup.release() - expect(api.fetchApi).toHaveBeenCalledTimes(1) - expect(useRoute().query.workflowId).toBe(ID) + expect(await attempt).toBe('opened') + expect(currentQuery()).toEqual({ workflowId: ID }) expect(getPreservedQueryParam(NAMESPACE, 'workflowId')).toBe(NEXT_ID) - expect(useTelemetry()?.trackWorkflowLinkOpened).toHaveBeenCalledTimes(1) + signIn.release() + await newerLink + expect(currentQuery()).toEqual({ workflowId: NEXT_ID }) }) - it('keeps a boot link opened when an unrelated navigation cancels its URL cleanup, and clears it later without reopening', async () => { + it('keeps a boot link opened when another navigation cancels its URL cleanup, and clears it later without reopening', async () => { serveFile() - navigateToLink(ID) + await navigate({ workflowId: ID }) const { store } = await openExistingTab() vi.mocked(useWorkflowService().openWorkflow).mockImplementation( async (workflow) => { @@ -605,54 +617,54 @@ describe('workflow-id links', () => { return true } ) - vi.mocked(useRouter().replace).mockResolvedValueOnce(cancelledNavigation()) - const linkedLoader = scope.run(useLinkedWorkflowUrlLoader) - assert.exists(linkedLoader) + const cleanup = holdNavigation(isUrlCleanup) + const linkedLoader = inApp(useLinkedWorkflowUrlLoader) + + const boot = linkedLoader.openLinkedWorkflowFromUrl() + await cleanup.arrived + await navigate({ workflowId: ID, keep: 'yes' }) + cleanup.release() - expect(await linkedLoader.openLinkedWorkflowFromUrl()).toBe('opened') + expect(await boot).toBe('opened') expect(store.activeWorkflow?.path).toBe(PATH) - expect(useRoute().query).toEqual({ workflowId: ID }) + expect(currentQuery()).toEqual({ workflowId: ID, keep: 'yes' }) expect(await loader.openWorkflowLinkFromUrl(true)).toBe('opened') expect(useWorkflowService().openWorkflow).toHaveBeenCalledOnce() expect(store.activeWorkflow?.path).toBe(PATH) - expect(useRoute().query).toEqual({}) + expect(currentQuery()).toEqual({ keep: 'yes' }) expect(getPreservedQueryParam(NAMESPACE, 'workflowId')).toBeUndefined() expect(useTelemetry()?.trackWorkflowLinkOpened).toHaveBeenCalledTimes(1) }) - function runUrlActions() { - Object.assign(useRouter(), { currentRoute: { value: useRoute() } }) - const urlActions = scope.run(useUrlActionLoaders) - assert.exists(urlActions) - return urlActions.runUrlActionLoaders() - } - - function holdNewerLinkInGuard() { - vi.mocked(useRouter().replace).mockImplementation(async () => { - stashLink(NEXT_ID) - return cancelledNavigation() - }) - } - it('runs the URL actions without another replace while a newer link waits in a navigation guard', async () => { serveFile() - navigateToLink(ID) + await navigate({ workflowId: ID }) vi.mocked(useWorkflowService().openWorkflow).mockResolvedValue(true) - holdNewerLinkInGuard() + const replace = vi.spyOn(router, 'replace') + const cleanup = holdNavigation(isUrlCleanup) + const signIn = holdNavigation(isNewerLink) - await runUrlActions() + const actions = runUrlActions() + await cleanup.arrived + const newerLink = navigate({ workflowId: NEXT_ID }) + await signIn.arrived + cleanup.release() + await actions expect(useWorkflowService().openWorkflow).toHaveBeenCalledOnce() - expect(useRouter().replace).toHaveBeenCalledOnce() - expect(useRoute().query).toEqual({ workflowId: ID }) + expect(replace).toHaveBeenCalledOnce() + expect(currentQuery()).toEqual({ workflowId: ID }) expect(getPreservedQueryParam(NAMESPACE, 'workflowId')).toBe(NEXT_ID) + signIn.release() + await newerLink + expect(currentQuery()).toEqual({ workflowId: NEXT_ID }) }) - it('keeps a boot link opened and makes no other replace while a newer link waits in a navigation guard', async () => { + it('lets a newer link held in a navigation guard land when the URL actions run after the boot link opened', async () => { serveFile() - navigateToLink(ID) + await navigate({ workflowId: ID }) const { store } = await openExistingTab() vi.mocked(useWorkflowService().openWorkflow).mockImplementation( async (workflow) => { @@ -660,19 +672,26 @@ describe('workflow-id links', () => { return true } ) - vi.mocked(useRouter().replace).mockResolvedValueOnce(cancelledNavigation()) - const linkedLoader = scope.run(useLinkedWorkflowUrlLoader) - assert.exists(linkedLoader) - expect(await linkedLoader.openLinkedWorkflowFromUrl()).toBe('opened') - holdNewerLinkInGuard() - + const replace = vi.spyOn(router, 'replace') + const cleanup = holdNavigation(isUrlCleanup) + const signIn = holdNavigation(isNewerLink) + const linkedLoader = inApp(useLinkedWorkflowUrlLoader) + + const boot = linkedLoader.openLinkedWorkflowFromUrl() + await cleanup.arrived + const newerLink = navigate({ workflowId: NEXT_ID }) + await signIn.arrived + cleanup.release() + expect(await boot).toBe('opened') await runUrlActions() + signIn.release() + await newerLink + expect(currentQuery()).toEqual({ workflowId: NEXT_ID }) + expect(getPreservedQueryParam(NAMESPACE, 'workflowId')).toBe(NEXT_ID) + expect(replace).toHaveBeenCalledOnce() expect(useWorkflowService().openWorkflow).toHaveBeenCalledOnce() expect(store.activeWorkflow?.path).toBe(PATH) - expect(useRouter().replace).toHaveBeenCalledTimes(2) - expect(useRoute().query).toEqual({ workflowId: ID }) - expect(getPreservedQueryParam(NAMESPACE, 'workflowId')).toBe(NEXT_ID) }) it('clears the other URL actions while a link from the stash waits for a workspace change', async () => { @@ -682,13 +701,14 @@ describe('workflow-id links', () => { }) return new Response(null, { status: 404 }) }) - stashLink(ID) - Object.assign(useRoute().query, { topup: '1' }) + await navigate({ workflowId: ID }) + await navigate({ topup: '1' }) + const replace = vi.spyOn(router, 'replace') await runUrlActions() - expect(useRouter().replace).toHaveBeenCalledOnce() - expect(useRoute().query).toEqual({}) + expect(replace).toHaveBeenCalledOnce() + expect(currentQuery()).toEqual({}) expect(getPreservedQueryParam(NAMESPACE, 'workflowId')).toBe(ID) expect(useTelemetry()?.trackWorkflowLinkOpened).not.toHaveBeenCalled() }) @@ -696,7 +716,7 @@ describe('workflow-id links', () => { it('reports an opening error when the sidebar file is not in the workflow list after a sync', async () => { serveFile() vi.mocked(api.listUserDataFullInfo).mockResolvedValue([]) - Object.assign(useRoute().query, { workflowId: ID }) + await navigate({ workflowId: ID }) expect(await loader.openWorkflowLinkFromUrl()).toBe('failed') @@ -712,7 +732,7 @@ describe('workflow-id links', () => { it('keeps tabs unchanged when the sidebar file cannot be opened', async () => { serveFile() - Object.assign(useRoute().query, { workflowId: ID }) + await navigate({ workflowId: ID }) const { store, existing, active } = await openExistingTab() vi.mocked(useWorkflowService().openWorkflow).mockResolvedValue(false) diff --git a/src/composables/useWorkflowLinkUrlLoader.ts b/src/composables/useWorkflowLinkUrlLoader.ts index 1f85b7425eb..b2994b9c6c3 100644 --- a/src/composables/useWorkflowLinkUrlLoader.ts +++ b/src/composables/useWorkflowLinkUrlLoader.ts @@ -54,6 +54,17 @@ type Ownership = { unreplaced: () => boolean } +function isWorkflowId(value: unknown): value is string { + return typeof value === 'string' && workflowIdSchema.safeParse(value).success +} + +function isSameLink(carried: unknown, workflowId: unknown): boolean { + return ( + carried === workflowId || + (!isWorkflowId(carried) && !isWorkflowId(workflowId)) + ) +} + function isWorkflowPath(path: string): boolean { return ( path.startsWith('workflows/') && @@ -221,8 +232,7 @@ function useWorkflowLinkUrlLoaderInternal() { value: unknown, isCurrent: () => boolean ): Promise { - if (typeof value !== 'string' || !workflowIdSchema.safeParse(value).success) - return { kind: 'not_found' } + if (!isWorkflowId(value)) return { kind: 'not_found' } const result = await lookupSidebarFile(value) if (!isCurrent()) return { kind: 'pending' } return result.kind === 'found' ? openPath(result.path, isCurrent) : result @@ -255,11 +265,11 @@ function useWorkflowLinkUrlLoaderInternal() { } } - function keepsCapturedLink(captured: LinkCarriers): boolean { - const current = linkCarriers() + function carriesOnly(workflowId: unknown): boolean { + const { route, stash } = linkCarriers() return ( - (current.route === undefined || current.route === captured.route) && - (current.stash === undefined || current.stash === captured.stash) + (route === undefined || isSameLink(route, workflowId)) && + (stash === undefined || isSameLink(stash, workflowId)) ) } @@ -268,12 +278,14 @@ function useWorkflowLinkUrlLoaderInternal() { return current.route !== undefined || current.stash !== undefined } - function attemptOwnership(workspaceId: string | null): Ownership { - const captured = linkCarriers() + function attemptOwnership( + workflowId: unknown, + workspaceId: string | null + ): Ownership { const unreplaced = () => !disposed && workspaceStore.activeWorkspaceId === workspaceId && - keepsCapturedLink(captured) + carriesOnly(workflowId) return { owns: () => hasLink() && unreplaced(), unreplaced } } @@ -302,7 +314,7 @@ function useWorkflowLinkUrlLoaderInternal() { workspaceId: string | null ): Promise { startedLinks.add(workflowId) - const ownership = attemptOwnership(workspaceId) + const ownership = attemptOwnership(workflowId, workspaceId) const priorStatus = completedStatus(workflowId, workspaceId) if (priorStatus) { await clearOwnedIntent(ownership) From 8277e08f2767753dc31cfb49d427391decb0a8d6 Mon Sep 17 00:00:00 2001 From: Vinh Trinh Date: Tue, 10 Nov 2026 14:08:17 -0800 Subject: [PATCH 4/5] fix: keep file names out of workflow link error reports When the sidebar-file lookup succeeded but reading the linked file failed, the loader reported the read error as the cause of its own error. That error names the file ("Failed to load file 'workflows/.json': 500 ..."), and the error sinks keep a nested cause, so a user's workflow file name reached error reporting. A lookup reply that was not JSON did the same with the parser's message, which quotes the reply. The loader now reports a fixed message with the error's class name as context, and never the caught error itself. --- ...workflow-links-through-the-sidebar-file.md | 4 ++ .../useWorkflowLinkUrlLoader.test.ts | 45 +++++++++++++++++++ src/composables/useWorkflowLinkUrlLoader.ts | 19 +++++--- 3 files changed, 62 insertions(+), 6 deletions(-) diff --git a/docs/adr/WORKFLOW-LINKS-0053-open-workflow-links-through-the-sidebar-file.md b/docs/adr/WORKFLOW-LINKS-0053-open-workflow-links-through-the-sidebar-file.md index a486c42d2d8..b5cbe9c9594 100644 --- a/docs/adr/WORKFLOW-LINKS-0053-open-workflow-links-through-the-sidebar-file.md +++ b/docs/adr/WORKFLOW-LINKS-0053-open-workflow-links-through-the-sidebar-file.md @@ -52,6 +52,10 @@ lists the `details.reason` values only in prose, saying the set may grow. The loader keeps its list of known reasons as a telemetry classification and records any other value as `unknown`. +Error reports for the link carry a fixed message, the error type and the +failing error's class name. They never carry the caught error or its message: +a failed file read names the file, and a parser error quotes the reply. + ## Alternatives considered - Open the record's own content: rejected because Save would write to a file diff --git a/src/composables/useWorkflowLinkUrlLoader.test.ts b/src/composables/useWorkflowLinkUrlLoader.test.ts index 5141885f912..94d1e86743a 100644 --- a/src/composables/useWorkflowLinkUrlLoader.test.ts +++ b/src/composables/useWorkflowLinkUrlLoader.test.ts @@ -498,6 +498,51 @@ describe('workflow-id links', () => { } ) + it.for([ + { + name: 'the linked file cannot be read', + fail: () => { + serveFile('workflows/Customer Jane Doe.json') + vi.mocked(useWorkflowService().openWorkflow).mockRejectedValue( + new Error( + "Failed to load file 'workflows/Customer Jane Doe.json': 500 Internal Server Error" + ) + ) + }, + reported: new Error('Could not open workflow link'), + errorType: 'error_opening_workflow_link', + errorName: 'Error' + }, + { + name: 'the lookup reply is not JSON', + fail: () => { + vi.spyOn(api, 'fetchApi').mockResolvedValue( + new Response('workflows/Customer Jane Doe.json') + ) + }, + reported: new Error('Could not read workflow link'), + errorType: 'error_loading_workflow_link', + errorName: 'SyntaxError' + } + ])( + 'reports that $name without the file name or the error text', + async ({ fail, reported, errorType, errorName }) => { + fail() + await navigate({ workflowId: ID }) + + expect(await loader.openWorkflowLinkFromUrl()).toBe('failed') + + expect(reportError).toHaveBeenCalledExactlyOnceWith(reported, { + surface: 'graph', + errorType, + context: { error_name: errorName } + }) + expect(vi.mocked(reportError).mock.calls[0]?.[0]).not.toHaveProperty( + 'cause' + ) + } + ) + it('keeps the intent if the workspace changes during the lookup', async () => { vi.spyOn(api, 'fetchApi').mockImplementation(async () => { Object.assign(useTeamWorkspaceStore(), { diff --git a/src/composables/useWorkflowLinkUrlLoader.ts b/src/composables/useWorkflowLinkUrlLoader.ts index b2994b9c6c3..3a6c4f6b014 100644 --- a/src/composables/useWorkflowLinkUrlLoader.ts +++ b/src/composables/useWorkflowLinkUrlLoader.ts @@ -65,6 +65,10 @@ function isSameLink(carried: unknown, workflowId: unknown): boolean { ) } +function failureContext(cause: unknown) { + return { error_name: cause instanceof Error ? cause.name : typeof cause } +} + function isWorkflowPath(path: string): boolean { return ( path.startsWith('workflows/') && @@ -116,9 +120,10 @@ async function lookupSidebarFile(workflowId: string): Promise { const response = await api.fetchApi(`/workflows/${workflowId}/sidebar-file`) return await readLookupResponse(response) } catch (cause) { - reportError(new Error('Could not read workflow link', { cause }), { + reportError(new Error('Could not read workflow link'), { surface: 'graph', - errorType: 'error_loading_workflow_link' + errorType: 'error_loading_workflow_link', + context: failureContext(cause) }) return { kind: 'error' } } @@ -176,9 +181,10 @@ function useWorkflowLinkUrlLoaderInternal() { try { return (await router.replace({ query })) === undefined } catch (cause) { - reportError(new Error('Could not clear workflow link', { cause }), { + reportError(new Error('Could not clear workflow link'), { surface: 'graph', - errorType: 'error_clearing_workflow_link' + errorType: 'error_clearing_workflow_link', + context: failureContext(cause) }) return true } @@ -220,9 +226,10 @@ function useWorkflowLinkUrlLoaderInternal() { }) return opened ? { kind: 'opened' } : { kind: 'error' } } catch (cause) { - reportError(new Error('Could not open workflow link', { cause }), { + reportError(new Error('Could not open workflow link'), { surface: 'graph', - errorType: 'error_opening_workflow_link' + errorType: 'error_opening_workflow_link', + context: failureContext(cause) }) return { kind: 'error' } } From dc7cf6bce7fc4c0dfb319b4581b97efc88750572 Mon Sep 17 00:00:00 2001 From: Vinh Trinh Date: Tue, 10 Nov 2026 14:25:12 -0800 Subject: [PATCH 5/5] fix: reject an empty workflow link even when an older one is still saved Opening /?workflowId= while the session still held an earlier workflow id left that id saved: an empty value was not worth capturing, so the capture kept the old one. The loader then read the saved id as a newer navigation in flight and returned pending without reporting the empty link or clearing it, on every reload. For namespaces that mark ambiguous values (rejectRepeated), a key present with an empty value now clears the saved value when the router captures it. The empty link is rejected as invalid, reported, and cleared from the URL and the stash, as before. A newer link a navigation guard holds is still captured after the empty one, so it keeps its protection. --- ...workflow-links-through-the-sidebar-file.md | 4 +++- .../useWorkflowLinkUrlLoader.test.ts | 14 +++++++++++ .../navigation/preservedQueryTracker.test.ts | 23 +++++++++++++++++++ .../navigation/preservedQueryTracker.ts | 15 +++++++++++- 4 files changed, 54 insertions(+), 2 deletions(-) diff --git a/docs/adr/WORKFLOW-LINKS-0053-open-workflow-links-through-the-sidebar-file.md b/docs/adr/WORKFLOW-LINKS-0053-open-workflow-links-through-the-sidebar-file.md index b5cbe9c9594..55da21059b4 100644 --- a/docs/adr/WORKFLOW-LINKS-0053-open-workflow-links-through-the-sidebar-file.md +++ b/docs/adr/WORKFLOW-LINKS-0053-open-workflow-links-through-the-sidebar-file.md @@ -42,7 +42,9 @@ params but leaves `workflowId` and its stash. A navigation guard can hold a newer link in the stash while the URL still shows the old one. While the URL and the stash name different links, the loader treats the stash as a navigation still in flight: it makes no replace and clears neither carrier, even for a -link it already opened. While the stash holds a link the loader never started +link it already opened. An empty `?workflowId=` clears the stash when the +router captures it, so an older stashed link cannot keep the empty one from +being rejected as invalid. While the stash holds a link the loader never started and the URL does not show, the sweep makes no replace either, so that link's navigation is not cancelled. diff --git a/src/composables/useWorkflowLinkUrlLoader.test.ts b/src/composables/useWorkflowLinkUrlLoader.test.ts index 94d1e86743a..9c216da9667 100644 --- a/src/composables/useWorkflowLinkUrlLoader.test.ts +++ b/src/composables/useWorkflowLinkUrlLoader.test.ts @@ -410,6 +410,20 @@ describe('workflow-id links', () => { } ) + it('rejects an empty workflowId while an older link is still stashed', async () => { + const request = vi.spyOn(api, 'fetchApi') + capturePreservedQuery(NAMESPACE, { workflowId: ID }, ['workflowId']) + await navigate({ workflowId: '' }) + + expect(await loader.openWorkflowLinkFromUrl()).toBe('failed') + + expect(request).not.toHaveBeenCalled() + expect(useToast().toasts[0]?.title).toBe("Couldn't open this workflow") + expect(currentQuery()).toEqual({}) + expect(getPreservedQueryParam(NAMESPACE, 'workflowId')).toBeUndefined() + expect(loader.hasLinkInFlight()).toBe(false) + }) + it.for(['workspace', 'deployment'])( 'keeps a stashed link until the %s navigation finishes', async (namespace) => { diff --git a/src/platform/navigation/preservedQueryTracker.test.ts b/src/platform/navigation/preservedQueryTracker.test.ts index 33834ee64f2..3e1a3edabda 100644 --- a/src/platform/navigation/preservedQueryTracker.test.ts +++ b/src/platform/navigation/preservedQueryTracker.test.ts @@ -285,6 +285,29 @@ describe('installPreservedQueryTracker', () => { ) }) + it('clears a stale rejectRepeated value when the URL supplies an empty value', async () => { + const router = createTestRouter() + installPreservedQueryTracker(router, [rejectRepeatedDefinition]) + + await router.push('/?workspace=ws-team') + await router.push('/?workspace=') + + expect(router.currentRoute.value.fullPath).toBe('/?workspace=') + expect( + getPreservedQueryParam(REJECT_REPEATED_NAMESPACE, 'workspace') + ).toBeUndefined() + }) + + it('keeps a plain namespace stash when the URL supplies an empty value', async () => { + const router = createTestRouter() + installPreservedQueryTracker(router, [plainDefinition]) + + await router.push('/?plain_code=abc') + await router.push('/?plain_code=') + + expect(getPreservedQueryParam(PLAIN_NAMESPACE, 'plain_code')).toBe('abc') + }) + it('drops a bare param of a non-rejectRepeated namespace like any empty value', async () => { const router = createTestRouter() installPreservedQueryTracker(router, [ diff --git a/src/platform/navigation/preservedQueryTracker.ts b/src/platform/navigation/preservedQueryTracker.ts index 193781cb031..378ec9c2923 100644 --- a/src/platform/navigation/preservedQueryTracker.ts +++ b/src/platform/navigation/preservedQueryTracker.ts @@ -28,7 +28,9 @@ export interface PreservedQueryDefinition { * becomes a bare `,`. Both are strings outside any real id's charset, so * they read back as invalid rather than resolving to one of several * colliding values or to "absent" (`capturePreservedQuery` itself drops a - * null/empty value as not worth capturing). + * null/empty value as not worth capturing). A key present with an empty + * value (`?key=`) clears the namespace's stash instead, so an older stashed + * value never stands in for the newer, empty one the URL carries. */ rejectRepeated?: true } @@ -53,6 +55,10 @@ function withAmbiguityMarked( return result } +function hasValue(value: LocationQuery[string] | undefined): boolean { + return (Array.isArray(value) ? value : [value]).some(Boolean) +} + export const installPreservedQueryTracker = ( router: Router, definitions: PreservedQueryDefinition[] @@ -73,6 +79,13 @@ export const installPreservedQueryTracker = ( const captureQuery = rejectRepeated ? withAmbiguityMarked(to.query, keys) : to.query + if ( + rejectRepeated && + !presentKeys.some((key) => hasValue(captureQuery[key])) + ) { + clearPreservedQuery(namespace) + return + } capturePreservedQuery(namespace, captureQuery, keys, { merge: stripAfterCapture })