nango 0.72.1 → 0.72.3

package/dist/zeroYaml/deploy.js

@@ -3,19 +3,33 @@ import path from 'node:path';
 import chalk from 'chalk';
 import columnify from 'columnify';
 import promptly from 'promptly';
+import * as z from 'zod';
 import { cliFetch } from '../tls.js';
-import { getCliHeaders, isCI, parseSecretKey, printDebug, resolveHostport } from '../utils.js';
+import { getCliHeaders, parseSecretKey, printDebug, resolveHostport } from '../utils.js';
 import { Err, Ok } from '../utils/result.js';
 import { Spinner } from '../utils/spinner.js';
 import { NANGO_VERSION } from '../version.js';
 import { tsToJsPath } from './compile.js';
 import { parseIntegrationDefinitions } from './definitions.js';
-import { resolveProjectPath } from './project-path.js';
+import { resolveEntryPoint, resolveProjectPath } from './project-path.js';
 import { ReadableError } from './utils.js';
-export async function deploy({ fullPath, options, environmentName, interactive = true }) {
+export async function deploy({ fullPath, options, environmentName, file, interactive }) {
     const { env, version, debug } = options;
     const spinnerFactory = new Spinner({ interactive });
-    let deployment;
+    if (options.sync && options.action) {
+        console.log(chalk.red('The --sync and --action options cannot be used together.'));
+        return Err('invalid_options');
+    }
+    const validArguments = validateDeployArguments({ environment: environmentName, file, options });
+    if (validArguments.isErr()) {
+        console.log(chalk.red(validArguments.error.message));
+        return Err(validArguments.error);
+    }
+    if (options.sync || options.action) {
+        console.log(chalk.yellow('--sync and --action are deprecated. Use `nango deploy <environment> <file>` to deploy a single script.'));
+    }
+    const deploySource = resolveDeploySource();
+    const plan = [];
     const spinnerPackage = spinnerFactory.start('Packaging');
     try {
         const def = await parseIntegrationDefinitions({ fullPath, debug });
@@ -25,47 +39,46 @@ export async function deploy({ fullPath, options, environmentName, interactive =
             console.log(def.error instanceof ReadableError ? def.error.toText() : chalk.red(def.error.message));
             return Err(def.error);
         }
-        const deploymentKind = getDeploymentKind({
-            parsed: def.value,
-            optionalIntegrationId: options.integration,
-            optionalSyncName: options.sync,
-            optionalActionName: options.action
-        });
-        if (deploymentKind === 'mixed') {
+        const selections = file !== undefined ? planFileDeployment({ fullPath, file, parsed: def.value }).map((selection) => [selection]) : Ok(planDeployment({ options }));
+        if (selections.isErr()) {
             spinnerPackage.fail();
-            console.log(chalk.red('Legacy scripts and functions cannot be deployed together.'));
+            console.log(chalk.red(selections.error.message));
             return Err('no_data');
         }
-        if (deploymentKind === 'legacy') {
-            const postData = await createDeployConfirmationPackage({
-                parsed: def.value,
-                fullPath,
-                debug,
-                version,
-                optionalIntegrationId: options.integration,
-                optionalSyncName: options.sync,
-                optionalActionName: options.action
-            });
-            if (postData.isErr()) {
-                spinnerPackage.fail();
-                console.log(chalk.red(postData.error.message));
-                return Err('no_data');
-            }
-            deployment = { kind: 'legacy', package: postData.value };
-        }
-        else {
-            if (options.version) {
-                spinnerPackage.fail();
-                console.log(chalk.red('The --version option can only be used with legacy scripts.'));
-                return Err('no_data');
+        for (const selection of selections.value) {
+            if (selection.kind === 'legacy') {
+                const postData = await createLegacyPackage({
+                    parsed: def.value,
+                    fullPath,
+                    debug,
+                    version,
+                    reconciliationScope: selection.integrationId ? { kind: 'integration', integrationId: selection.integrationId } : { kind: 'environment' },
+                    optionalSyncName: selection.syncName,
+                    optionalActionName: selection.actionName
+                });
+                if (postData.isErr()) {
+                    spinnerPackage.fail();
+                    console.log(chalk.red(postData.error.message));
+                    return Err('no_data');
+                }
+                for (const legacyPackage of postData.value) {
+                    plan.push({ kind: 'legacy', package: legacyPackage });
+                }
             }
-            const bundle = await createFunctionsBundle({ fullPath, optionalIntegrationId: options.integration });
-            if (bundle.isErr()) {
-                spinnerPackage.fail();
-                console.log(chalk.red(bundle.error.message));
-                return Err('no_data');
+            else {
+                const bundle = await createFunctionsBundle({
+                    fullPath,
+                    functionConfigs: def.value.functions,
+                    reconciliationScope: selection.reconciliationScope,
+                    source: deploySource
+                });
+                if (bundle.isErr()) {
+                    spinnerPackage.fail();
+                    console.log(chalk.red(bundle.error.message));
+                    return Err('no_data');
+                }
+                plan.push({ kind: 'functions', bundle: bundle.value });
             }
-            deployment = { kind: 'functions', bundle: bundle.value };
         }
         spinnerPackage.succeed();
     }
@@ -74,6 +87,9 @@ export async function deploy({ fullPath, options, environmentName, interactive =
         console.error(chalk.red('Unknown error'), err);
         return Err('failed');
     }
+    if (version && plan.some((deployment) => deployment.kind === 'functions' && deployment.bundle.functions.length > 0)) {
+        console.log(chalk.yellow('The --version option only applies to syncs/actions; it has no effect on functions.'));
+    }
     // Get the private key before reaching the API
     await parseSecretKey(environmentName, debug);
     const nangoYamlBody = '';
@@ -81,28 +97,16 @@ export async function deploy({ fullPath, options, environmentName, interactive =
     const hostport = resolveHostport(env);
     // Check remote state
     const spinnerState = spinnerFactory.start(`Acquiring remote state ${chalk.gray(`(${new URL(hostport).origin})`)}`);
-    let confirmation;
+    const confirmations = [];
     try {
-        if (deployment.kind === 'legacy') {
-            const confirmationRes = await postLegacyConfirmation({
-                hostport,
-                body: { ...deployment.package, reconcile: false, debug, sdkVersion }
-            });
+        const confirmationResults = await Promise.all(plan.map((deployment) => previewDeployment({ deployment, hostport, debug, sdkVersion })));
+        for (const confirmationRes of confirmationResults) {
             if (confirmationRes.isErr()) {
                 spinnerState.fail();
                 console.log(chalk.red(confirmationRes.error.message));
                 return Err(confirmationRes.error);
             }
-            confirmation = { kind: 'legacy', value: confirmationRes.value };
-        }
-        else {
-            const confirmationRes = await previewFunctionsDeployment({ hostport, body: deployment.bundle });
-            if (confirmationRes.isErr()) {
-                spinnerState.fail();
-                console.log(chalk.red(confirmationRes.error.message));
-                return Err(confirmationRes.error);
-            }
-            confirmation = { kind: 'functions', value: confirmationRes.value };
+            confirmations.push(confirmationRes.value);
         }
         spinnerState.succeed();
     }
@@ -110,90 +114,157 @@ export async function deploy({ fullPath, options, environmentName, interactive =
         spinnerState.fail();
         return Err('failed');
     }
-    const deploySource = resolveDeploySource();
     const autoconfirm = process.env['NANGO_DEPLOY_AUTO_CONFIRM'] === 'true' || options.autoConfirm;
-    const confirmed = confirmation.kind === 'legacy'
-        ? await handleLegacyConfirmation({ autoconfirm, allowDestructive: options.allowDestructive || false, confirmation: confirmation.value })
-        : await handleFunctionsConfirmation({
-            autoconfirm,
-            allowDestructive: options.allowDestructive || false,
-            confirmation: confirmation.value
-        });
+    const confirmed = await handleConfirmation({
+        autoconfirm,
+        allowDestructive: options.allowDestructive || false,
+        confirmations,
+        interactive
+    });
     if (confirmed.isErr()) {
         return Err('not_confirmed');
     }
     console.log('');
     // Actual deploy
-    const total = deployment.kind === 'legacy'
-        ? deployment.package.flowConfigs.length + (deployment.package.onEventScriptsByProvider?.reduce((v, t) => v + t.scripts.length, 0) || 0)
-        : deployment.bundle.functions.length;
-    const spinnerDeploy = spinnerFactory.start(`Deploying ${total} functions`);
-    try {
-        if (deployment.kind === 'legacy') {
-            const deployRes = await postLegacyDeploy({
-                hostport,
-                body: { ...deployment.package, reconcile: true, debug, nangoYamlBody, sdkVersion, source: deploySource }
-            });
-            if (deployRes.isErr()) {
-                spinnerDeploy.fail();
-                console.log(chalk.red(deployRes.error.message));
-                return Err('failed_to_deploy');
-            }
-            spinnerDeploy.succeed('Deployed');
-            console.log(chalk.green(deployRes.value));
-        }
-        else {
-            const deployRes = await deployFunctions({ hostport, body: deployment.bundle });
-            if (deployRes.isErr()) {
-                spinnerDeploy.fail();
-                console.log(chalk.red(deployRes.error.message));
-                return Err('failed_to_deploy');
+    const pendingConfirmations = confirmations.filter((confirmation) => !isNoop(confirmation));
+    const total = pendingConfirmations.reduce((count, { deployment }) => count + countFunctions(deployment), 0);
+    const spinnerDeploy = spinnerFactory.start(total > 0 ? `Deploying ${total} functions` : 'Deploying');
+    const results = [];
+    // Deployments are intentionally not atomic: completed ones are not rolled back on failure.
+    for (const [failedIndex, confirmation] of pendingConfirmations.entries()) {
+        const deployRes = await executeDeployment({ confirmation, hostport, debug, nangoYamlBody, sdkVersion, source: deploySource });
+        if (deployRes.isErr()) {
+            spinnerDeploy.fail();
+            printDeploymentMessage(results);
+            console.log(chalk.red(deployRes.error.message));
+            console.log(chalk.red(failedIndex > 0 ? 'Deployment partially completed.' : 'Deployment failed.'));
+            for (const [index, { kind }] of pendingConfirmations.entries()) {
+                const status = index < failedIndex ? 'completed' : index === failedIndex ? 'failed' : 'not attempted';
+                console.log(`- ${kind === 'legacy' ? 'Syncs/actions/on-events' : 'Functions'}: ${status}`);
             }
-            spinnerDeploy.succeed('Deployed');
-            console.log(chalk.green(functionsDeploymentMessage(deployRes.value)));
+            console.log(chalk.yellow('The failed request may have applied changes. Check remote state before retrying.'));
+            return Err('failed_to_deploy');
         }
-        return Ok(true);
+        results.push(deployRes.value);
     }
-    catch {
-        spinnerDeploy.fail();
-        return Err('failed');
+    spinnerDeploy.succeed('Deployed');
+    if (results.every((result) => result.deployed.length + result.deleted.length === 0)) {
+        console.log(chalk.gray('No changes were deployed.'));
     }
+    else {
+        printDeploymentMessage(results);
+    }
+    return Ok(true);
 }
-function getDeploymentKind({ parsed, optionalIntegrationId, optionalSyncName, optionalActionName }) {
-    if (optionalSyncName || optionalActionName) {
-        return 'legacy';
-    }
-    const integrations = optionalIntegrationId
-        ? parsed.integrations.filter((integration) => integration.providerConfigKey === optionalIntegrationId)
-        : parsed.integrations;
-    const hasLegacyScripts = integrations.some((integration) => integration.syncs.length > 0 || integration.actions.length > 0 || Object.values(integration.onEventScripts).some((scripts) => scripts.length > 0));
-    const hasFunctions = parsed.functions.some((config) => !optionalIntegrationId || config.integrationId === optionalIntegrationId);
-    if (hasLegacyScripts && hasFunctions) {
-        return 'mixed';
-    }
-    if (hasLegacyScripts) {
-        return 'legacy';
-    }
-    return 'functions';
+function countFunctions(deployment) {
+    if (deployment.kind === 'legacy') {
+        const onEventScriptsCount = deployment.package.onEventScriptsByProvider?.reduce((count, { scripts }) => count + scripts.length, 0) || 0;
+        return deployment.package.flowConfigs.length + onEventScriptsCount;
+    }
+    return deployment.bundle.functions.length;
 }
-async function createFunctionsBundle({ fullPath, optionalIntegrationId }) {
-    const artifactPath = path.join(fullPath, '.nango', 'functions.json');
-    let functionConfigs = [];
-    if (fs.existsSync(artifactPath)) {
-        try {
-            const content = await fs.promises.readFile(artifactPath, 'utf8');
-            const parsed = JSON.parse(content);
-            if (!Array.isArray(parsed)) {
-                return Err(new Error(`Invalid functions artifact ${artifactPath}`));
-            }
-            functionConfigs = parsed;
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            return Err(new Error(`Could not read functions artifact ${artifactPath}: ${message}`));
+function isNoop(confirmation) {
+    if (countFunctions(confirmation.deployment) > 0) {
+        return false;
+    }
+    if (confirmation.kind === 'legacy') {
+        const { deletedSyncs, deletedActions, deletedOnEventScripts } = confirmation.value;
+        return deletedSyncs.length + deletedActions.length + deletedOnEventScripts.length === 0;
+    }
+    return confirmation.value.deleted.length === 0;
+}
+async function previewDeployment({ deployment, hostport, debug, sdkVersion }) {
+    if (deployment.kind === 'legacy') {
+        const result = await postLegacyConfirmation({ hostport, body: { ...deployment.package, reconcile: false, debug, sdkVersion } });
+        return result.map((value) => ({ kind: 'legacy', value, deployment }));
+    }
+    const result = await previewFunctionsDeployment({ hostport, body: deployment.bundle });
+    return result.map((value) => ({ kind: 'functions', value, deployment }));
+}
+async function executeDeployment({ confirmation, hostport, debug, nangoYamlBody, sdkVersion, source }) {
+    try {
+        if (confirmation.kind === 'legacy') {
+            const { deployment, value } = confirmation;
+            const result = await postLegacyDeploy({ hostport, body: { ...deployment.package, reconcile: true, debug, nangoYamlBody, sdkVersion, source } });
+            return result.map((deployed) => ({
+                deployed: deployed.map(({ providerConfigKey, name, version }) => ({ integrationId: providerConfigKey, name, version })),
+                // The legacy API only returns deployed entries.
+                // Getting deleted entries from the confirmation response instead.
+                deleted: [...value.deletedSyncs, ...value.deletedActions, ...value.deletedOnEventScripts].map(({ providerConfigKey, name }) => ({
+                    integrationId: providerConfigKey,
+                    name
+                }))
+            }));
+        }
+        const result = await deployFunctions({ hostport, body: confirmation.deployment.bundle });
+        return result.map((value) => ({ deployed: [...value.created, ...value.updated], deleted: value.deleted }));
+    }
+    catch (err) {
+        return Err(new Error(`Unexpected deploy response:\n${err instanceof Error ? err.message : String(err)}`));
+    }
+}
+function planDeployment({ options }) {
+    const { integration: integrationId, sync: syncName, action: actionName } = options;
+    if (syncName || actionName) {
+        return [{ kind: 'legacy', integrationId, syncName, actionName }];
+    }
+    // Reconcile both families even when their last local script was removed.
+    return [
+        { kind: 'legacy', integrationId },
+        { kind: 'functions', reconciliationScope: integrationId ? { kind: 'integration', integrationId } : { kind: 'environment' } }
+    ];
+}
+const environmentNameSchema = z
+    .string()
+    .regex(/^[a-z0-9_-]+$/)
+    .max(255);
+export function validateDeployArguments({ environment, file, options }) {
+    if (!environmentNameSchema.safeParse(environment).success) {
+        return Err(new Error(`'${environment}' is not a valid environment name. Usage: nango deploy <environment> [file]`));
+    }
+    if (file === undefined) {
+        return Ok(undefined);
+    }
+    if (file.trim() === '') {
+        return Err(new Error('The file argument is empty.'));
+    }
+    if (options.sync || options.action || options.integration) {
+        return Err(new Error('A file cannot be combined with --sync, --action or --integration.'));
+    }
+    return Ok(undefined);
+}
+function planFileDeployment({ fullPath, file, parsed }) {
+    const resolved = resolveEntryPoint({ fullPath, file, entryPoints: parsed.entryPoints });
+    if (resolved.isErr()) {
+        return Err(resolved.error);
+    }
+    const entryPoint = resolved.value;
+    const { integrationId, name } = entryPoint;
+    switch (entryPoint.type) {
+        case 'function':
+            return Ok({ kind: 'functions', reconciliationScope: { kind: 'function', integrationId, name } });
+        case 'sync':
+            return Ok({ kind: 'legacy', integrationId, syncName: name });
+        case 'action':
+            return Ok({ kind: 'legacy', integrationId, actionName: name });
+        case 'on-event':
+            return Err(new Error(`'${file}' is an on-event script and can't be deployed on its own. Use \`nango deploy <environment> --integration ${integrationId}\` or deploy the whole project.`));
+    }
+}
+async function createFunctionsBundle({ fullPath, functionConfigs, reconciliationScope, source }) {
+    const selectedConfigs = functionConfigs.filter((config) => {
+        switch (reconciliationScope.kind) {
+            case 'environment':
+                return true;
+            case 'function':
+                return config.integrationId === reconciliationScope.integrationId && config.name === reconciliationScope.name;
+            case 'integration':
+                return config.integrationId === reconciliationScope.integrationId;
         }
+    });
+    if (reconciliationScope.kind === 'function' && selectedConfigs.length === 0) {
+        return Err(new Error(`No compiled function found for "${reconciliationScope.name}"`));
     }
-    const selectedConfigs = optionalIntegrationId ? functionConfigs.filter((config) => config.integrationId === optionalIntegrationId) : functionConfigs;
     const functions = [];
     for (const config of selectedConfigs) {
         const { filePath, ...artifact } = config;
@@ -211,27 +282,24 @@ async function createFunctionsBundle({ fullPath, optionalIntegrationId }) {
         if (!fileBody) {
             return Err(new Error(`No function files found for "${config.name}"`));
         }
-        functions.push({ ...artifact, fileBody });
+        functions.push({ ...artifact, fileBody, source });
     }
-    return Ok({
-        reconciliationScope: optionalIntegrationId ? { kind: 'integration', integrationId: optionalIntegrationId } : { kind: 'environment' },
-        functions
-    });
+    return Ok({ reconciliationScope, functions });
 }
 /**
  * Maps NangoYamlParsed (which is a list of integrations and its function definitions) into the shape expected by the API,
  * while also loading the content of the related script files.
  * It also supports filtering by integration, sync or action name for single deploys.
  */
-async function createDeployConfirmationPackage({ parsed, fullPath, debug, version = '', optionalIntegrationId, optionalSyncName, optionalActionName }) {
+async function createLegacyPackage({ parsed, fullPath, debug, version = '', reconciliationScope, optionalSyncName, optionalActionName }) {
     printDebug('Packaging', debug);
+    const isSingleScript = Boolean(optionalSyncName || optionalActionName);
     const postData = [];
-    const onEventScriptsByProvider = optionalActionName || optionalSyncName ? undefined : []; // only load on-event scripts if we're not deploying a single sync or action
-    const hasSingleScript = Boolean(optionalSyncName || optionalActionName);
-    const deployMode = hasSingleScript ? 'single' : optionalIntegrationId ? 'integration' : 'all';
+    const onEventScriptsByProvider = isSingleScript ? undefined : []; // only load on-event scripts if we're not deploying a single sync or action
+    const integrationId = reconciliationScope.kind === 'integration' ? reconciliationScope.integrationId : undefined;
     for (const integration of parsed.integrations) {
         const { providerConfigKey, onEventScripts } = integration;
-        if (optionalIntegrationId && integration.providerConfigKey !== optionalIntegrationId) {
+        if (integrationId && integration.providerConfigKey !== integrationId) {
             continue;
         }
         if (onEventScriptsByProvider) {
@@ -322,14 +390,16 @@ async function createDeployConfirmationPackage({ parsed, fullPath, debug, versio
             }
         }
     }
-    if (postData.length <= 0) {
+    if (isSingleScript && postData.length === 0) {
         return Err(new Error('No syncs or actions to deploy'));
     }
-    return Ok({
-        flowConfigs: postData,
-        onEventScriptsByProvider,
-        deployMode
-    });
+    if (isSingleScript) {
+        return Ok(postData.map((flow) => ({
+            flowConfigs: [flow],
+            reconciliationScope: { kind: 'function', integrationId: flow.providerConfigKey, name: flow.syncName }
+        })));
+    }
+    return Ok([{ flowConfigs: postData, onEventScriptsByProvider, reconciliationScope }]);
 }
 /**
  * Load source and bundled files
@@ -433,19 +503,11 @@ async function postLegacyDeploy({ hostport, body }) {
         if ('error' in json) {
             return Err(new Error(`Error deploying:\n${json.error.message} ${chalk.gray(`(${json.error.code})`)}`));
         }
-        if (json.length === 0) {
-            return Ok(`Successfully removed the syncs/actions.`);
-        }
-        const nameAndVersions = json.map((result) => `${result.name}@v${result.version}`);
-        return Ok(`Successfully deployed the functions: \r\n${nameAndVersions
-            .map((row) => {
-            return `- ${row}`;
-        })
-            .join('\r\n')}`);
+        return Ok(json);
     }
     catch (err) {
         const errorMessage = getFetchError(err);
-        return Err(new Error(`Error deploying the functions:\n${errorMessage}`));
+        return Err(new Error(`Error deploying:\n${errorMessage}`));
     }
 }
 function formatFunctionsDeploymentError(error) {
@@ -499,21 +561,32 @@ async function deployFunctions({ hostport, body }) {
         return Err(new Error(`Error deploying functions:\n${getFetchError(err)}`));
     }
 }
-function functionsDeploymentMessage(result) {
-    const deployed = [...result.created, ...result.updated];
-    if (deployed.length === 0) {
-        return result.deleted.length > 0 ? 'Successfully removed the functions.' : 'No function changes were deployed.';
+function printDeploymentMessage(results) {
+    const deployed = results.flatMap((result) => result.deployed);
+    const deleted = results.flatMap((result) => result.deleted);
+    const messages = [];
+    if (deployed.length > 0) {
+        messages.push(`Successfully deployed: \r\n${deployed.map((func) => `- ${func.integrationId} → ${func.name}${func.version ? `@v${func.version}` : ''}`).join('\r\n')}`);
+    }
+    if (deleted.length > 0) {
+        messages.push(`Successfully removed: \r\n${deleted.map((func) => `- ${func.integrationId} → ${func.name}`).join('\r\n')}`);
+    }
+    if (messages.length > 0) {
+        console.log(chalk.green(messages.join('\r\n')));
     }
-    return `Successfully deployed the functions: \r\n${deployed.map((func) => `- ${func.integrationId} → ${func.name}`).join('\r\n')}`;
 }
-/**
- * Handle state, display plan and eventually ask for confirmation if destructive
- */
-async function handleLegacyConfirmation({ autoconfirm, allowDestructive, confirmation }) {
+function renderLegacyConfirmation(confirmation) {
     const { newSyncs, updatedSyncs, deletedSyncs, newActions, updatedActions, deletedActions, newOnEventScripts, updatedOnEventScripts, deletedOnEventScripts, deletedModels } = confirmation;
+    const scriptSummaries = [
+        { name: 'Actions', newItems: newActions, updatedItems: updatedActions, deleteItems: deletedActions },
+        { name: 'OnEvents', newItems: newOnEventScripts, updatedItems: updatedOnEventScripts, deleteItems: deletedOnEventScripts }
+    ];
+    const summaries = [{ name: 'Syncs', newItems: newSyncs, updatedItems: updatedSyncs, deleteItems: deletedSyncs }, ...scriptSummaries];
+    if (deletedModels.length === 0 &&
+        summaries.every(({ newItems, updatedItems, deleteItems }) => newItems.length + updatedItems.length + deleteItems.length === 0)) {
+        return { rows: [], requiresConfirmation: false };
+    }
     let deletedSyncsConnectionsCount = 0;
-    console.log('');
-    console.log('', chalk.underline('Nango will perform this plan:'));
     // Syncs
     if (newSyncs.length > 0 || deletedSyncs.length > 0) {
         console.log('');
@@ -544,101 +617,32 @@ async function handleLegacyConfirmation({ autoconfirm, allowDestructive, confirm
         });
         console.log(columns);
     }
-    // Actions
-    if (newActions.length > 0 || deletedActions.length > 0) {
-        console.log('');
-        console.log(shortSummaryMessage({ name: 'Actions', newItems: newActions, deleteItems: deletedActions }));
-        for (const action of newActions) {
-            console.log(` ${chalk.green('+')} ${action.providerConfigKey} → ${action.name}`);
-        }
-        for (const action of deletedActions) {
-            console.log(` ${chalk.red('-')} ${action.providerConfigKey} → ${action.name}`);
+    for (const { name, newItems, deleteItems } of scriptSummaries) {
+        if (newItems.length === 0 && deleteItems.length === 0) {
+            continue;
         }
-    }
-    // OnEvents
-    if (newOnEventScripts.length > 0 || deletedOnEventScripts.length > 0) {
         console.log('');
-        console.log(shortSummaryMessage({ name: 'OnEvents', newItems: newOnEventScripts, deleteItems: deletedOnEventScripts }));
-        for (const onEvent of newOnEventScripts) {
-            console.log(` ${chalk.green('+')} ${onEvent.providerConfigKey} → ${onEvent.name}`);
+        console.log(shortSummaryMessage({ name, newItems, deleteItems }));
+        for (const item of newItems) {
+            console.log(` ${chalk.green('+')} ${item.providerConfigKey} → ${item.name}`);
         }
-        for (const onEvent of deletedOnEventScripts) {
-            console.log(` ${chalk.red('-')} ${onEvent.providerConfigKey} → ${onEvent.name}`);
+        for (const item of deleteItems) {
+            console.log(` ${chalk.red('-')} ${item.providerConfigKey} → ${item.name}`);
         }
     }
     if (deletedModels.length > 0) {
         console.log(chalk.red(`The following models have been removed: ${deletedModels.join(', ')}. `));
         console.log(chalk.red("WARNING: Renaming a model is the equivalent of deleting the old model and creating a new one. Records from the old model won't be transferred to the new model. Consider running a full sync to transfer records."));
     }
-    if (newSyncs.length <= 0 &&
-        deletedSyncs.length <= 0 &&
-        newActions.length <= 0 &&
-        deletedActions.length <= 0 &&
-        newOnEventScripts.length <= 0 &&
-        deletedOnEventScripts.length <= 0 &&
-        deletedModels.length <= 0) {
-        console.log('');
-        console.log(chalk.gray.italic('  Only updates'));
-    }
-    console.log('');
-    console.log('', chalk.underline('Summary'));
-    const columns = columnify([
-        summaryMessageColumns({ name: 'Syncs', newItems: newSyncs, updatedItems: updatedSyncs, deleteItems: deletedSyncs }),
-        summaryMessageColumns({ name: 'Actions', newItems: newActions, updatedItems: updatedActions, deleteItems: deletedActions }),
-        summaryMessageColumns({ name: 'OnEvents', newItems: newOnEventScripts, updatedItems: updatedOnEventScripts, deleteItems: deletedOnEventScripts })
-    ], {
-        showHeaders: false,
-        minWidth: 18,
-        config: {
-            name: {
-                dataTransform: (a) => {
-                    return `\u2063\u2063${a}`;
-                }
-            }
-        }
-    });
-    console.log(columns);
-    console.log('');
-    const shouldConfirmDestructive = deletedSyncsConnectionsCount > 0 || deletedModels.length > 0;
-    if (!shouldConfirmDestructive) {
-        console.log(chalk.grey('No sync deleted with active connections, proceeding without confirmation'));
-        return Ok(true);
-    }
-    if (autoconfirm && !shouldConfirmDestructive) {
-        console.log(chalk.yellow('autoconfirm flag is on, proceeding without confirmation'));
-        return Ok(true);
-    }
-    else if (autoconfirm && shouldConfirmDestructive && allowDestructive) {
-        console.log(chalk.yellow('allowDestructive flag is on, proceeding without confirmation'));
-        return Ok(true);
-    }
-    // Can't do anything here
-    if (isCI) {
-        console.log(chalk.red(`Syncs/Actions were not deployed. Confirm the deploy by passing the --auto-confirm flag${shouldConfirmDestructive ? ' and --allow-destructive flag' : ''}. Exiting`));
-        return Err('is_ci');
-    }
-    try {
-        const wait = await promptly.confirm(`Are you sure you want to continue y/n?`);
-        if (!wait) {
-            console.log(chalk.yellow('Deployed aborted. Exiting'));
-            return Err('not_confirmed');
-        }
-    }
-    catch {
-        console.log('');
-        console.log(chalk.yellow('Deployed aborted. Exiting'));
-        return Err('not_confirmed');
-    }
-    return Ok(true);
+    return {
+        rows: summaries.map(summaryMessageColumns),
+        requiresConfirmation: deletedSyncsConnectionsCount > 0 || deletedModels.length > 0
+    };
 }
-async function handleFunctionsConfirmation({ autoconfirm, allowDestructive, confirmation }) {
+function renderFunctionsConfirmation(confirmation) {
     const { created, updated, deleted } = confirmation;
-    console.log('');
-    console.log('', chalk.underline('Nango will perform this plan:'));
     if (created.length + updated.length + deleted.length === 0) {
-        console.log('');
-        console.log(chalk.gray.italic('  No changes'));
-        return Ok(true);
+        return { rows: [], requiresConfirmation: false };
     }
     else if (created.length > 0 || deleted.length > 0) {
         console.log('');
@@ -650,32 +654,42 @@ async function handleFunctionsConfirmation({ autoconfirm, allowDestructive, conf
             console.log(` ${chalk.red('-')} ${func.integrationId} → ${func.name}`);
         }
     }
-    else if (updated.length > 0) {
+    return {
+        rows: [summaryMessageColumns({ name: 'Functions', newItems: created, updatedItems: updated, deleteItems: deleted })],
+        requiresConfirmation: deleted.length > 0
+    };
+}
+async function handleConfirmation({ autoconfirm, allowDestructive, confirmations, interactive }) {
+    console.log('');
+    console.log('', chalk.underline('Nango will perform this plan:'));
+    const summaries = confirmations.map((confirmation) => confirmation.kind === 'legacy' ? renderLegacyConfirmation(confirmation.value) : renderFunctionsConfirmation(confirmation.value));
+    const rows = summaries.flatMap((summary) => summary.rows);
+    if (rows.length > 0) {
+        console.log('');
+        console.log('', chalk.underline('Summary'));
+        console.log(columnify(rows, {
+            showHeaders: false,
+            minWidth: 18,
+            config: { name: { dataTransform: (value) => `\u2063\u2063${value}` } }
+        }));
+        console.log('');
+    }
+    else {
         console.log('');
-        console.log(chalk.gray.italic('  Only updates'));
+        console.log(chalk.gray.italic('  No changes'));
     }
-    console.log('');
-    console.log('', chalk.underline('Summary'));
-    console.log(columnify([summaryMessageColumns({ name: 'Functions', newItems: created, updatedItems: updated, deleteItems: deleted })], {
-        showHeaders: false,
-        minWidth: 18,
-        config: {
-            name: {
-                dataTransform: (value) => `\u2063\u2063${value}`
-            }
+    if (!summaries.some((summary) => summary.requiresConfirmation)) {
+        if (rows.length > 0) {
+            console.log(chalk.grey('No destructive changes, proceeding without confirmation'));
         }
-    }));
-    console.log('');
-    if (deleted.length === 0) {
-        console.log(chalk.grey('No functions deleted, proceeding without confirmation'));
         return Ok(true);
     }
     if (autoconfirm && allowDestructive) {
         console.log(chalk.yellow('allowDestructive flag is on, proceeding without confirmation'));
         return Ok(true);
     }
-    if (isCI) {
-        console.log(chalk.red('Functions were not deployed. Confirm the deploy by passing the --auto-confirm and --allow-destructive flags. Exiting'));
+    if (!interactive) {
+        console.log(chalk.red('Nothing was deployed. Confirm the deploy by passing the --auto-confirm and --allow-destructive flags. Exiting'));
         return Err('is_ci');
     }
     try {