n8n 2.46.4 → 2.47.1

package/dist/modules/promotions.ee/promotion-change.service.d.ts

@@ -1,13 +1,12 @@
 import type { PromotionChanges, PromotionChangesQueryDto, PromotionDirection, PromotionPreview, PromotionResourceDetail, PromotionResourceDetails, PromotionResourceDetailsRequestDto, PromotionResourceType } from '@n8n/api-types';
-import { Logger, ModuleRegistry } from '@n8n/backend-common';
-import { CredentialsRepository, SharedWorkflowRepository, VariablesRepository, WorkflowRepository, type User } from '@n8n/db';
-import { DataTableService } from '../../modules/data-table/data-table.service';
-import { DataTableSerializer } from '../../modules/n8n-packages/entities/data-table/data-table.serializer';
-import { TagImporter } from '../../modules/n8n-packages/entities/tag/tag-importer';
+import { Logger } from '@n8n/backend-common';
+import { SharedWorkflowRepository, WorkflowRepository, type User } from '@n8n/db';
 import { N8nPackagesService } from '../../modules/n8n-packages/n8n-packages.service';
 import { type PackageManifest } from '../../modules/n8n-packages/spec/manifest.schema';
 import { PromotionEnvironmentResolver } from './promotion-environment.resolver';
 import { PromotionReviewGateService } from './promotion-review-gate.service';
+import { ApplyPreviewService } from './apply-preview.service';
+import { LocalPackageEntities } from './local-package-entities.service';
 import { PromotionsService } from './promotions.service';
 export type DetailSide = {
     content: string | null;
@@ -16,31 +15,24 @@ export type DetailSide = {
 export declare class PromotionChangeService {
     private readonly promotionsService;
     private readonly packagesService;
+    private readonly applyPreviewService;
     private readonly workflowRepository;
     private readonly sharedWorkflowRepository;
-    private readonly variablesRepository;
-    private readonly credentialsRepository;
-    private readonly tagImporter;
-    private readonly dataTableService;
-    private readonly dataTableSerializer;
-    private readonly moduleRegistry;
+    private readonly localEntities;
     private readonly environmentResolver;
     private readonly reviewGate;
     private readonly logger;
-    constructor(promotionsService: PromotionsService, packagesService: N8nPackagesService, workflowRepository: WorkflowRepository, sharedWorkflowRepository: SharedWorkflowRepository, variablesRepository: VariablesRepository, credentialsRepository: CredentialsRepository, tagImporter: TagImporter, dataTableService: DataTableService, dataTableSerializer: DataTableSerializer, moduleRegistry: ModuleRegistry, environmentResolver: PromotionEnvironmentResolver, reviewGate: PromotionReviewGateService, logger: Logger);
+    constructor(promotionsService: PromotionsService, packagesService: N8nPackagesService, applyPreviewService: ApplyPreviewService, workflowRepository: WorkflowRepository, sharedWorkflowRepository: SharedWorkflowRepository, localEntities: LocalPackageEntities, environmentResolver: PromotionEnvironmentResolver, reviewGate: PromotionReviewGateService, logger: Logger);
     getChanges(user: User, projectId: string, direction: PromotionDirection, query: PromotionChangesQueryDto): Promise<PromotionChanges>;
     getPreview(user: User, projectId: string, direction: PromotionDirection, query: PromotionChangesQueryDto): Promise<PromotionPreview>;
+    private getApplyPreview;
+    private toApplyChanges;
     private markCrossProjectMoves;
     getDetails(user: User, projectId: string, direction: PromotionDirection, { commitSha, keys }: PromotionResourceDetailsRequestDto): Promise<PromotionResourceDetails>;
-    private compareProject;
+    private comparePromote;
     private assertCanPreview;
     private diffPackages;
-    private exportInstancePackage;
-    private readBranchDesired;
     private readBranchManifest;
-    private loadApplyDestination;
-    private loadLocalTags;
-    private loadLocalDataTables;
 }
 export declare function parsePackageManifest(raw: string | undefined): PackageManifest | null;
 export declare function toDetail({ key, type, before, after, hideVariableValues, }: {

package/dist/modules/promotions.ee/promotion-change.service.js

@@ -20,21 +20,14 @@ const permissions_1 = require("@n8n/permissions");
 const n8n_workflow_1 = require("n8n-workflow");
 const node_crypto_1 = require("node:crypto");
 const errors_1 = require("@n8n/errors");
-const data_table_service_1 = require("../../modules/data-table/data-table.service");
 const data_table_compat_1 = require("../../modules/n8n-packages/entities/data-table/data-table-compat");
-const data_table_serializer_1 = require("../../modules/n8n-packages/entities/data-table/data-table.serializer");
-const tag_importer_1 = require("../../modules/n8n-packages/entities/tag/tag-importer");
-const tag_exporter_1 = require("../../modules/n8n-packages/entities/tag/tag.exporter");
-const entity_file_format_1 = require("../../modules/n8n-packages/io/entity-file-format");
 const hashing_package_writer_1 = require("../../modules/n8n-packages/io/hashing-package-writer");
 const manifest_entry_1 = require("../../modules/n8n-packages/io/manifest-entry");
 const slug_utils_1 = require("../../modules/n8n-packages/io/slug.utils");
 const n8n_packages_service_1 = require("../../modules/n8n-packages/n8n-packages.service");
-const n8n_packages_types_1 = require("../../modules/n8n-packages/n8n-packages.types");
 const constants_1 = require("../../modules/n8n-packages/spec/constants");
 const manifest_schema_1 = require("../../modules/n8n-packages/spec/manifest.schema");
 const requirement_consumers_1 = require("../../modules/n8n-packages/spec/requirement-consumers");
-const base_branch_files_1 = require("./base-branch-files");
 const branch_placement_1 = require("./branch-placement");
 const cross_project_moves_1 = require("./cross-project-moves");
 const constants_2 = require("./constants");
@@ -42,6 +35,9 @@ const diff_package_files_1 = require("./diff-package-files");
 const promotion_preview_1 = require("./promotion-preview");
 const promotion_environment_resolver_1 = require("./promotion-environment.resolver");
 const promotion_review_gate_service_1 = require("./promotion-review-gate.service");
+const apply_preview_service_1 = require("./apply-preview.service");
+const instance_package_1 = require("./instance-package");
+const local_package_entities_service_1 = require("./local-package-entities.service");
 const promotions_service_1 = require("./promotions.service");
 const promotions_git_utils_1 = require("./promotions-git.utils");
 const DEPENDENCY_COLLECTIONS = {
@@ -52,76 +48,66 @@ const DEPENDENCY_COLLECTIONS = {
     workflows: 'workflows',
     nodeTypes: null,
 };
-const GIT_SCOPES = {
-    promote: 'gitConnection:push',
-    apply: 'gitConnection:pull',
+const PROMOTION_SCOPES = {
+    promote: 'promotions:promote',
+    apply: 'promotions:apply',
 };
 let PromotionChangeService = class PromotionChangeService {
-    constructor(promotionsService, packagesService, workflowRepository, sharedWorkflowRepository, variablesRepository, credentialsRepository, tagImporter, dataTableService, dataTableSerializer, moduleRegistry, environmentResolver, reviewGate, logger) {
+    constructor(promotionsService, packagesService, applyPreviewService, workflowRepository, sharedWorkflowRepository, localEntities, environmentResolver, reviewGate, logger) {
         this.promotionsService = promotionsService;
         this.packagesService = packagesService;
+        this.applyPreviewService = applyPreviewService;
         this.workflowRepository = workflowRepository;
         this.sharedWorkflowRepository = sharedWorkflowRepository;
-        this.variablesRepository = variablesRepository;
-        this.credentialsRepository = credentialsRepository;
-        this.tagImporter = tagImporter;
-        this.dataTableService = dataTableService;
-        this.dataTableSerializer = dataTableSerializer;
-        this.moduleRegistry = moduleRegistry;
+        this.localEntities = localEntities;
         this.environmentResolver = environmentResolver;
         this.reviewGate = reviewGate;
         this.logger = logger;
         this.logger = this.logger.scoped('promotions');
     }
     async getChanges(user, projectId, direction, query) {
-        return toChanges(await this.compareProject(user, projectId, direction), query);
+        if (direction === 'apply') {
+            const { commitSha, source, changes } = await this.getApplyPreview(user, projectId);
+            return { commitSha, source, changes: applyQuery(changes, query) };
+        }
+        return toChanges(await this.comparePromote(user, projectId), query);
     }
     async getPreview(user, projectId, direction, query) {
-        if (direction === 'promote') {
-            this.assertCanPreview(user, direction);
-            const input = await this.environmentResolver.resolveForProject(projectId, direction);
-            const blocker = input.config.direction === 'promote' && input.config.settings.createBranchOnPromotion
-                ? await this.reviewGate.findPromoteBlocker(projectId, input.environmentId)
-                : null;
-            if (blocker) {
-                return {
-                    commitSha: null,
-                    source: {
-                        environmentId: input.environmentId,
-                        branchName: (0, promotions_git_utils_1.checkoutBranchName)(input.config),
-                    },
-                    changes: [],
-                    resources: [],
-                    dependencies: [],
-                    blocker,
-                };
-            }
+        if (direction === 'apply') {
+            const preview = await this.getApplyPreview(user, projectId);
+            return { ...preview, changes: applyQuery(preview.changes, query) };
         }
-        const comparison = await this.compareProject(user, projectId, direction);
-        const { branch, instance, archiveState } = comparison;
-        const promoteBase = direction === 'promote' && (branch.hasManifest || branch.files.length > 0)
-            ? await this.readBranchManifest(branch)
-            : null;
-        const branchSide = {
-            manifest: comparison.branchManifest ??
-                (promoteBase && branch.files.length > 0
-                    ? (0, promotion_preview_1.scopeManifestToProject)(promoteBase, projectId)
-                    : null),
-            blobByPath: blobsByPath(branch.files),
-        };
-        const instanceSide = {
-            manifest: instance.manifest,
-            blobByPath: blobsByPath(instance.files),
-        };
-        const destination = direction === 'apply'
-            ? await this.loadApplyDestination(branchSide.manifest, instance.manifest, comparison.destinationVariables)
+        this.assertCanPreview(user, direction);
+        const input = await this.environmentResolver.resolveForProject(projectId, direction);
+        const blocker = input.config.direction === 'promote' && input.config.settings.createBranchOnPromotion
+            ? await this.reviewGate.findPromoteBlocker(projectId, input.environmentId)
             : null;
+        if (blocker) {
+            return {
+                commitSha: null,
+                source: {
+                    environmentId: input.environmentId,
+                    branchName: (0, promotions_git_utils_1.checkoutBranchName)(input.config),
+                },
+                changes: [],
+                resources: [],
+                dependencies: [],
+                blocker,
+            };
+        }
+        const comparison = await this.comparePromote(user, projectId);
+        const { branch, instance } = comparison;
+        const promoteBase = branch.hasManifest || branch.files.length > 0 ? await this.readBranchManifest(branch) : null;
         const { resources, dependencies } = (0, promotion_preview_1.buildPreview)({
-            operation: { direction, destination },
+            operation: { direction, planned: null },
             projectIds: [projectId],
-            base: direction === 'promote' ? branchSide : instanceSide,
-            desired: direction === 'promote' ? instanceSide : branchSide,
-            isArchived: (path) => archiveState.get(path) ?? false,
+            base: {
+                manifest: promoteBase && branch.files.length > 0
+                    ? (0, promotion_preview_1.scopeManifestToProject)(promoteBase, projectId)
+                    : null,
+                blobByPath: blobsByPath(branch.files),
+            },
+            desired: { manifest: instance.manifest, blobByPath: blobsByPath(instance.files) },
         });
         return {
             ...toChanges(comparison, query),
@@ -131,6 +117,64 @@ let PromotionChangeService = class PromotionChangeService {
             dependencies,
         };
     }
+    async getApplyPreview(user, projectId) {
+        this.assertCanPreview(user, 'apply');
+        const branch = await this.promotionsService.readBranchPackage(projectId, 'apply');
+        if (branch.commitSha === null) {
+            throw new errors_1.BadRequestError('The remote branch has no exported package to import. Promote to it first.');
+        }
+        const [files, instance] = await Promise.all([
+            this.promotionsService.readApplyPackageAtCommit(projectId, branch.commitSha),
+            (0, instance_package_1.exportInstancePackage)(this.packagesService, user, projectId),
+        ]);
+        const preview = await this.applyPreviewService.build({ user, projectId, files, instance });
+        return {
+            commitSha: branch.commitSha,
+            source: { environmentId: branch.environmentId, branchName: branch.branchName },
+            changes: await this.toApplyChanges(preview),
+            ...preview,
+        };
+    }
+    async toApplyChanges({ resources, dependencies, }) {
+        const changed = new Set(resources.filter(({ change }) => change !== 'unchanged').map(({ key }) => key));
+        const usesChangedDependency = new Set(dependencies
+            .filter(({ included, resourceKey }) => included && changed.has(resourceKey))
+            .map(({ workflowKey }) => workflowKey));
+        const dependencyCounts = new Map();
+        for (const { workflowKey } of dependencies) {
+            dependencyCounts.set(workflowKey, (dependencyCounts.get(workflowKey) ?? 0) + 1);
+        }
+        const byKey = new Map(resources.map((resource) => [resource.key, resource]));
+        const isMovedFile = (resource) => {
+            const { change, previousName, previousParentKey, parentKey } = resource;
+            if (change === 'modified' &&
+                (previousName !== undefined || previousParentKey !== undefined)) {
+                return true;
+            }
+            const parent = parentKey ? byKey.get(parentKey) : undefined;
+            return parent?.type === 'folder' && isMovedFile(parent);
+        };
+        const workflows = resources.filter((resource) => resource.type === 'workflow' &&
+            resource.selectable &&
+            (changed.has(resource.key) ||
+                usesChangedDependency.has(resource.key) ||
+                isMovedFile(resource)));
+        const metadata = new Map((await this.workflowRepository.findByIds(workflows.map(({ id }) => id), { fields: ['name', 'updatedAt', 'versionCounter'] })).map((workflow) => [workflow.id, workflow]));
+        return workflows.map((resource) => {
+            const { id, key, name } = resource;
+            const workflow = metadata.get(id);
+            return {
+                id,
+                name,
+                type: 'workflow',
+                status: applyStatus(resource, isMovedFile(resource)),
+                version: workflow?.versionCounter ?? null,
+                updatedAt: workflow?.updatedAt.toISOString() ?? null,
+                updatedBy: null,
+                dependencyCount: dependencyCounts.get(key) ?? 0,
+            };
+        });
+    }
     async markCrossProjectMoves(projectId, resources, branchManifest) {
         const deletedIds = resources
             .filter(({ type, change }) => type === 'workflow' && change === 'deleted')
@@ -158,14 +202,14 @@ let PromotionChangeService = class PromotionChangeService {
     }
     async getDetails(user, projectId, direction, { commitSha, keys }) {
         this.assertCanPreview(user, direction);
-        const requestedIds = new Set(keys.map((key) => key.slice(key.lastIndexOf(':') + 1)));
+        const requestedIds = new Set(keys.map((key) => key.slice(key.indexOf(':') + 1)));
         const readBranch = async (paths) => commitSha === null
             ? new Map()
             : await this.promotionsService.readBranchFilesAtCommit(projectId, direction, commitSha, paths);
         const manifestPath = `${constants_2.PACKAGE_SUBFOLDER}/${constants_1.MANIFEST_FILE}`;
         const [branchFiles, instance] = await Promise.all([
             readBranch([manifestPath]),
-            this.exportInstancePackage(user, projectId, {
+            (0, instance_package_1.exportInstancePackage)(this.packagesService, user, projectId, {
                 keepContent: (path) => requestedIds.has(entityIdOfPath(path)) ||
                     path.includes(`/${manifest_entry_1.PACKAGE_ENTITY_LAYOUT.variables.directory}/`),
             }),
@@ -176,13 +220,13 @@ let PromotionChangeService = class PromotionChangeService {
         const missingKeys = keys.filter((key) => !branchIndex.has(key) && !instanceIndex.has(key));
         const branchContents = await readBranch(keys.flatMap((key) => branchIndex.get(key)?.path ?? []));
         const localTables = direction === 'apply'
-            ? await this.loadLocalDataTables(keys.flatMap((key) => {
+            ? await this.localEntities.dataTables(keys.flatMap((key) => {
                 const resource = branchIndex.get(key);
                 return resource?.type === 'dataTable' && !instanceIndex.has(key) ? [resource.id] : [];
             }))
             : new Map();
         const localTags = direction === 'apply'
-            ? await this.loadLocalTags(keys.flatMap((key) => {
+            ? await this.localEntities.tags(keys.flatMap((key) => {
                 const resource = branchIndex.get(key);
                 return resource?.type === 'tag' && !instanceIndex.has(key) ? [resource] : [];
             }))
@@ -220,41 +264,22 @@ let PromotionChangeService = class PromotionChangeService {
         });
         return { details, missingKeys };
     }
-    async compareProject(user, projectId, direction) {
-        this.assertCanPreview(user, direction);
-        const branch = await this.promotionsService.readBranchPackage(projectId, direction);
-        const branchDesired = direction === 'apply' ? await this.readBranchDesired(branch, projectId) : null;
-        const [instance, destinationVariables] = await Promise.all([
-            this.exportInstancePackage(user, projectId),
-            branchDesired === null
-                ? null
-                : this.variablesRepository.findKeysInProjectsOrGlobal(branchDesired.manifest.requirements?.variables?.map(({ name }) => name) ?? [], [projectId]),
-        ]);
-        const { base, desired } = branchDesired === null
-            ? { base: branch.files, desired: instance }
-            : { base: instance.files, desired: branchDesired };
-        const diff = this.diffPackages({ projectId, direction, base, desired, destinationVariables });
-        const archiveState = direction === 'promote'
-            ? instance.archiveState
-            : await readBranchArchiveState(branch, diff.archiveCheckPaths);
-        const metadata = await this.workflowRepository.findByIds([...diff.changedIds].filter((id) => direction === 'apply' || diff.desiredWorkflows.has(id)), { fields: ['name', 'updatedAt', 'versionCounter'] });
-        const rows = buildPromotableResources({ ...diff, base, archiveState, metadata });
-        return {
-            branch,
-            branchManifest: branchDesired?.manifest ?? null,
-            instance,
-            destinationVariables,
-            archiveState,
-            rows,
-        };
+    async comparePromote(user, projectId) {
+        this.assertCanPreview(user, 'promote');
+        const branch = await this.promotionsService.readBranchPackage(projectId, 'promote');
+        const instance = await (0, instance_package_1.exportInstancePackage)(this.packagesService, user, projectId);
+        const diff = this.diffPackages({ projectId, base: branch.files, desired: instance });
+        const metadata = await this.workflowRepository.findByIds([...diff.changedIds].filter((id) => diff.desiredWorkflows.has(id)), { fields: ['name', 'updatedAt', 'versionCounter'] });
+        const rows = buildPromotableResources({ ...diff, base: branch.files, metadata });
+        return { branch, instance, rows };
     }
     assertCanPreview(user, direction) {
-        if (!(0, permissions_1.hasGlobalScope)(user, GIT_SCOPES[direction])) {
-            const operation = direction === 'promote' ? 'push' : 'pull';
-            throw new errors_1.ForbiddenError(`Change preview requires the promotion ${operation} permission. Ask an administrator for access.`);
+        const scope = PROMOTION_SCOPES[direction];
+        if (!(0, permissions_1.hasGlobalScope)(user, scope)) {
+            throw new errors_1.ForbiddenError(`Change preview requires the ${scope} scope. Ask an administrator for access.`);
         }
     }
-    diffPackages({ projectId, direction, base, desired, destinationVariables, }) {
+    diffPackages({ projectId, base, desired, }) {
         const previewId = (0, node_crypto_1.randomUUID)();
         const { manifest } = desired;
         const changes = (0, diff_package_files_1.diffPackageFiles)(base, desired.files);
@@ -279,7 +304,7 @@ let PromotionChangeService = class PromotionChangeService {
             this.logger.debug('Promotion file change', {
                 previewId,
                 projectId,
-                direction,
+                direction: 'promote',
                 ...fileChange,
             });
         }
@@ -288,7 +313,6 @@ let PromotionChangeService = class PromotionChangeService {
             manifest,
             changedPaths,
             projectId,
-            destinationVariables,
         });
         for (const workflowId of affectedWorkflowIds) {
             changedIds.add(workflowId);
@@ -298,67 +322,13 @@ let PromotionChangeService = class PromotionChangeService {
         this.logger.debug('Promotion change preview', {
             previewId,
             projectId,
-            direction,
+            direction: 'promote',
             baseFileCount: base.length,
             desiredFileCount: desired.files.length,
             fileChangeCount: changes.length,
             workflowIds: [...changedIds],
         });
-        const baseWorkflowIds = new Set(base.filter(({ type }) => type === 'workflow').map(({ entityId }) => entityId));
-        const desiredWorkflowPaths = new Map(desired.files
-            .filter(({ type }) => type === 'workflow')
-            .map(({ entityId, path }) => [entityId, path]));
-        const archiveCheckPaths = [...changedIds].flatMap((id) => {
-            const path = desiredWorkflowPaths.get(id);
-            return path !== undefined && desiredWorkflows.has(id) && baseWorkflowIds.has(id)
-                ? [path]
-                : [];
-        });
-        return {
-            changedIds,
-            renamedIds,
-            modifiedIds,
-            dependencyCounts,
-            desiredWorkflows,
-            desiredWorkflowPaths,
-            archiveCheckPaths,
-        };
-    }
-    async exportInstancePackage(user, projectId, { keepContent } = {}) {
-        const writer = new hashing_package_writer_1.HashingPackageWriter();
-        const archiveState = new Map();
-        const contents = new Map();
-        const { manifest } = await this.packagesService.exportPackageToWriter({
-            user,
-            projectIds: [projectId],
-            includeAgents: false,
-            includeArchivedWorkflows: true,
-            includeTags: true,
-            includeVariableValues: true,
-            versionPolicy: n8n_packages_types_1.ExportVersionPolicy.Latest,
-            dependencyPolicy: n8n_packages_types_1.ExportDependencyPolicy.ReferenceOnly,
-        }, {
-            writeDirectory: (path) => writer.writeDirectory(path),
-            writeFile(path, content) {
-                writer.writeFile(path, content);
-                const packagePath = `${constants_2.PACKAGE_SUBFOLDER}/${path}`;
-                if (path.endsWith(`/${manifest_entry_1.PACKAGE_ENTITY_LAYOUT.workflows.fileName}`)) {
-                    const workflow = (0, n8n_workflow_1.jsonParse)(String(content));
-                    archiveState.set(packagePath, workflow.isArchived);
-                }
-                if (keepContent?.(packagePath))
-                    contents.set(packagePath, String(content));
-            },
-        });
-        const files = (0, base_branch_files_1.parsePackageFiles)(writer.finalize().map((file) => ({
-            ...file,
-            path: `${constants_2.PACKAGE_SUBFOLDER}/${file.path}`,
-        })), { exportRoot: constants_2.PACKAGE_SUBFOLDER, projectId });
-        return { files, manifest, archiveState, contents };
-    }
-    async readBranchDesired(branch, projectId) {
-        const manifest = await this.readBranchManifest(branch);
-        return { files: branch.files, manifest: (0, promotion_preview_1.scopeManifestToProject)(manifest, projectId) };
+        return { changedIds, renamedIds, modifiedIds, dependencyCounts, desiredWorkflows };
     }
     async readBranchManifest(branch) {
         const manifestPath = `${constants_2.PACKAGE_SUBFOLDER}/${constants_1.MANIFEST_FILE}`;
@@ -368,47 +338,11 @@ let PromotionChangeService = class PromotionChangeService {
         }
         return manifest;
     }
-    async loadApplyDestination(branchManifest, instanceManifest, variables) {
-        const requirements = branchManifest?.requirements;
-        const exportedTableIds = new Set(instanceManifest.dataTables?.map(({ id }) => id));
-        const [credentials, tags, dataTables] = await Promise.all([
-            this.credentialsRepository.findNamesByIds(requirements?.credentials?.map(({ id }) => id) ?? []),
-            this.loadLocalTags(requirements?.tags ?? []),
-            this.loadLocalDataTables((requirements?.dataTables ?? [])
-                .map(({ id }) => id)
-                .filter((id) => !exportedTableIds.has(id))),
-        ]);
-        return {
-            credentialNames: new Map(credentials.map(({ id, name }) => [id, name])),
-            tags,
-            variableKeys: new Set((variables ?? []).map(({ key, projectId }) => (0, promotion_preview_1.variableResourceKey)(key, projectId))),
-            dataTables,
-        };
-    }
-    async loadLocalTags(branchTags) {
-        const local = await this.tagImporter.findLocalTags(branchTags);
-        return new Map(branchTags.flatMap(({ id, name }) => {
-            const tag = local.byId.get(id) ?? local.byName.get(name.trim());
-            if (!tag)
-                return [];
-            const content = (0, entity_file_format_1.formatEntityFile)((0, tag_exporter_1.serializeTag)(tag));
-            return [[id, { id: tag.id, name: tag.name, content, blobSha: (0, hashing_package_writer_1.gitBlobSha)(content) }]];
-        }));
-    }
-    async loadLocalDataTables(ids) {
-        if (ids.length === 0 || !this.moduleRegistry.isActive('data-table'))
-            return new Map();
-        const tables = await this.dataTableService.findDataTablesByIds(ids);
-        return new Map(tables.map((table) => {
-            const content = (0, entity_file_format_1.formatEntityFile)(this.dataTableSerializer.serialize(table));
-            return [table.id, { content, blobSha: (0, hashing_package_writer_1.gitBlobSha)(content) }];
-        }));
-    }
 };
 exports.PromotionChangeService = PromotionChangeService;
 exports.PromotionChangeService = PromotionChangeService = __decorate([
     (0, di_1.Service)(),
-    __metadata("design:paramtypes", [promotions_service_1.PromotionsService, n8n_packages_service_1.N8nPackagesService, db_1.WorkflowRepository, db_1.SharedWorkflowRepository, db_1.VariablesRepository, db_1.CredentialsRepository, tag_importer_1.TagImporter, data_table_service_1.DataTableService, data_table_serializer_1.DataTableSerializer, backend_common_1.ModuleRegistry, promotion_environment_resolver_1.PromotionEnvironmentResolver, promotion_review_gate_service_1.PromotionReviewGateService, backend_common_1.Logger])
+    __metadata("design:paramtypes", [promotions_service_1.PromotionsService, n8n_packages_service_1.N8nPackagesService, apply_preview_service_1.ApplyPreviewService, db_1.WorkflowRepository, db_1.SharedWorkflowRepository, local_package_entities_service_1.LocalPackageEntities, promotion_environment_resolver_1.PromotionEnvironmentResolver, promotion_review_gate_service_1.PromotionReviewGateService, backend_common_1.Logger])
 ], PromotionChangeService);
 function parseBranchJson(raw) {
     try {
@@ -431,8 +365,7 @@ function blobsByPath(files) {
 }
 function entityIdOfPath(path) {
     const segments = path.split('/');
-    const directory = segments[segments.length - 2] ?? '';
-    return directory.slice(directory.lastIndexOf('-') + 1);
+    return (0, manifest_entry_1.entityIdOfSegment)(segments[segments.length - 2] ?? '');
 }
 function toChanges({ branch, rows }, query) {
     return {
@@ -484,12 +417,18 @@ function toDetail({ key, type, before, after, hideVariableValues, }) {
         }
     }
 }
-async function readBranchArchiveState(branch, paths) {
-    const files = await branch.readFiles(paths);
-    return new Map([...files].map(([path, raw]) => [
-        path,
-        parseBranchJson(raw)?.isArchived ?? false,
-    ]));
+function applyStatus({ change, revision }, isMovedFile) {
+    switch (change) {
+        case 'added':
+            return 'new';
+        case 'archived':
+        case 'deleted':
+            return change;
+        default:
+            if (!isMovedFile)
+                return 'modified';
+            return revision.before === revision.after ? 'renamed' : 'renamed-and-modified';
+    }
 }
 function applyQuery(changes, query) {
     const search = query.search?.toLowerCase();
@@ -500,9 +439,7 @@ function applyQuery(changes, query) {
         return (query.order === 'desc' ? -comparison : comparison) || a.id.localeCompare(b.id);
     });
 }
-function calculateDependencyImpact({ base, manifest, changedPaths, projectId, destinationVariables, }) {
-    const destinationVariableKeys = destinationVariables &&
-        new Set(destinationVariables.map(({ key, projectId: owner }) => variableKey(key, owner === null ? 'global' : 'project')));
+function calculateDependencyImpact({ base, manifest, changedPaths, projectId, }) {
     const baseDependencies = new Map();
     for (const file of base) {
         const key = JSON.stringify([
@@ -536,13 +473,7 @@ function calculateDependencyImpact({ base, manifest, changedPaths, projectId, de
                 : undefined;
             let dependencyChanged = false;
             if (collection === 'variables') {
-                dependencyChanged = variableChanged({
-                    name: key,
-                    entry,
-                    baseFiles: group,
-                    projectId,
-                    destinationVariableKeys,
-                });
+                dependencyChanged = filesScope(group, projectId) !== entryScope(entry);
             }
             else if (collection !== 'workflows') {
                 dependencyChanged =
@@ -558,15 +489,6 @@ function calculateDependencyImpact({ base, manifest, changedPaths, projectId, de
     }
     return { affectedWorkflowIds, dependencyCounts };
 }
-function variableChanged({ name, entry, baseFiles, projectId, destinationVariableKeys, }) {
-    const desiredScope = entryScope(entry);
-    if (destinationVariableKeys === null)
-        return filesScope(baseFiles, projectId) !== desiredScope;
-    const exists = (scope) => destinationVariableKeys.has(variableKey(name, scope));
-    if (desiredScope === undefined)
-        return exists('project') || exists('global');
-    return !exists(desiredScope);
-}
 function entryScope(entry) {
     if (!entry)
         return undefined;
@@ -581,22 +503,18 @@ function filesScope(files, projectId) {
         return 'global';
     return undefined;
 }
-function variableKey(name, scope) {
-    return JSON.stringify([scope, name]);
-}
-function buildPromotableResources({ base, desiredWorkflows, desiredWorkflowPaths, archiveState, changedIds, renamedIds, modifiedIds, metadata, dependencyCounts, }) {
+function buildPromotableResources({ base, desiredWorkflows, changedIds, renamedIds, modifiedIds, metadata, dependencyCounts, }) {
     const metadataById = new Map(metadata.map((workflow) => [workflow.id, workflow]));
     const baseWorkflowSlugs = new Map(base.filter(({ type }) => type === 'workflow').map(({ entityId, slug }) => [entityId, slug]));
     return [...changedIds].map((id) => {
         const entry = desiredWorkflows.get(id);
         const workflow = metadataById.get(id);
-        const path = desiredWorkflowPaths.get(id);
         let status = 'modified';
         if (!entry)
             status = 'deleted';
         else if (!baseWorkflowSlugs.has(id))
             status = 'new';
-        else if (path !== undefined && archiveState.get(path))
+        else if (entry.isArchived)
             status = 'archived';
         else if (renamedIds.has(id)) {
             status = modifiedIds.has(id) ? 'renamed-and-modified' : 'renamed';