n8n 2.46.4 → 2.47.1

package/dist/modules/promotions.ee/promotions.service.js

@@ -15,6 +15,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PromotionsService = void 0;
 const api_types_1 = require("@n8n/api-types");
 const backend_common_1 = require("@n8n/backend-common");
+const backend_services_1 = require("@n8n/backend-services");
 const db_1 = require("@n8n/db");
 const di_1 = require("@n8n/di");
 const is_record_1 = require("@n8n/utils/is-record");
@@ -23,7 +24,6 @@ const node_path_1 = __importDefault(require("node:path"));
 const n8n_workflow_1 = require("n8n-workflow");
 const zod_1 = require("zod");
 const errors_1 = require("@n8n/errors");
-const directory_package_reader_1 = require("../../modules/n8n-packages/io/directory/directory-package-reader");
 const package_directory_inventory_reader_1 = require("../../modules/n8n-packages/io/directory/package-directory-inventory-reader");
 const n8n_packages_config_1 = require("../../modules/n8n-packages/n8n-packages.config");
 const n8n_packages_service_1 = require("../../modules/n8n-packages/n8n-packages.service");
@@ -37,24 +37,29 @@ const branch_placement_1 = require("./branch-placement");
 const cross_project_moves_1 = require("./cross-project-moves");
 const constants_2 = require("./constants");
 const promotion_commit_message_1 = require("./promotion-commit-message");
-const promotion_binding_preflight_service_1 = require("./promotion-binding-preflight.service");
+const apply_preview_service_1 = require("./apply-preview.service");
+const git_commit_package_reader_1 = require("./git-commit-package-reader");
+const instance_package_1 = require("./instance-package");
+const package_references_1 = require("./package-references");
 const promotion_environment_resolver_1 = require("./promotion-environment.resolver");
 const promotion_providers_service_1 = require("./promotion-providers.service");
 const promotion_run_repository_1 = require("./database/repositories/promotion-run.repository");
 const promotion_reviews_service_1 = require("./promotion-reviews.service");
+const promotion_telemetry_1 = require("./promotion-telemetry");
 const promotion_working_directory_service_1 = require("./promotion-working-directory.service");
 const promotions_git_service_1 = require("./promotions-git.service");
 const promotions_selective_push_error_1 = require("./promotions-selective-push.error");
 const promotions_git_utils_1 = require("./promotions-git.utils");
 const working_copy_updater_1 = require("./working-copy-updater");
+const NO_APPLY_PACKAGE_MESSAGE = 'The remote branch has no exported package to import. Promote to it first.';
 function isConfirmableConflict(code) {
     return code === 'destructive-change' || code === 'project-deletion';
 }
 const IMPORT_POLICY = {
     projectConflictPolicy: n8n_packages_types_1.ProjectConflictPolicy.Overwrite,
-    workflowConflictPolicy: n8n_packages_types_1.WorkflowConflictPolicy.NewVersion,
-    workflowIdPolicy: n8n_packages_types_1.WorkflowIdPolicy.Source,
-    workflowPublishingPolicy: n8n_packages_types_1.WorkflowPublishingPolicy.MatchSource,
+    conflictPolicy: n8n_packages_types_1.ImportConflictPolicy.NewVersion,
+    idPolicy: n8n_packages_types_1.WorkflowIdPolicy.Source,
+    publishingPolicy: n8n_packages_types_1.WorkflowPublishingPolicy.PreserveTargetState,
     missingNodeTypeMode: n8n_packages_types_1.MissingNodeTypeMode.Fail,
     credentialMatchingMode: 'id-only',
     credentialMissingMode: 'must-preexist',
@@ -70,7 +75,7 @@ const IMPORT_POLICY = {
     tagConflictPolicy: n8n_packages_types_1.TagConflictPolicy.Rename,
 };
 let PromotionsService = class PromotionsService {
-    constructor(resolver, providersService, workingDirectory, workingCopy, gitService, projectRepository, sharedWorkflowRepository, projectService, folderService, n8nPackagesService, bindingPreflight, inventoryReader, packageImportConfig, runRepository, reviewsService, logger) {
+    constructor(resolver, providersService, workingDirectory, workingCopy, gitService, projectRepository, sharedWorkflowRepository, projectService, folderService, n8nPackagesService, applyPreviewService, inventoryReader, packageImportConfig, runRepository, reviewsService, eventService, logger) {
         this.resolver = resolver;
         this.providersService = providersService;
         this.workingDirectory = workingDirectory;
@@ -81,16 +86,27 @@ let PromotionsService = class PromotionsService {
         this.projectService = projectService;
         this.folderService = folderService;
         this.n8nPackagesService = n8nPackagesService;
-        this.bindingPreflight = bindingPreflight;
+        this.applyPreviewService = applyPreviewService;
         this.inventoryReader = inventoryReader;
         this.packageImportConfig = packageImportConfig;
         this.runRepository = runRepository;
         this.reviewsService = reviewsService;
+        this.eventService = eventService;
         this.logger = logger;
         this.logger = this.logger.scoped('promotions');
     }
-    async clone(environmentId) {
+    async clone(environmentId, actor) {
         const input = await this.resolver.resolveForEnvironment(environmentId);
+        return await (0, promotion_telemetry_1.observePromotion)(async () => await this.cloneResolved(input), (observed) => this.eventService.emit('promotion-environment-connected', {
+            user: actor,
+            environmentId: input.environmentId,
+            direction: input.config.direction,
+            outcome: observed.ok ? 'success' : 'failed',
+            ...(!observed.ok && { failureKind: observed.failureKind }),
+            durationMs: observed.durationMs,
+        }));
+    }
+    async cloneResolved(input) {
         const branchName = (0, promotions_git_utils_1.checkoutBranchName)(input.config);
         await this.gitService.clone({
             remoteUrl: (0, promotions_git_utils_1.repositoryUrl)(input),
@@ -113,6 +129,9 @@ let PromotionsService = class PromotionsService {
     }
     async promote(environmentId, actor, request) {
         const input = await this.resolver.resolveForEnvironment(environmentId, 'promote');
+        return await this.trackPromote(input, actor, {}, async () => await this.promoteResolved(input, actor, request));
+    }
+    async promoteResolved(input, actor, request) {
         this.assertInstanceScope(input, 'Promote');
         await this.assertCheckoutReady(input, 'promoting');
         const branchName = (0, promotions_git_utils_1.checkoutBranchName)(input.config);
@@ -124,24 +143,18 @@ let PromotionsService = class PromotionsService {
         await this.assertNoProjectMovesSinceBranch(input, branchName, credentials, target?.baseCommitSha);
         const projectIds = await this.projectRepository.findTeamProjectIds();
         this.logger.info('Exporting projects for a promotion', {
-            environmentId,
+            environmentId: input.environmentId,
             projectCount: projectIds.length,
         });
         await (0, promises_1.mkdir)(repositoryFolder, { recursive: true });
         const stagingFolder = await (0, promises_1.mkdtemp)(node_path_1.default.join(repositoryFolder, `.${constants_2.PACKAGE_SUBFOLDER}-`));
         let pushed;
         try {
-            const exportResult = await this.n8nPackagesService.exportPackageToDirectory({
+            const exportResult = await this.n8nPackagesService.exportPackageToDirectory((0, instance_package_1.instancePromotionExportRequest)({
                 user: actor,
                 projectIds,
-                includeAgents: false,
-                includeVariableValues: true,
                 canExportVariableValues: request.canExportVariableValues,
-                includeTags: true,
-                includeArchivedWorkflows: true,
-                dependencyPolicy: n8n_packages_types_1.ExportDependencyPolicy.Fail,
-                versionPolicy: n8n_packages_types_1.ExportVersionPolicy.Latest,
-            }, { targetDir: stagingFolder });
+            }), { targetDir: stagingFolder });
             await (0, promises_1.rm)(packageFolder, { recursive: true, force: true });
             await (0, promises_1.rename)(stagingFolder, packageFolder);
             if (targetBranchName) {
@@ -370,11 +383,40 @@ let PromotionsService = class PromotionsService {
             throw new errors_1.BadRequestError('workflowIds contains duplicates');
         }
         const input = await this.resolver.resolveForProject(projectId, 'promote');
-        const { selection, movedTo } = await this.classifySelection(projectId, request.workflowIds);
-        return await this.promoteSelectionResolved(input, actor, {
-            commitMessage: request.commitMessage,
-            canExportVariableValues: request.canExportVariableValues,
-        }, selection, movedTo);
+        return await this.trackPromote(input, actor, { projectId, selectedWorkflowCount: request.workflowIds.length }, async () => {
+            const { selection, movedTo } = await this.classifySelection(projectId, request.workflowIds);
+            return await this.promoteSelectionResolved(input, actor, {
+                commitMessage: request.commitMessage,
+                canExportVariableValues: request.canExportVariableValues,
+            }, selection, movedTo);
+        });
+    }
+    async trackPromote(input, actor, { projectId, selectedWorkflowCount }, run) {
+        return await (0, promotion_telemetry_1.observePromotion)(run, (observed) => this.eventService.emit('promotion-promoted', {
+            user: actor,
+            environmentId: input.environmentId,
+            scope: projectId ? 'project' : 'instance',
+            projectId,
+            selectedWorkflowCount,
+            durationMs: observed.durationMs,
+            ...(observed.ok
+                ? {
+                    outcome: observed.result.warnings?.length ? 'success_with_warnings' : 'success',
+                    counts: observed.result.counts,
+                    openedReview: !!observed.result.review,
+                }
+                : { outcome: 'failed', failureKind: observed.failureKind }),
+        }));
+    }
+    async trackApply(input, actor, { projectId }, run) {
+        return await (0, promotion_telemetry_1.observePromotion)(run, (observed) => this.eventService.emit('promotion-applied', {
+            user: actor,
+            environmentId: input.environmentId,
+            scope: projectId ? 'project' : 'instance',
+            projectId,
+            durationMs: observed.durationMs,
+            ...appliedOutcome(observed),
+        }));
     }
     async classifySelection(projectId, workflowIds) {
         const ownerProjects = await this.sharedWorkflowRepository.findOwnerProjectsByWorkflowIds(workflowIds);
@@ -404,10 +446,17 @@ let PromotionsService = class PromotionsService {
         return await this.applyFromSource(environmentId, actor, request.expectedSource, request.confirmDestructiveChanges === true);
     }
     async applyProjectSelection(projectId, actor, request) {
-        return await this.applySelectionFromSource(projectId, actor, request.workflowIds, request.expectedSource);
+        return await this.applySelectionFromSource(projectId, actor, request.workflowIds, {
+            expectedSource: request.expectedSource,
+            expectedPreviewRevision: request.expectedPreviewRevision,
+        });
     }
     async continueApplyProjectSelection(projectId, actor, request) {
-        return await this.applySelectionFromSource(projectId, actor, request.workflowIds, request.expectedSource, request.confirmDestructiveChanges === true);
+        return await this.applySelectionFromSource(projectId, actor, request.workflowIds, {
+            expectedSource: request.expectedSource,
+            expectedPreviewRevision: request.expectedPreviewRevision,
+            confirmDestructiveChanges: request.confirmDestructiveChanges === true,
+        });
     }
     async classifyApplySelection(inventory, projectId, workflowIds, movedWorkflowIds) {
         const branchWorkflowIds = new Set(inventory.workflows
@@ -434,130 +483,57 @@ let PromotionsService = class PromotionsService {
         }
         return { selectedProjectId: projectId, selectedWorkflowIds, deletedWorkflowIds };
     }
-    async findCrossProjectMoves(inventory, projectId) {
-        const [owners, folders, existingProjects] = await Promise.all([
-            this.sharedWorkflowRepository.findOwnerProjectsByWorkflowIds(inventory.workflows.map(({ id }) => id)),
-            this.folderService.getFoldersByIds((0, cross_project_moves_1.foldersInScope)(inventory.folders, projectId).map(({ folder }) => folder.id)),
-            this.projectRepository.findTypesByIds(inventory.projects.map(({ id }) => id)),
-        ]);
-        return (0, cross_project_moves_1.crossProjectMoves)({
-            inventory,
-            owners,
-            folderHomes: new Map(folders.map(({ id, homeProject }) => [id, homeProject])),
-            existingProjectIds: new Set(existingProjects.map(({ id }) => id)),
-            projectId,
-        });
-    }
-    async checkApplyBlockers(projectId, commitSha) {
+    async readApplyPackageAtCommit(projectId, commitSha) {
         const input = await this.resolver.resolveForProject(projectId, 'apply');
-        await this.assertCheckoutReady(input, 'checking Apply blockers');
-        const branchName = (0, promotions_git_utils_1.checkoutBranchName)(input.config);
-        const files = await this.gitService.readTreeAtCommit({
+        await this.assertCheckoutReady(input, 'reading the Apply branch');
+        return await this.gitService.readTreeAtCommit({
             remoteUrl: (0, promotions_git_utils_1.repositoryUrl)(input),
             credentials: await this.credentialsFor(input),
             paths: this.workingDirectory.paths(input.environmentId),
-            branchName,
+            branchName: (0, promotions_git_utils_1.checkoutBranchName)(input.config),
             environmentId: input.environmentId,
             commitSha,
             directory: constants_2.PACKAGE_SUBFOLDER,
             limits: this.packageImportConfig,
         });
-        if (files.size === 0) {
-            throw new errors_1.BadRequestError('The remote branch has no exported package to import. Promote to it first.');
-        }
-        const inventory = await this.inventoryReader.read({
-            listEntries: async () => [...files.keys()],
-            readFile: async (entryPath) => {
-                const content = files.get(entryPath);
-                if (!content)
-                    throw new errors_1.BadRequestError(`Package does not contain entry: ${entryPath}`);
-                return content;
-            },
-        });
-        const moves = await this.findCrossProjectMoves(inventory, projectId);
-        const preflight = await this.bindingPreflight.checkInventory({
-            inventory,
-            selection: {
-                selectedProjectId: projectId,
-                selectedWorkflowIds: inventory.workflows
-                    .filter((workflow) => workflow.projectId === projectId)
-                    .map(({ id }) => id),
-            },
-        });
-        return {
-            environmentId: input.environmentId,
-            git: { commitSha, branchName },
-            preflight,
-            movedWorkflows: moves.workflows,
-            movedFolders: moves.folders,
-        };
     }
-    async applySelectionFromSource(projectId, actor, workflowIds, expectedSource, confirmDestructiveChanges = false) {
+    async applySelectionFromSource(projectId, actor, workflowIds, { expectedSource, expectedPreviewRevision, confirmDestructiveChanges = false, }) {
         const input = await this.resolver.resolveForProject(projectId, 'apply');
+        return await this.trackApply(input, actor, { projectId }, async () => await this.applySelectionResolved(input, projectId, actor, workflowIds, expectedSource, confirmDestructiveChanges, expectedPreviewRevision));
+    }
+    async applySelectionResolved(input, projectId, actor, workflowIds, expectedSource, confirmDestructiveChanges, expectedPreviewRevision) {
         await this.assertCheckoutReady(input, 'applying');
-        const branchName = (0, promotions_git_utils_1.checkoutBranchName)(input.config);
-        const paths = this.workingDirectory.paths(input.environmentId);
-        const { commitSha } = await this.gitService.refreshCheckout({
-            remoteUrl: (0, promotions_git_utils_1.repositoryUrl)(input),
-            credentials: await this.credentialsFor(input),
-            paths,
-            branchName,
-            environmentId: input.environmentId,
-        });
-        const identity = {
-            environmentId: input.environmentId,
-            git: { commitSha, branchName },
-        };
-        if (expectedSource &&
-            (expectedSource.environmentId !== input.environmentId ||
-                expectedSource.branchName !== branchName ||
-                expectedSource.commitSha !== commitSha)) {
-            this.logger.info('Apply stopped because the source changed', {
-                status: 'source-changed',
-                ...identity,
+        const tip = await this.readApplyTip(input, expectedSource);
+        if (tip.status === 'source-changed')
+            return tip;
+        const { identity, files } = tip;
+        if (expectedPreviewRevision !== undefined) {
+            const preview = await this.applyPreviewService.build({
+                user: actor,
+                projectId,
+                files,
+                instance: await (0, instance_package_1.exportInstancePackage)(this.n8nPackagesService, actor, projectId),
             });
-            return { status: 'source-changed', ...identity };
-        }
-        const packageFolder = node_path_1.default.join(paths.repositoryFolder, constants_2.PACKAGE_SUBFOLDER);
-        if (!(await isDirectory(packageFolder))) {
-            throw new errors_1.BadRequestError('The remote branch has no exported package to import. Promote to it first.');
+            if (preview.revision !== expectedPreviewRevision) {
+                this.logger.info('Apply stopped because the preview changed', {
+                    status: 'preview-changed',
+                    ...identity,
+                });
+                return { status: 'preview-changed', ...identity };
+            }
         }
-        const reader = new directory_package_reader_1.DirectoryPackageReader(packageFolder, this.packageImportConfig);
+        const reader = new git_commit_package_reader_1.GitCommitPackageReader(files);
         const inventory = await this.inventoryReader.read(reader);
-        const moves = await this.findCrossProjectMoves(inventory, projectId);
+        const moves = await this.applyPreviewService.findCrossProjectMoves(inventory, projectId);
         const selection = await this.classifyApplySelection(inventory, projectId, workflowIds, new Set(moves.workflows.map(({ id }) => id)));
+        const plan = await this.n8nPackagesService.planPackageSelection((0, apply_preview_service_1.applySelectionRequest)(actor, confirmDestructiveChanges), reader, selection, 'enforce');
         const requested = new Set(workflowIds);
-        const blocking = {
+        const check = blockingCheck(this.applyPreviewService.check(plan, inventory, selection, {
             ...moves,
             workflows: moves.workflows.filter(({ id }) => requested.has(id)),
-        };
-        if (blocking.workflows.length > 0 || blocking.folders.length > 0) {
-            throw new errors_1.ConflictError((0, cross_project_moves_1.describeCrossProjectMoves)(blocking));
-        }
-        const preflight = await this.bindingPreflight.checkInventory({
-            inventory,
-            selection: {
-                selectedProjectId: projectId,
-                selectedWorkflowIds: selection.selectedWorkflowIds,
-            },
-        });
-        const blockingConflicts = confirmDestructiveChanges
-            ? preflight.conflicts.filter(({ code }) => !isConfirmableConflict(code))
-            : preflight.conflicts;
-        if (preflight.missingBindings.length > 0 ||
-            preflight.accessRequirements.length > 0 ||
-            blockingConflicts.length > 0) {
-            this.logger.info('Apply blocked by unresolved bindings', {
-                status: 'blocked',
-                ...identity,
-                bindingCounts: {
-                    missingBindings: preflight.missingBindings.length,
-                    accessRequirements: preflight.accessRequirements.length,
-                    conflicts: preflight.conflicts.length,
-                    warnings: preflight.warnings.length,
-                },
-            });
-            return { status: 'blocked', ...identity, preflight };
+        }));
+        if (this.isBlocked(check, confirmDestructiveChanges, identity)) {
+            return { status: 'blocked', ...identity, check };
         }
         this.logger.info('Importing a package selection', {
             ...identity,
@@ -566,16 +542,7 @@ let PromotionsService = class PromotionsService {
             deletedCount: selection.deletedWorkflowIds?.length ?? 0,
             confirmDestructiveChanges,
         });
-        const result = await this.n8nPackagesService.importPackageSelectionFromDirectory({
-            user: actor,
-            overwriteDeletionPolicy: n8n_packages_types_1.OverwriteDeletionPolicy.HardDelete,
-            dataTableSchemaConflictPolicy: confirmDestructiveChanges
-                ? n8n_packages_types_1.DataTableSchemaConflictPolicy.Overwrite
-                : IMPORT_POLICY.dataTableSchemaConflictPolicy,
-            tagConflictPolicy: IMPORT_POLICY.tagConflictPolicy,
-            credentialConflictPolicy: IMPORT_POLICY.credentialConflictPolicy,
-            layoutConflictPolicy: n8n_packages_types_1.LayoutConflictPolicy.FollowPackage,
-        }, { sourceDir: packageFolder }, selection);
+        const result = await this.n8nPackagesService.applyPackagePlan(plan);
         return {
             status: 'applied',
             ...identity,
@@ -583,85 +550,142 @@ let PromotionsService = class PromotionsService {
                 importResult: result,
                 projectReconciliation: { deletedProjectIds: [] },
             }),
-            warnings: preflight.warnings,
+            warnings: check.warnings,
         };
     }
     async applyFromSource(environmentId, actor, expectedSource, confirmDestructiveChanges = false) {
         const input = await this.resolver.resolveForEnvironment(environmentId, 'apply');
+        return await this.trackApply(input, actor, {}, async () => await this.applyResolved(input, actor, expectedSource, confirmDestructiveChanges));
+    }
+    async applyResolved(input, actor, expectedSource, confirmDestructiveChanges) {
         this.assertInstanceScope(input, 'Apply');
         await this.assertCheckoutReady(input, 'applying');
-        const branchName = (0, promotions_git_utils_1.checkoutBranchName)(input.config);
-        const paths = this.workingDirectory.paths(input.environmentId);
-        const { commitSha } = await this.gitService.refreshCheckout({
-            remoteUrl: (0, promotions_git_utils_1.repositoryUrl)(input),
-            credentials: await this.credentialsFor(input),
-            paths,
-            branchName,
+        const tip = await this.readApplyTip(input, expectedSource);
+        if (tip.status === 'source-changed')
+            return tip;
+        const { identity, files } = tip;
+        const reader = new git_commit_package_reader_1.GitCommitPackageReader(files);
+        const inventory = await this.inventoryReader.read(reader);
+        const moves = await this.applyPreviewService.findCrossProjectMoves(inventory);
+        const plan = await this.n8nPackagesService.planPackage({ ...IMPORT_POLICY, ...(0, apply_preview_service_1.applySelectionRequest)(actor, confirmDestructiveChanges) }, reader, 'enforce');
+        const check = blockingCheck(this.applyPreviewService.check(plan, inventory, undefined, moves), await this.projectDeletions(inventory));
+        if (this.isBlocked(check, confirmDestructiveChanges, identity)) {
+            return { status: 'blocked', ...identity, check };
+        }
+        this.logger.info('Importing a package', {
             environmentId: input.environmentId,
+            confirmDestructiveChanges,
         });
-        const identity = {
-            environmentId: input.environmentId,
-            git: { commitSha, branchName },
+        const result = await this.n8nPackagesService.applyPackagePlan(plan);
+        const importedProjectIds = result.projects.map((project) => project.localId);
+        const confirmedProjectIds = check.conflicts.flatMap((conflict) => conflict.code === 'project-deletion' ? conflict.project.id : []);
+        const projectReconciliation = await this.reconcileTeamProjects(actor, importedProjectIds, confirmedProjectIds);
+        return {
+            status: 'applied',
+            ...identity,
+            counts: this.toApplyCounts({ importResult: result, projectReconciliation }),
+            warnings: check.warnings,
         };
+    }
+    async listMissingProjects(environmentId) {
+        const input = await this.resolver.resolveForEnvironment(environmentId, 'apply');
+        this.assertInstanceScope(input, 'Listing missing projects');
+        await this.assertCheckoutReady(input, 'reading its package');
+        const head = await this.fetchApplyHead(input);
+        const files = head && (await this.readApplyTree(head));
+        if (!head || !files?.size)
+            return { environmentId, git: null, data: [] };
+        const { projects } = await this.inventoryReader.read(new git_commit_package_reader_1.GitCommitPackageReader(files));
+        const existing = await this.projectRepository.findTypesByIds(projects.map(({ id }) => id));
+        const existingIds = new Set(existing.map(({ id }) => id));
+        const data = projects
+            .filter(({ id }) => !existingIds.has(id))
+            .map(({ path: _path, ...project }) => project)
+            .sort((a, b) => a.name.localeCompare(b.name) || a.id.localeCompare(b.id));
+        return { environmentId, git: head.identity.git, data };
+    }
+    async readApplyTip(input, expectedSource) {
+        const head = await this.fetchApplyHead(input);
+        if (head === null)
+            throw new errors_1.BadRequestError(NO_APPLY_PACKAGE_MESSAGE);
+        const { identity } = head;
         if (expectedSource &&
             (expectedSource.environmentId !== input.environmentId ||
-                expectedSource.branchName !== branchName ||
-                expectedSource.commitSha !== commitSha)) {
+                expectedSource.branchName !== identity.git.branchName ||
+                expectedSource.commitSha !== identity.git.commitSha)) {
             this.logger.info('Apply stopped because the source changed', {
                 status: 'source-changed',
                 ...identity,
             });
             return { status: 'source-changed', ...identity };
         }
-        const packageFolder = node_path_1.default.join(paths.repositoryFolder, constants_2.PACKAGE_SUBFOLDER);
-        if (!(await isDirectory(packageFolder))) {
-            throw new errors_1.BadRequestError('The remote branch has no exported package to import. Promote to it first.');
-        }
-        const inventory = await this.inventoryReader.read(new directory_package_reader_1.DirectoryPackageReader(packageFolder, this.packageImportConfig));
-        const moves = await this.findCrossProjectMoves(inventory);
-        if (moves.workflows.length > 0 || moves.folders.length > 0) {
-            throw new errors_1.ConflictError((0, cross_project_moves_1.describeCrossProjectMoves)(moves));
-        }
-        const preflight = await this.bindingPreflight.checkInventory({ inventory });
+        const files = await this.readApplyTree(head);
+        if (files.size === 0)
+            throw new errors_1.BadRequestError(NO_APPLY_PACKAGE_MESSAGE);
+        return { status: 'current', identity, files };
+    }
+    async fetchApplyHead(input) {
+        const branchName = (0, promotions_git_utils_1.checkoutBranchName)(input.config);
+        const operation = {
+            remoteUrl: (0, promotions_git_utils_1.repositoryUrl)(input),
+            credentials: await this.credentialsFor(input),
+            paths: this.workingDirectory.paths(input.environmentId),
+            branchName,
+            environmentId: input.environmentId,
+        };
+        const { commitSha } = await this.gitService.listBranchTree({
+            ...operation,
+            pathspecs: [`${constants_2.PACKAGE_SUBFOLDER}/${constants_1.MANIFEST_FILE}`],
+        });
+        if (commitSha === null)
+            return null;
+        return {
+            operation,
+            identity: { environmentId: input.environmentId, git: { commitSha, branchName } },
+        };
+    }
+    async readApplyTree({ operation, identity }) {
+        return await this.gitService.readTreeAtCommit({
+            ...operation,
+            commitSha: identity.git.commitSha,
+            directory: constants_2.PACKAGE_SUBFOLDER,
+            limits: this.packageImportConfig,
+        });
+    }
+    isBlocked(check, confirmDestructiveChanges, identity) {
         const blockingConflicts = confirmDestructiveChanges
-            ? preflight.conflicts.filter(({ code }) => !isConfirmableConflict(code))
-            : preflight.conflicts;
-        if (preflight.missingBindings.length > 0 ||
-            preflight.accessRequirements.length > 0 ||
-            blockingConflicts.length > 0) {
-            this.logger.info('Apply blocked by unresolved bindings', {
+            ? check.conflicts.filter(({ code }) => !isConfirmableConflict(code))
+            : check.conflicts;
+        const blocked = check.missingBindings.length > 0 ||
+            check.accessRequirements.length > 0 ||
+            blockingConflicts.length > 0;
+        if (blocked) {
+            this.logger.info('Apply blocked', {
                 status: 'blocked',
                 ...identity,
                 bindingCounts: {
-                    missingBindings: preflight.missingBindings.length,
-                    accessRequirements: preflight.accessRequirements.length,
-                    conflicts: preflight.conflicts.length,
-                    warnings: preflight.warnings.length,
+                    missingBindings: check.missingBindings.length,
+                    accessRequirements: check.accessRequirements.length,
+                    conflicts: check.conflicts.length,
+                    warnings: check.warnings.length,
                 },
             });
-            return { status: 'blocked', ...identity, preflight };
         }
-        this.logger.info('Importing a package', {
-            environmentId,
-            confirmDestructiveChanges,
-        });
-        const result = await this.n8nPackagesService.importPackageFromDirectory({
-            user: actor,
-            ...IMPORT_POLICY,
-            layoutConflictPolicy: n8n_packages_types_1.LayoutConflictPolicy.FollowPackage,
-            dataTableSchemaConflictPolicy: confirmDestructiveChanges
-                ? n8n_packages_types_1.DataTableSchemaConflictPolicy.Overwrite
-                : IMPORT_POLICY.dataTableSchemaConflictPolicy,
-        }, { sourceDir: packageFolder });
-        const importedProjectIds = result.projects.map((project) => project.localId);
-        const confirmedProjectIds = preflight.conflicts.flatMap((conflict) => conflict.code === 'project-deletion' ? conflict.project.id : []);
-        const projectReconciliation = await this.reconcileTeamProjects(actor, importedProjectIds, confirmedProjectIds);
-        return {
-            status: 'applied',
-            ...identity,
-            counts: this.toApplyCounts({ importResult: result, projectReconciliation }),
-            warnings: preflight.warnings,
-        };
+        return blocked;
+    }
+    async projectDeletions(inventory) {
+        const packageProjectIds = new Set(inventory.projects.map(({ id }) => id));
+        const deletedIds = (await this.projectRepository.findTeamProjectIds()).filter((id) => !packageProjectIds.has(id));
+        if (deletedIds.length === 0)
+            return [];
+        const projects = await this.projectRepository.findTeamProjectInfoByIds(deletedIds);
+        return projects
+            .sort((a, b) => (0, package_references_1.compare)(a.name, b.name) || (0, package_references_1.compare)(a.id, b.id))
+            .map(({ id, name }) => ({
+            kind: 'project',
+            code: 'project-deletion',
+            project: { id, name },
+        }));
     }
     async readBranchPackage(projectId, direction) {
         const input = await this.resolver.resolveForProject(projectId, direction);
@@ -743,18 +767,24 @@ let PromotionsService = class PromotionsService {
         });
     }
     async prepareTargetBranch(input, branchName, credentials) {
-        if (input.config.direction !== 'promote' || !input.config.settings.createBranchOnPromotion) {
+        if (input.config.direction !== 'promote')
             return undefined;
-        }
-        const targetBranchName = (0, promotions_git_utils_1.buildPromotionBranchName)(new Date());
-        await this.gitService.validateBranchName(targetBranchName);
-        const { commitSha } = await this.gitService.prepareCheckoutForPromotion({
+        const checkout = {
             remoteUrl: (0, promotions_git_utils_1.repositoryUrl)(input),
             credentials,
             paths: this.workingDirectory.paths(input.environmentId),
             branchName,
             environmentId: input.environmentId,
-        });
+        };
+        if (!input.config.settings.createBranchOnPromotion) {
+            if (!(await this.gitService.hasRemoteBranch(checkout)))
+                return undefined;
+            const { commitSha } = await this.gitService.prepareCheckoutForPromotion(checkout);
+            return { baseCommitSha: commitSha };
+        }
+        const targetBranchName = (0, promotions_git_utils_1.buildPromotionBranchName)(new Date());
+        await this.gitService.validateBranchName(targetBranchName);
+        const { commitSha } = await this.gitService.prepareCheckoutForPromotion(checkout);
         return { targetBranchName, baseCommitSha: commitSha };
     }
     async assertNoProjectMovesSinceBranch(input, branchName, credentials, baseCommitSha) {
@@ -949,7 +979,7 @@ let PromotionsService = class PromotionsService {
 exports.PromotionsService = PromotionsService;
 exports.PromotionsService = PromotionsService = __decorate([
     (0, di_1.Service)(),
-    __metadata("design:paramtypes", [promotion_environment_resolver_1.PromotionEnvironmentResolver, promotion_providers_service_1.PromotionProvidersService, promotion_working_directory_service_1.PromotionWorkingDirectoryService, working_copy_updater_1.WorkingCopyUpdater, promotions_git_service_1.PromotionsGitService, db_1.ProjectRepository, db_1.SharedWorkflowRepository, project_service_ee_1.ProjectService, folder_service_1.FolderService, n8n_packages_service_1.N8nPackagesService, promotion_binding_preflight_service_1.PromotionBindingPreflightService, package_directory_inventory_reader_1.PackageDirectoryInventoryReader, n8n_packages_config_1.PackageImportConfig, promotion_run_repository_1.PromotionRunRepository, promotion_reviews_service_1.PromotionReviewsService, backend_common_1.Logger])
+    __metadata("design:paramtypes", [promotion_environment_resolver_1.PromotionEnvironmentResolver, promotion_providers_service_1.PromotionProvidersService, promotion_working_directory_service_1.PromotionWorkingDirectoryService, working_copy_updater_1.WorkingCopyUpdater, promotions_git_service_1.PromotionsGitService, db_1.ProjectRepository, db_1.SharedWorkflowRepository, project_service_ee_1.ProjectService, folder_service_1.FolderService, n8n_packages_service_1.N8nPackagesService, apply_preview_service_1.ApplyPreviewService, package_directory_inventory_reader_1.PackageDirectoryInventoryReader, n8n_packages_config_1.PackageImportConfig, promotion_run_repository_1.PromotionRunRepository, promotion_reviews_service_1.PromotionReviewsService, backend_services_1.EventService, backend_common_1.Logger])
 ], PromotionsService);
 async function pathExists(target) {
     try {
@@ -962,13 +992,22 @@ async function pathExists(target) {
         throw error;
     }
 }
-async function isDirectory(folder) {
-    try {
-        return (await (0, promises_1.stat)(folder)).isDirectory();
-    }
-    catch {
-        return false;
-    }
+function appliedOutcome(observed) {
+    if (!observed.ok)
+        return { outcome: 'failed', failureKind: observed.failureKind };
+    const { result } = observed;
+    if (result.status === 'blocked')
+        return { outcome: 'blocked' };
+    if (result.status === 'source-changed')
+        return { outcome: 'source_changed' };
+    if (result.status === 'preview-changed')
+        return { outcome: 'preview_changed' };
+    const { workflows } = result.counts;
+    return {
+        outcome: 'applied',
+        workflowsChanged: workflows.created + workflows.updated + workflows.archived + workflows.deleted,
+        workflowsFailedToPublish: workflows.publishing.failed,
+    };
 }
 const BRANCH_MANIFEST_PATH = `${constants_2.PACKAGE_SUBFOLDER}/${constants_1.MANIFEST_FILE}`;
 function describeWorkflowsMovedToPersonalProjects(moved) {
@@ -1012,4 +1051,19 @@ function readBranchPlacements(raw, manifestPath) {
         }),
     };
 }
+function blockingCheck({ movedWorkflows, movedFolders, ...check }, otherConflicts = []) {
+    return {
+        ...check,
+        conflicts: [
+            ...check.conflicts,
+            ...movedWorkflows.map((move) => ({
+                kind: 'workflow',
+                code: 'moved',
+                ...move,
+            })),
+            ...movedFolders.map((move) => ({ kind: 'folder', code: 'moved', ...move })),
+            ...otherConflicts,
+        ],
+    };
+}
 //# sourceMappingURL=promotions.service.js.map