nango 0.72.2 → 0.72.3

package/dist/zeroYaml/deploy.unit.cli-test.js

@@ -115,6 +115,13 @@ const noFunctionChanges = {
     unchanged: [{ integrationId: 'github', name: 'fetch' }],
     deleted: []
 };
+const emptyFunctionChanges = { created: [], updated: [], unchanged: [], deleted: [] };
+const apiRoutes = {
+    legacyPreview: '/sync/deploy/confirmation',
+    legacyDeploy: '/sync/deploy',
+    functionsPreview: '/functions/deployments/bundle/preview',
+    functionsDeploy: '/functions/deployments/bundle'
+};
 describe('deploy', () => {
     let fullPath;
     let fetchMock;
@@ -155,6 +162,10 @@ describe('deploy', () => {
             '/sync/deploy',
             '/functions/deployments/bundle'
         ]);
+        expect(requestBody(fetchMock, 'legacyPreview')).toMatchObject({ reconciliationScope: { kind: 'environment' } });
+        expect(requestBody(fetchMock, 'legacyDeploy')).toMatchObject({ reconciliationScope: { kind: 'environment' } });
+        expect(requestBody(fetchMock, 'legacyPreview')).not.toHaveProperty('deployMode');
+        expect(requestBody(fetchMock, 'legacyDeploy')).not.toHaveProperty('deployMode');
         const output = logOutput(logSpy);
         expect(output.match(/Nango will perform this plan:/g)).toHaveLength(1);
         expect(output.match(/Summary/g)).toHaveLength(1);
@@ -170,11 +181,12 @@ describe('deploy', () => {
         expect(promptly.confirm).not.toHaveBeenCalled();
     });
     it('scopes both families to the selected integration and only overrides sync/action versions', async () => {
-        fetchMock
-            .mockResolvedValueOnce(jsonResponse(legacyChangeConfirmation))
-            .mockResolvedValueOnce(jsonResponse(noFunctionChanges))
-            .mockResolvedValueOnce(jsonResponse(legacyDeploymentResult))
-            .mockResolvedValueOnce(jsonResponse(noFunctionChanges));
+        mockApi(fetchMock, {
+            legacyPreview: legacyChangeConfirmation,
+            legacyDeploy: legacyDeploymentResult,
+            functionsPreview: noFunctionChanges,
+            functionsDeploy: noFunctionChanges
+        });
         const result = await deploy({
             fullPath,
             environmentName: 'test',
@@ -182,26 +194,27 @@ describe('deploy', () => {
             options: deployOptions({ integration: 'github', version: '42' })
         });
         expect(result.isOk()).toBe(true);
-        const bodies = fetchMock.mock.calls.map(([, request]) => JSON.parse(request.body));
-        expect(bodies[0]).toMatchObject({ deployMode: 'integration', flowConfigs: [{ providerConfigKey: 'github', version: '42' }] });
-        expect(bodies[1]).toMatchObject({
+        const legacyPreviewBody = requestBody(fetchMock, 'legacyPreview');
+        const functionsPreviewBody = requestBody(fetchMock, 'functionsPreview');
+        expect(legacyPreviewBody).toMatchObject({
+            reconciliationScope: { kind: 'integration', integrationId: 'github' },
+            flowConfigs: [{ providerConfigKey: 'github', version: '42' }]
+        });
+        expect(functionsPreviewBody).toMatchObject({
             reconciliationScope: { kind: 'integration', integrationId: 'github' },
             functions: [{ integrationId: 'github', name: 'fetch' }]
         });
-        expect(bodies[2]).toMatchObject({ flowConfigs: bodies[0]?.['flowConfigs'] });
-        expect(bodies[3]).toEqual(bodies[1]);
+        expect(requestBody(fetchMock, 'legacyDeploy')).toMatchObject({ flowConfigs: legacyPreviewBody?.['flowConfigs'] });
+        expect(requestBody(fetchMock, 'functionsDeploy')).toEqual(functionsPreviewBody);
         expect(logOutput(logSpy).match(/The --version option/g)).toHaveLength(1);
         expect(logOutput(logSpy).indexOf('✓ Packaging')).toBeLessThan(logOutput(logSpy).indexOf('The --version option'));
         expect(logOutput(logSpy)).not.toContain('No changes');
         expect(logOutput(logSpy)).toContain('- github → legacy@v42');
     });
-    it.each([
-        { name: 'unknown integration', options: { integration: 'missing' }, message: 'No local definitions found for integration "missing"' },
-        { name: 'conflicting selectors', options: { sync: 'contacts', action: 'legacy' }, message: 'The --sync and --action options cannot be used together' }
-    ])('rejects $name without contacting the API', async ({ options, message }) => {
-        const result = await deploy({ fullPath, environmentName: 'test', interactive: false, options: deployOptions(options) });
+    it('rejects conflicting selectors without contacting the API', async () => {
+        const result = await deploy({ fullPath, environmentName: 'test', interactive: false, options: deployOptions({ sync: 'contacts', action: 'legacy' }) });
         expect(result.isErr()).toBe(true);
-        expect(logOutput(logSpy)).toContain(message);
+        expect(logOutput(logSpy)).toContain('The --sync and --action options cannot be used together');
         expect(fetchMock).not.toHaveBeenCalled();
     });
     it.each(['legacy', 'functions'])('does not contact the API when %s packaging fails in a mixed project', async (family) => {
@@ -354,6 +367,9 @@ describe('deploy', () => {
         expect(output).toContain('✓ Deployed');
         expect(output).toContain('No destructive changes, proceeding without confirmation');
         expect(output).toContain('--sync and --action are deprecated');
+        expect(requestPaths(fetchMock)).toEqual(['/sync/deploy/confirmation', '/sync/deploy']);
+        expect(requestBody(fetchMock, 'legacyPreview')).toMatchObject({ reconciliationScope: { kind: 'function', integrationId: 'github', name: 'legacy' } });
+        expect(requestBody(fetchMock, 'legacyPreview')).not.toHaveProperty('deployMode');
     });
     describe('with a file', () => {
         const functionChanges = {
@@ -399,6 +415,19 @@ describe('deploy', () => {
             expect(previewBody.reconciliationScope).toEqual({ kind: 'function', integrationId: 'github', name: 'get_issue' });
             expect(previewBody.functions).toEqual([expect.objectContaining({ name: 'get_issue', fileBody: { js: 'compiled tool', ts: 'source tool' } })]);
         });
+        it.each([
+            { env: undefined, source: 'repo' },
+            { env: 'standalone', source: 'standalone' }
+        ])('sends source $source on every function when NANGO_DEPLOY_SOURCE is $env', async ({ env, source }) => {
+            vi.stubEnv('NANGO_DEPLOY_SOURCE', env);
+            fetchMock.mockResolvedValueOnce(jsonResponse(functionChanges)).mockResolvedValueOnce(jsonResponse(functionChanges));
+            await deploy({ fullPath, environmentName: 'test', interactive: false, options: deployOptions(), file: 'github/functions/fetch.ts' });
+            const bodies = fetchMock.mock.calls.map(([, init]) => JSON.parse(init.body));
+            expect(bodies).toHaveLength(2);
+            for (const body of bodies) {
+                expect(body.functions.map((fn) => fn.source)).toEqual([source]);
+            }
+        });
         it('deploys a legacy action as a single script', async () => {
             fetchMock.mockResolvedValueOnce(jsonResponse(legacyChangeConfirmation)).mockResolvedValueOnce(jsonResponse([]));
             await deploy({ fullPath, environmentName: 'test', interactive: false, options: deployOptions(), file: 'github/actions/legacy.ts' });
@@ -407,7 +436,7 @@ describe('deploy', () => {
             expect(output).not.toContain('--sync and --action are deprecated');
             const confirmationRequest = fetchMock.mock.calls[0]?.[1];
             const confirmationBody = JSON.parse(confirmationRequest.body);
-            expect(confirmationBody.deployMode).toBe('single');
+            expect(confirmationBody.reconciliationScope).toEqual({ kind: 'function', integrationId: 'github', name: 'legacy' });
             expect(confirmationBody.onEventScriptsByProvider).toBeUndefined();
             expect(confirmationBody.flowConfigs).toEqual([expect.objectContaining({ syncName: 'legacy', providerConfigKey: 'github', type: 'action' })]);
         });
@@ -427,7 +456,7 @@ describe('deploy', () => {
                 expect(logOutput(logSpy)).toContain('✓ Deployed');
                 const confirmationRequest = fetchMock.mock.calls[0]?.[1];
                 const confirmationBody = JSON.parse(confirmationRequest.body);
-                expect(confirmationBody.deployMode).toBe('single');
+                expect(confirmationBody.reconciliationScope).toEqual({ kind: 'function', integrationId: 'github', name: 'contacts' });
                 expect(confirmationBody.flowConfigs).toEqual([
                     expect.objectContaining({
                         syncName: 'contacts',
@@ -437,6 +466,26 @@ describe('deploy', () => {
                     })
                 ]);
             });
+            it('deploys each match of a deprecated action selector in its own function scope', async () => {
+                fetchMock.mockReset();
+                mockApi(fetchMock, { legacyPreview: legacyChangeConfirmation });
+                const result = await deploy({ fullPath, environmentName: 'test', interactive: false, options: deployOptions({ action: 'legacy' }) });
+                expect(result.isOk()).toBe(true);
+                const scopes = fetchMock.mock.calls.map(([url, init]) => {
+                    const body = JSON.parse(init.body);
+                    expect(body).not.toHaveProperty('deployMode');
+                    expect(body.flowConfigs).toHaveLength(1);
+                    const [flow] = body.flowConfigs;
+                    expect(body.reconciliationScope).toEqual({ kind: 'function', integrationId: flow?.providerConfigKey, name: 'legacy' });
+                    return { path: url.pathname, integrationId: flow?.providerConfigKey };
+                });
+                expect(scopes).toEqual([
+                    { path: apiRoutes.legacyPreview, integrationId: 'github' },
+                    { path: apiRoutes.legacyPreview, integrationId: 'slack' },
+                    { path: apiRoutes.legacyDeploy, integrationId: 'github' },
+                    { path: apiRoutes.legacyDeploy, integrationId: 'slack' }
+                ]);
+            });
             it("deploys only the file's integration when another integration has an action with the same name", async () => {
                 await deploy({ fullPath, environmentName: 'test', interactive: false, options: deployOptions(), file: 'slack/actions/legacy.ts' });
                 expect(logOutput(logSpy)).toContain('✓ Deployed');
@@ -532,7 +581,7 @@ describe('deploy', () => {
             unchanged: [],
             deleted: []
         };
-        fetchMock.mockResolvedValueOnce(jsonResponse(functionChanges)).mockResolvedValueOnce(jsonResponse(functionChanges));
+        mockApi(fetchMock, { functionsPreview: functionChanges, functionsDeploy: functionChanges });
         await deploy({
             fullPath,
             environmentName: 'test',
@@ -542,13 +591,16 @@ describe('deploy', () => {
         const output = logOutput(logSpy);
         expect(output).toContain('↳ Functions');
         expect(output).toContain('✓ Deployed');
-        const previewRequest = fetchMock.mock.calls[0]?.[1];
-        const previewBody = JSON.parse(previewRequest.body);
+        expect(requestBody(fetchMock, 'legacyPreview')).toMatchObject({
+            flowConfigs: [],
+            onEventScriptsByProvider: [],
+            reconciliationScope: { kind: 'integration', integrationId: 'slack' }
+        });
+        const previewBody = requestBody(fetchMock, 'functionsPreview');
         expect(previewBody.reconciliationScope).toEqual({ kind: 'integration', integrationId: 'slack' });
         expect(previewBody.functions).toEqual([expect.objectContaining({ integrationId: 'slack', name: 'other', trigger: { kind: 'http' } })]);
     });
-    // TODO: Re-enable these tests when empty deployments can delete the last definition for both legacy scripts and functions.
-    it.skip('deletes the functions of an integration when its last function was removed', async () => {
+    it('deletes the functions of an integration when its last function was removed', async () => {
         vi.mocked(parseIntegrationDefinitions).mockResolvedValue(Ok({ ...functionsOnlyParsed, functions: [githubFunction] }));
         const functionChanges = {
             created: [],
@@ -556,7 +608,7 @@ describe('deploy', () => {
             unchanged: [],
             deleted: [{ integrationId: 'slack', name: 'other' }]
         };
-        fetchMock.mockResolvedValueOnce(jsonResponse(functionChanges)).mockResolvedValueOnce(jsonResponse(functionChanges));
+        mockApi(fetchMock, { functionsPreview: functionChanges, functionsDeploy: functionChanges });
         await deploy({
             fullPath,
             environmentName: 'test',
@@ -567,8 +619,15 @@ describe('deploy', () => {
         expect(output).toContain('- slack → other');
         expect(output).toContain('✓ Deployed');
         expect(output).toContain('Successfully removed:');
+        expect(requestBody(fetchMock, 'functionsDeploy')).toEqual({ reconciliationScope: { kind: 'integration', integrationId: 'slack' }, functions: [] });
+        expect(requestBody(fetchMock, 'legacyPreview')).toMatchObject({
+            flowConfigs: [],
+            onEventScriptsByProvider: [],
+            reconciliationScope: { kind: 'integration', integrationId: 'slack' }
+        });
+        expect(requestPaths(fetchMock)).not.toContain(apiRoutes.legacyDeploy);
     });
-    it.skip('deletes every function of the environment when the last function was removed', async () => {
+    it('deletes every function of the environment when the last function was removed', async () => {
         vi.mocked(parseIntegrationDefinitions).mockResolvedValue(Ok({ ...functionsOnlyParsed, functions: [] }));
         const functionChanges = {
             created: [],
@@ -579,17 +638,70 @@ describe('deploy', () => {
                 { integrationId: 'slack', name: 'other' }
             ]
         };
-        fetchMock.mockResolvedValueOnce(jsonResponse(functionChanges)).mockResolvedValueOnce(jsonResponse(functionChanges));
+        mockApi(fetchMock, { functionsPreview: functionChanges, functionsDeploy: functionChanges });
         await deploy({ fullPath, environmentName: 'test', interactive: false, options: deployOptions({ allowDestructive: true }) });
         const output = logOutput(logSpy);
         expect(output).toContain('- github → fetch');
         expect(output).toContain('- slack → other');
         expect(output).toContain('✓ Deployed');
         expect(output).toContain('Successfully removed:');
+        expect(requestBody(fetchMock, 'functionsDeploy')).toEqual({ reconciliationScope: { kind: 'environment' }, functions: [] });
+    });
+    it('deletes every legacy script of the environment when the last one was removed', async () => {
+        vi.mocked(parseIntegrationDefinitions).mockResolvedValue(Ok({ ...functionsOnlyParsed, functions: [] }));
+        const changes = {
+            ...legacyConfirmation,
+            deletedActions: [{ providerConfigKey: 'github', name: 'legacy' }],
+            deletedOnEventScripts: [{ providerConfigKey: 'github', name: 'old-event', event: 'post-connection-creation' }]
+        };
+        mockApi(fetchMock, { legacyPreview: changes });
+        const result = await deploy({ fullPath, environmentName: 'test', interactive: false, options: deployOptions() });
+        expect(result.isOk()).toBe(true);
+        const output = logOutput(logSpy);
+        expect(output).toContain('Successfully removed:');
+        expect(output).toContain('- github → legacy');
+        expect(output).toContain('- github → old-event');
+        expect(requestBody(fetchMock, 'legacyDeploy')).toMatchObject({
+            flowConfigs: [],
+            onEventScriptsByProvider: [],
+            reconciliationScope: { kind: 'environment' }
+        });
+    });
+    it('deploys a project that only has on-event scripts', async () => {
+        vi.mocked(parseIntegrationDefinitions).mockResolvedValue(Ok({
+            ...functionsOnlyParsed,
+            integrations: functionsOnlyParsed.integrations.map((integration) => ({
+                ...integration,
+                onEventScripts: { ...integration.onEventScripts, 'post-connection-creation': ['on-create'] }
+            })),
+            functions: []
+        }));
+        await fs.mkdir(path.join(fullPath, 'github', 'on-events'), { recursive: true });
+        await fs.writeFile(path.join(fullPath, 'build', 'github_on-events_on-create.cjs'), 'compiled on-event');
+        await fs.writeFile(path.join(fullPath, 'github', 'on-events', 'on-create.ts'), 'source on-event');
+        mockApi(fetchMock, {
+            legacyPreview: {
+                ...legacyConfirmation,
+                newOnEventScripts: [{ providerConfigKey: 'github', name: 'on-create', event: 'post-connection-creation' }]
+            },
+            legacyDeploy: [{ name: 'on-create', version: '0.0.1', providerConfigKey: 'github', type: 'on-event', models: [] }]
+        });
+        const result = await deploy({ fullPath, environmentName: 'test', interactive: false, options: deployOptions() });
+        expect(result.isOk()).toBe(true);
+        expect(logOutput(logSpy)).toContain('- github → on-create@v0.0.1');
+        expect(requestBody(fetchMock, 'legacyDeploy')).toMatchObject({
+            flowConfigs: [],
+            onEventScriptsByProvider: [
+                {
+                    providerConfigKey: 'github',
+                    scripts: [{ name: 'on-create', event: 'post-connection-creation', fileBody: { js: 'compiled on-event', ts: 'source on-event' } }]
+                }
+            ]
+        });
     });
     it('warns about --version for function deployments and still deploys', async () => {
         vi.mocked(parseIntegrationDefinitions).mockResolvedValue(Ok(functionsOnlyParsed));
-        fetchMock.mockResolvedValueOnce(jsonResponse(noFunctionChanges)).mockResolvedValueOnce(jsonResponse(noFunctionChanges));
+        mockApi(fetchMock);
         const result = await deploy({
             fullPath,
             environmentName: 'test',
@@ -598,7 +710,15 @@ describe('deploy', () => {
         });
         expect(result.isOk()).toBe(true);
         expect(logOutput(logSpy)).toContain('The --version option only applies to syncs/actions; it has no effect on functions.');
-        expect(fetchMock).toHaveBeenCalledTimes(2);
+        expect(requestPaths(fetchMock)).toEqual([apiRoutes.legacyPreview, apiRoutes.functionsPreview, apiRoutes.functionsDeploy]);
+    });
+    it('only previews when no deployment has anything to deploy or delete', async () => {
+        vi.mocked(parseIntegrationDefinitions).mockResolvedValue(Ok({ ...functionsOnlyParsed, functions: [] }));
+        mockApi(fetchMock);
+        const result = await deploy({ fullPath, environmentName: 'test', interactive: false, options: deployOptions() });
+        expect(result.isOk()).toBe(true);
+        expect(requestPaths(fetchMock)).toEqual([apiRoutes.legacyPreview, apiRoutes.functionsPreview]);
+        expect(logOutput(logSpy)).toContain('No changes were deployed.');
     });
     it('prints only the Functions summary row for a functions-only project', async () => {
         vi.mocked(parseIntegrationDefinitions).mockResolvedValue(Ok(functionsOnlyParsed));
@@ -608,7 +728,7 @@ describe('deploy', () => {
             unchanged: [{ integrationId: 'slack', name: 'other' }],
             deleted: []
         };
-        fetchMock.mockResolvedValueOnce(jsonResponse(functionChanges)).mockResolvedValueOnce(jsonResponse(functionChanges));
+        mockApi(fetchMock, { functionsPreview: functionChanges, functionsDeploy: functionChanges });
         await deploy({ fullPath, environmentName: 'test', interactive: false, options: deployOptions() });
         const output = logOutput(logSpy);
         expect(output).not.toContain('↳ Syncs');
@@ -631,11 +751,10 @@ describe('deploy', () => {
             unchanged: [],
             deleted: []
         };
-        fetchMock.mockResolvedValueOnce(jsonResponse(functionChanges)).mockResolvedValueOnce(jsonResponse(functionChanges));
+        mockApi(fetchMock, { functionsPreview: functionChanges, functionsDeploy: functionChanges });
         await deploy({ fullPath, environmentName: 'test', interactive: false, options: deployOptions() });
         expect(logOutput(logSpy)).toContain('✓ Deployed');
-        const previewRequest = fetchMock.mock.calls[0]?.[1];
-        const previewBody = JSON.parse(previewRequest.body);
+        const previewBody = requestBody(fetchMock, 'functionsPreview');
         expect(previewBody.functions[0]?.fileBody).toEqual({ js: 'compiled with dotted path', ts: 'source with dotted path' });
     });
     it('rejects function source paths outside the project directory', async () => {
@@ -657,7 +776,7 @@ describe('deploy', () => {
     });
     it('prints only legacy summary rows when no functions bundle', async () => {
         vi.mocked(parseIntegrationDefinitions).mockResolvedValue(Ok(legacyOnlyParsed));
-        fetchMock.mockResolvedValueOnce(jsonResponse(legacyChangeConfirmation)).mockResolvedValueOnce(jsonResponse([]));
+        mockApi(fetchMock, { legacyPreview: legacyChangeConfirmation });
         await deploy({ fullPath, environmentName: 'test', interactive: false, options: deployOptions() });
         const output = logOutput(logSpy);
         expect(output).toContain('↳ Syncs');
@@ -670,16 +789,9 @@ describe('deploy', () => {
         { name: 'legacy', definitions: legacyOnlyParsed },
         { name: 'functions', definitions: functionsOnlyParsed },
         { name: 'mixed', definitions: parsed }
-    ])('prints No changes when the $name deployment is unchanged', async ({ name, definitions }) => {
+    ])('prints No changes when the $name deployment is unchanged', async ({ definitions }) => {
         vi.mocked(parseIntegrationDefinitions).mockResolvedValue(Ok(definitions));
-        fetchMock.mockResolvedValueOnce(jsonResponse(name === 'functions' ? noFunctionChanges : legacyConfirmation));
-        if (name === 'mixed') {
-            fetchMock.mockResolvedValueOnce(jsonResponse(noFunctionChanges));
-        }
-        fetchMock.mockResolvedValueOnce(jsonResponse(name === 'functions' ? noFunctionChanges : []));
-        if (name === 'mixed') {
-            fetchMock.mockResolvedValueOnce(jsonResponse(noFunctionChanges));
-        }
+        mockApi(fetchMock, { functionsPreview: noFunctionChanges, functionsDeploy: noFunctionChanges });
         const result = await deploy({ fullPath, environmentName: 'test', interactive: false, options: deployOptions() });
         const output = logOutput(logSpy);
         expect(result.isOk()).toBe(true);
@@ -692,38 +804,43 @@ describe('deploy', () => {
     });
     it('prints Function preview errors', async () => {
         vi.mocked(parseIntegrationDefinitions).mockResolvedValue(Ok(functionsOnlyParsed));
-        fetchMock.mockResolvedValueOnce(jsonResponse({ error: { code: 'functions_deployment_error', message: 'Preview failed' } }));
+        mockApi(fetchMock, { functionsPreview: { error: { code: 'functions_deployment_error', message: 'Preview failed' } } });
         await deploy({ fullPath, environmentName: 'test', interactive: false, options: deployOptions() });
         expect(logOutput(logSpy)).toContain('Error checking functions state:\nPreview failed');
-        expect(fetchMock).toHaveBeenCalledTimes(1);
+        expect(requestPaths(fetchMock)).toEqual(['/sync/deploy/confirmation', '/functions/deployments/bundle/preview']);
     });
     it('prints Function deploy errors', async () => {
         vi.mocked(parseIntegrationDefinitions).mockResolvedValue(Ok(functionsOnlyParsed));
-        fetchMock
-            .mockResolvedValueOnce(jsonResponse(noFunctionChanges))
-            .mockResolvedValueOnce(jsonResponse({ error: { code: 'functions_deployment_error', message: 'Apply failed' } }));
+        mockApi(fetchMock, { functionsDeploy: { error: { code: 'functions_deployment_error', message: 'Apply failed' } } });
         await deploy({ fullPath, environmentName: 'test', interactive: false, options: deployOptions() });
         expect(logOutput(logSpy)).toContain('Error deploying functions');
         expect(logOutput(logSpy)).not.toContain('✓ Deployed');
-        expect(fetchMock).toHaveBeenCalledTimes(2);
+        expect(requestPaths(fetchMock)).toEqual([apiRoutes.legacyPreview, apiRoutes.functionsPreview, apiRoutes.functionsDeploy]);
     });
     it('does not deploy legacy scripts when the preview fails', async () => {
         vi.mocked(parseIntegrationDefinitions).mockResolvedValue(Ok(legacyOnlyParsed));
-        fetchMock.mockResolvedValueOnce(jsonResponse({ error: { code: 'server_error', message: 'Preview failed' } }));
+        mockApi(fetchMock, { legacyPreview: { error: { code: 'server_error', message: 'Preview failed' } } });
         const result = await deploy({ fullPath, environmentName: 'test', interactive: false, options: deployOptions() });
         expect(result.isErr()).toBe(true);
-        expect(fetchMock).toHaveBeenCalledTimes(1);
+        expect(requestPaths(fetchMock)).toEqual(['/sync/deploy/confirmation', '/functions/deployments/bundle/preview']);
         expect(logOutput(logSpy)).toContain('Error checking state:\nPreview failed');
         expect(logOutput(logSpy)).not.toContain('✓ Deployed');
     });
+    it('does not deploy when the selected integration does not exist', async () => {
+        vi.mocked(parseIntegrationDefinitions).mockResolvedValue(Ok(legacyOnlyParsed));
+        mockApi(fetchMock, { functionsPreview: { error: { code: 'integration_not_found', message: 'Integration(s) not found: unknown' } } });
+        const result = await deploy({ fullPath, environmentName: 'test', interactive: false, options: deployOptions({ integration: 'unknown' }) });
+        expect(result.isErr()).toBe(true);
+        expect(requestPaths(fetchMock)).toEqual(['/sync/deploy/confirmation', '/functions/deployments/bundle/preview']);
+        expect(logOutput(logSpy)).toContain('Integration(s) not found: unknown');
+        expect(logOutput(logSpy)).not.toContain('✓ Deployed');
+    });
     it('reports legacy deployment errors', async () => {
         vi.mocked(parseIntegrationDefinitions).mockResolvedValue(Ok(legacyOnlyParsed));
-        fetchMock
-            .mockResolvedValueOnce(jsonResponse(legacyConfirmation))
-            .mockResolvedValueOnce(jsonResponse({ error: { code: 'server_error', message: 'Apply failed' } }));
+        mockApi(fetchMock, { legacyDeploy: { error: { code: 'server_error', message: 'Apply failed' } } });
         const result = await deploy({ fullPath, environmentName: 'test', interactive: false, options: deployOptions() });
         expect(result.isErr()).toBe(true);
-        expect(fetchMock).toHaveBeenCalledTimes(2);
+        expect(fetchMock).toHaveBeenCalledTimes(3);
         expect(logOutput(logSpy)).toContain('Error deploying:\nApply failed');
         expect(logOutput(logSpy)).not.toContain('✓ Deployed');
     });
@@ -732,34 +849,34 @@ describe('deploy', () => {
         { name: 'a model', changes: { deletedModels: ['RemovedModel'] } }
     ])('requires destructive confirmation when removing $name', async ({ changes }) => {
         vi.mocked(parseIntegrationDefinitions).mockResolvedValue(Ok(legacyOnlyParsed));
-        fetchMock.mockResolvedValueOnce(jsonResponse({ ...legacyConfirmation, ...changes }));
+        mockApi(fetchMock, { legacyPreview: { ...legacyConfirmation, ...changes } });
         const result = await deploy({ fullPath, environmentName: 'test', interactive: false, options: deployOptions() });
         expect(result.isErr()).toBe(true);
-        expect(fetchMock).toHaveBeenCalledTimes(1);
+        expect(fetchMock).toHaveBeenCalledTimes(2);
         expect(logOutput(logSpy)).not.toContain('✓ Deployed');
     });
     it('deploys legacy destructive changes when confirmation flags are provided', async () => {
         vi.mocked(parseIntegrationDefinitions).mockResolvedValue(Ok(legacyOnlyParsed));
-        fetchMock.mockResolvedValueOnce(jsonResponse({ ...legacyConfirmation, deletedModels: ['RemovedModel'] })).mockResolvedValueOnce(jsonResponse([]));
+        mockApi(fetchMock, { legacyPreview: { ...legacyConfirmation, deletedModels: ['RemovedModel'] } });
         const result = await deploy({ fullPath, environmentName: 'test', interactive: false, options: deployOptions({ allowDestructive: true }) });
         expect(result.isOk()).toBe(true);
-        expect(fetchMock).toHaveBeenCalledTimes(2);
+        expect(requestPaths(fetchMock)).toEqual([apiRoutes.legacyPreview, apiRoutes.functionsPreview, apiRoutes.legacyDeploy]);
         expect(promptly.confirm).not.toHaveBeenCalled();
         expect(logOutput(logSpy)).toContain('allowDestructive flag is on');
         expect(logOutput(logSpy)).toContain('✓ Deployed');
     });
     it('explains the required legacy confirmation flags when non-interactive', async () => {
         vi.mocked(parseIntegrationDefinitions).mockResolvedValue(Ok(legacyOnlyParsed));
-        fetchMock.mockResolvedValueOnce(jsonResponse({ ...legacyConfirmation, deletedModels: ['RemovedModel'] }));
+        mockApi(fetchMock, { legacyPreview: { ...legacyConfirmation, deletedModels: ['RemovedModel'] } });
         const result = await deploy({ fullPath, environmentName: 'test', interactive: false, options: deployOptions() });
         expect(result.isErr()).toBe(true);
         expect(logOutput(logSpy)).toContain('Nothing was deployed. Confirm the deploy by passing the --auto-confirm and --allow-destructive flags. Exiting');
         expect(promptly.confirm).not.toHaveBeenCalled();
-        expect(fetchMock).toHaveBeenCalledTimes(1);
+        expect(fetchMock).toHaveBeenCalledTimes(2);
     });
     it('prints the legacy abort message when confirmation is declined', async () => {
         vi.mocked(parseIntegrationDefinitions).mockResolvedValue(Ok(legacyOnlyParsed));
-        fetchMock.mockResolvedValueOnce(jsonResponse({ ...legacyConfirmation, deletedModels: ['RemovedModel'] }));
+        mockApi(fetchMock, { legacyPreview: { ...legacyConfirmation, deletedModels: ['RemovedModel'] } });
         const result = await deploy({
             fullPath,
             environmentName: 'test',
@@ -769,58 +886,57 @@ describe('deploy', () => {
         expect(result.isErr()).toBe(true);
         expect(logOutput(logSpy)).toContain('Deploy aborted. Exiting');
         expect(promptly.confirm).toHaveBeenCalledTimes(1);
-        expect(fetchMock).toHaveBeenCalledTimes(1);
+        expect(fetchMock).toHaveBeenCalledTimes(2);
     });
     it('preserves the legacy version override in both preview and deployment', async () => {
         vi.mocked(parseIntegrationDefinitions).mockResolvedValue(Ok(legacyOnlyParsed));
-        fetchMock.mockResolvedValueOnce(jsonResponse(legacyConfirmation)).mockResolvedValueOnce(jsonResponse([]));
+        mockApi(fetchMock);
         const result = await deploy({ fullPath, environmentName: 'test', interactive: false, options: deployOptions({ version: '42' }) });
         expect(result.isOk()).toBe(true);
-        expect(fetchMock).toHaveBeenCalledTimes(2);
-        const previewRequest = fetchMock.mock.calls[0]?.[1];
-        const deployRequest = fetchMock.mock.calls[1]?.[1];
-        const previewBody = JSON.parse(previewRequest.body);
-        const deployBody = JSON.parse(deployRequest.body);
+        expect(requestPaths(fetchMock)).toEqual([apiRoutes.legacyPreview, apiRoutes.functionsPreview, apiRoutes.legacyDeploy]);
+        const previewBody = requestBody(fetchMock, 'legacyPreview');
         expect(previewBody).toMatchObject({ reconcile: false, flowConfigs: [{ version: '42' }] });
-        expect(deployBody).toMatchObject({ reconcile: true, flowConfigs: previewBody.flowConfigs });
+        expect(requestBody(fetchMock, 'legacyDeploy')).toMatchObject({ reconcile: true, flowConfigs: previewBody?.['flowConfigs'] });
         expect(logOutput(logSpy)).not.toContain('The --version option');
     });
     it.each(['preview', 'deploy'])('prints backend validation details during function %s', async (stage) => {
         vi.mocked(parseIntegrationDefinitions).mockResolvedValue(Ok(functionsOnlyParsed));
-        if (stage === 'deploy') {
-            fetchMock.mockResolvedValueOnce(jsonResponse(noFunctionChanges));
-        }
-        fetchMock.mockResolvedValueOnce(jsonResponse({
-            error: {
-                code: 'invalid_body',
-                errors: [
-                    { code: 'invalid_union', path: ['functions', 0, 'tags', 'required_scopes'], message: 'Expected a structured scope requirement' },
-                    { code: 'custom', path: [], message: 'Another validation error' }
-                ]
+        mockApi(fetchMock, {
+            functionsPreview: noFunctionChanges,
+            [stage === 'preview' ? 'functionsPreview' : 'functionsDeploy']: {
+                error: {
+                    code: 'invalid_body',
+                    errors: [
+                        { code: 'invalid_union', path: ['functions', 0, 'tags', 'required_scopes'], message: 'Expected a structured scope requirement' },
+                        { code: 'custom', path: [], message: 'Another validation error' }
+                    ]
+                }
             }
-        }));
+        });
         await deploy({ fullPath, environmentName: 'test', interactive: false, options: deployOptions() });
         const output = logOutput(logSpy);
         expect(output).toContain('invalid_body');
         expect(output).toContain('- functions.0.tags.required_scopes: Expected a structured scope requirement');
         expect(output).toContain('- Another validation error');
         expect(output).not.toContain('✓ Deployed');
-        expect(fetchMock).toHaveBeenCalledTimes(stage === 'preview' ? 1 : 2);
+        expect(fetchMock).toHaveBeenCalledTimes(stage === 'preview' ? 2 : 3);
     });
     it('prints an aborted deployment when function deletions are not allowed', async () => {
         vi.mocked(parseIntegrationDefinitions).mockResolvedValue(Ok(functionsOnlyParsed));
-        fetchMock.mockResolvedValueOnce(jsonResponse({
-            created: [],
-            updated: [],
-            unchanged: [{ integrationId: 'github', name: 'fetch' }],
-            deleted: [{ integrationId: 'github', name: 'removed' }]
-        }));
+        mockApi(fetchMock, {
+            functionsPreview: {
+                created: [],
+                updated: [],
+                unchanged: [{ integrationId: 'github', name: 'fetch' }],
+                deleted: [{ integrationId: 'github', name: 'removed' }]
+            }
+        });
         await deploy({ fullPath, environmentName: 'test', interactive: false, options: deployOptions() });
         const output = logOutput(logSpy);
         expect(output).toContain('↳ Functions');
         expect(output).toContain('Nothing was deployed.');
         expect(output).not.toContain('✓ Deployed');
-        expect(fetchMock).toHaveBeenCalledTimes(1);
+        expect(fetchMock).toHaveBeenCalledTimes(2);
     });
     it.each([false, true])('reports function removals alongside updates: %s', async (withUpdates) => {
         vi.mocked(parseIntegrationDefinitions).mockResolvedValue(Ok(functionsOnlyParsed));
@@ -830,7 +946,7 @@ describe('deploy', () => {
             unchanged: [{ integrationId: 'github', name: 'fetch' }],
             deleted: [{ integrationId: 'github', name: 'removed' }]
         };
-        fetchMock.mockResolvedValueOnce(jsonResponse(functionChanges)).mockResolvedValueOnce(jsonResponse(functionChanges));
+        mockApi(fetchMock, { functionsPreview: functionChanges, functionsDeploy: functionChanges });
         await deploy({ fullPath, environmentName: 'test', interactive: false, options: deployOptions({ allowDestructive: true }) });
         const output = logOutput(logSpy);
         expect(output).toContain('allowDestructive flag is on');
@@ -854,7 +970,7 @@ describe('deploy', () => {
             deletedActions: [{ providerConfigKey: 'github', name: 'old-action' }],
             deletedOnEventScripts: [{ providerConfigKey: 'github', name: 'old-event', event: 'post-connection-creation' }]
         };
-        fetchMock.mockResolvedValueOnce(jsonResponse(changes)).mockResolvedValueOnce(jsonResponse(withDeployments ? legacyDeploymentResult : []));
+        mockApi(fetchMock, { legacyPreview: changes, legacyDeploy: withDeployments ? legacyDeploymentResult : [] });
         const result = await deploy({ fullPath, environmentName: 'test', interactive: false, options: deployOptions({ allowDestructive: true }) });
         const output = logOutput(logSpy);
         expect(result.isOk()).toBe(true);
@@ -916,6 +1032,28 @@ async function writeProject(fullPath) {
 function jsonResponse(value) {
     return { json: vi.fn().mockResolvedValue(value) };
 }
+function mockApi(fetchMock, responses = {}) {
+    const defaults = {
+        legacyPreview: legacyConfirmation,
+        legacyDeploy: [],
+        functionsPreview: emptyFunctionChanges,
+        functionsDeploy: emptyFunctionChanges
+    };
+    fetchMock.mockImplementation((url) => {
+        const route = Object.keys(apiRoutes).find((key) => apiRoutes[key] === url.pathname);
+        if (!route) {
+            return Promise.reject(new Error(`Unexpected request to ${url.pathname}`));
+        }
+        return Promise.resolve(jsonResponse(responses[route] ?? defaults[route]));
+    });
+}
+function requestPaths(fetchMock) {
+    return fetchMock.mock.calls.map(([url]) => url.pathname);
+}
+function requestBody(fetchMock, route) {
+    const call = fetchMock.mock.calls.find(([url]) => url.pathname === apiRoutes[route]);
+    return call ? JSON.parse(call[1].body) : undefined;
+}
 function logOutput(logSpy) {
     const calls = logSpy.mock.calls;
     return calls.map((args) => args.map(String).join(' ')).join('\n');