n8n 2.45.4 → 2.46.0

package/dist/modules/promotions.ee/git-hosts/gitlab-merge-request.types.d.ts

@@ -0,0 +1,87 @@
+import { z } from 'zod';
+export declare const mergeRequestSchema: z.ZodObject<{
+    iid: z.ZodNumber;
+    project_id: z.ZodNumber;
+    web_url: z.ZodEffects<z.ZodString, string, string>;
+    title: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    state: z.ZodEnum<["opened", "locked", "merged", "closed"]>;
+    source_branch: z.ZodString;
+    target_branch: z.ZodString;
+    sha: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    has_conflicts: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    merged_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    closed_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    detailed_merge_status: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    author: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        name: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+    }, {
+        name: string;
+    }>>>;
+    diff_refs: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        base_sha: z.ZodNullable<z.ZodString>;
+        head_sha: z.ZodNullable<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        base_sha: string | null;
+        head_sha: string | null;
+    }, {
+        base_sha: string | null;
+        head_sha: string | null;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    iid: number;
+    project_id: number;
+    web_url: string;
+    title: string;
+    description: string | null;
+    state: "closed" | "locked" | "merged" | "opened";
+    source_branch: string;
+    target_branch: string;
+    sha?: string | null | undefined;
+    has_conflicts: boolean;
+    merged_at?: string | null | undefined;
+    closed_at?: string | null | undefined;
+    detailed_merge_status?: string | null | undefined;
+    author?: {
+        name: string;
+    } | null | undefined;
+    diff_refs?: {
+        base_sha: string | null;
+        head_sha: string | null;
+    } | null | undefined;
+}, {
+    iid: number;
+    project_id: number;
+    web_url: string;
+    title: string;
+    description: string | null;
+    state: "closed" | "locked" | "merged" | "opened";
+    source_branch: string;
+    target_branch: string;
+    sha?: string | null | undefined;
+    has_conflicts?: boolean | undefined;
+    merged_at?: string | null | undefined;
+    closed_at?: string | null | undefined;
+    detailed_merge_status?: string | null | undefined;
+    author?: {
+        name: string;
+    } | null | undefined;
+    diff_refs?: {
+        base_sha: string | null;
+        head_sha: string | null;
+    } | null | undefined;
+}>;
+export type GitLabMergeRequest = z.infer<typeof mergeRequestSchema>;
+export type MergeRequestRef = Readonly<{
+    projectId: number;
+    iid: number;
+}>;
+export type MergeRequestInput = {
+    projectPath: string;
+    sourceBranch: string;
+    targetBranch: string;
+    title: string;
+    description: string;
+};

package/dist/modules/promotions.ee/git-hosts/gitlab-merge-request.types.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeRequestSchema = void 0;
+const zod_1 = require("zod");
+exports.mergeRequestSchema = zod_1.z.object({
+    iid: zod_1.z.number().int(),
+    project_id: zod_1.z.number().int(),
+    web_url: zod_1.z.string().refine((value) => {
+        try {
+            const { protocol } = new URL(value);
+            return protocol === 'http:' || protocol === 'https:';
+        }
+        catch {
+            return false;
+        }
+    }),
+    title: zod_1.z.string(),
+    description: zod_1.z.string().nullable(),
+    state: zod_1.z.enum(['opened', 'locked', 'merged', 'closed']),
+    source_branch: zod_1.z.string(),
+    target_branch: zod_1.z.string(),
+    sha: zod_1.z.string().nullable().optional(),
+    has_conflicts: zod_1.z.boolean().optional().default(false),
+    merged_at: zod_1.z.string().nullable().optional(),
+    closed_at: zod_1.z.string().nullable().optional(),
+    detailed_merge_status: zod_1.z.string().nullable().optional(),
+    author: zod_1.z.object({ name: zod_1.z.string() }).nullable().optional(),
+    diff_refs: zod_1.z
+        .object({ base_sha: zod_1.z.string().nullable(), head_sha: zod_1.z.string().nullable() })
+        .nullable()
+        .optional(),
+});
+//# sourceMappingURL=gitlab-merge-request.types.js.map

package/dist/modules/promotions.ee/git-hosts/gitlab-merge-request.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gitlab-merge-request.types.js","sourceRoot":"","sources":["../../../../src/modules/promotions.ee/git-hosts/gitlab-merge-request.types.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AAEX,QAAA,kBAAkB,GAAG,OAAC,CAAC,MAAM,CAAC;IAC1C,GAAG,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE;IACrB,UAAU,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE;IAC5B,OAAO,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE;QACpC,IAAI,CAAC;YACJ,MAAM,EAAE,QAAQ,EAAE,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,CAAC;YACpC,OAAO,QAAQ,KAAK,OAAO,IAAI,QAAQ,KAAK,QAAQ,CAAC;QACtD,CAAC;QAAC,MAAM,CAAC;YACR,OAAO,KAAK,CAAC;QACd,CAAC;IACF,CAAC,CAAC;IACF,KAAK,EAAE,OAAC,CAAC,MAAM,EAAE;IACjB,WAAW,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAClC,KAAK,EAAE,OAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;IACvD,aAAa,EAAE,OAAC,CAAC,MAAM,EAAE;IACzB,aAAa,EAAE,OAAC,CAAC,MAAM,EAAE;IAEzB,GAAG,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;IACrC,aAAa,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC;IACpD,SAAS,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;IAC3C,SAAS,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;IAC3C,qBAAqB,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;IACvD,MAAM,EAAE,OAAC,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,OAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;IAC5D,SAAS,EAAE,OAAC;SACV,MAAM,CAAC,EAAE,QAAQ,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,EAAE,QAAQ,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,EAAE,CAAC;SAC5E,QAAQ,EAAE;SACV,QAAQ,EAAE;CACZ,CAAC,CAAC"}

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

@@ -1,20 +1,52 @@
-import type { PromotionChanges, PromotionChangesQueryDto, PromotionDirection } from '@n8n/api-types';
-import { Logger } from '@n8n/backend-common';
-import { VariablesRepository, WorkflowRepository, type User } from '@n8n/db';
+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 { 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 { PromotionsService } from './promotions.service';
+export type DetailSide = {
+    content: string | null;
+    blobSha: string | null;
+};
 export declare class PromotionChangeService {
     private readonly promotionsService;
     private readonly packagesService;
     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 environmentResolver;
+    private readonly reviewGate;
     private readonly logger;
-    constructor(promotionsService: PromotionsService, packagesService: N8nPackagesService, workflowRepository: WorkflowRepository, variablesRepository: VariablesRepository, logger: 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);
     getChanges(user: User, projectId: string, direction: PromotionDirection, query: PromotionChangesQueryDto): Promise<PromotionChanges>;
+    getPreview(user: User, projectId: string, direction: PromotionDirection, query: PromotionChangesQueryDto): Promise<PromotionPreview>;
+    private markCrossProjectMoves;
+    getDetails(user: User, projectId: string, direction: PromotionDirection, { commitSha, keys }: PromotionResourceDetailsRequestDto): Promise<PromotionResourceDetails>;
+    private compareProject;
     private assertCanPreview;
     private diffPackages;
     private exportInstancePackage;
     private readBranchDesired;
+    private readBranchManifest;
+    private loadApplyDestination;
+    private loadLocalTags;
+    private loadLocalDataTables;
 }
-export declare function scopeManifestToProject(manifest: PackageManifest, projectId: string): PackageManifest;
+export declare function parsePackageManifest(raw: string | undefined): PackageManifest | null;
+export declare function toDetail({ key, type, before, after, hideVariableValues, }: {
+    key: string;
+    type: PromotionResourceType;
+    before: DetailSide;
+    after: DetailSide;
+    hideVariableValues: boolean;
+}): PromotionResourceDetail;

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

@@ -10,7 +10,9 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PromotionChangeService = void 0;
-exports.scopeManifestToProject = scopeManifestToProject;
+exports.parsePackageManifest = parsePackageManifest;
+exports.toDetail = toDetail;
+const api_types_1 = require("@n8n/api-types");
 const backend_common_1 = require("@n8n/backend-common");
 const db_1 = require("@n8n/db");
 const di_1 = require("@n8n/di");
@@ -18,6 +20,12 @@ 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");
@@ -27,9 +35,15 @@ 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");
 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 promotions_service_1 = require("./promotions.service");
+const promotions_git_utils_1 = require("./promotions-git.utils");
 const DEPENDENCY_COLLECTIONS = {
     credentials: 'credentials',
     dataTables: 'dataTables',
@@ -43,15 +57,170 @@ const GIT_SCOPES = {
     apply: 'gitConnection:pull',
 };
 let PromotionChangeService = class PromotionChangeService {
-    constructor(promotionsService, packagesService, workflowRepository, variablesRepository, logger) {
+    constructor(promotionsService, packagesService, workflowRepository, sharedWorkflowRepository, variablesRepository, credentialsRepository, tagImporter, dataTableService, dataTableSerializer, moduleRegistry, environmentResolver, reviewGate, logger) {
         this.promotionsService = promotionsService;
         this.packagesService = packagesService;
         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.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);
+    }
+    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,
+                };
+            }
+        }
+        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)
+            : null;
+        const { resources, dependencies } = (0, promotion_preview_1.buildPreview)({
+            operation: { direction, destination },
+            projectIds: [projectId],
+            base: direction === 'promote' ? branchSide : instanceSide,
+            desired: direction === 'promote' ? instanceSide : branchSide,
+            isArchived: (path) => archiveState.get(path) ?? false,
+        });
+        return {
+            ...toChanges(comparison, query),
+            resources: promoteBase
+                ? await this.markCrossProjectMoves(projectId, resources, promoteBase)
+                : resources,
+            dependencies,
+        };
+    }
+    async markCrossProjectMoves(projectId, resources, branchManifest) {
+        const deletedIds = resources
+            .filter(({ type, change }) => type === 'workflow' && change === 'deleted')
+            .map(({ id }) => id);
+        const owners = deletedIds.length > 0
+            ? await this.sharedWorkflowRepository.findOwnerProjectsByWorkflowIds(deletedIds)
+            : new Map();
+        const branchTargets = new Map((branchManifest.workflows ?? []).map(({ id, target }) => [id, target]));
+        const elsewhere = (project) => project && project.id !== projectId ? project : undefined;
+        const branchProjectOf = (id) => {
+            const target = branchTargets.get(id);
+            return target === undefined ? undefined : (0, branch_placement_1.projectHolding)(branchManifest.projects, target);
+        };
+        return resources.map((resource) => {
+            if (resource.type !== 'workflow')
+                return resource;
+            const owner = resource.change === 'deleted' ? elsewhere(owners.get(resource.id)) : undefined;
+            if (owner)
+                return { ...resource, movedToProject: (0, cross_project_moves_1.toInstanceProject)(owner) };
+            const branchProject = resource.change === 'added' ? elsewhere(branchProjectOf(resource.id)) : undefined;
+            return branchProject
+                ? { ...resource, movedFromProject: { id: branchProject.id, name: branchProject.name } }
+                : resource;
+        });
+    }
+    async getDetails(user, projectId, direction, { commitSha, keys }) {
+        this.assertCanPreview(user, direction);
+        const requestedIds = new Set(keys.map((key) => key.slice(key.lastIndexOf(':') + 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, {
+                keepContent: (path) => requestedIds.has(entityIdOfPath(path)) ||
+                    path.includes(`/${manifest_entry_1.PACKAGE_ENTITY_LAYOUT.variables.directory}/`),
+            }),
+        ]);
+        const branchManifest = parseBranchManifest(branchFiles.get(manifestPath), projectId);
+        const branchIndex = (0, promotion_preview_1.indexSide)({ manifest: branchManifest, blobByPath: new Map() }, projectId);
+        const instanceIndex = (0, promotion_preview_1.indexSide)({ manifest: instance.manifest, blobByPath: blobsByPath(instance.files) }, projectId);
+        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) => {
+                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) => {
+                const resource = branchIndex.get(key);
+                return resource?.type === 'tag' && !instanceIndex.has(key) ? [resource] : [];
+            }))
+            : new Map();
+        const canSeeVariableValues = (0, permissions_1.hasGlobalScope)(user, 'variable:list');
+        const details = keys.flatMap((key) => {
+            const fromBranch = branchIndex.get(key);
+            const fromInstance = instanceIndex.get(key);
+            const resource = fromInstance ?? fromBranch;
+            if (!resource)
+                return [];
+            const branchContent = fromBranch && branchContents.get(fromBranch.path);
+            const localCopy = fromBranch && (fromBranch.type === 'tag' ? localTags : localTables).get(fromBranch.id);
+            const branchSide = branchContent === undefined
+                ? { content: null, blobSha: null }
+                : { content: branchContent, blobSha: (0, hashing_package_writer_1.gitBlobSha)(branchContent) };
+            const instanceSide = fromInstance
+                ? {
+                    content: instance.contents.get(fromInstance.path) ?? null,
+                    blobSha: fromInstance.blobSha,
+                }
+                : localCopy
+                    ? { content: localCopy.content, blobSha: localCopy.blobSha }
+                    : { content: null, blobSha: null };
+            const [before, after] = direction === 'promote' ? [branchSide, instanceSide] : [instanceSide, branchSide];
+            return [
+                toDetail({
+                    key,
+                    type: resource.type,
+                    before,
+                    after,
+                    hideVariableValues: resource.type === 'variable' && !canSeeVariableValues,
+                }),
+            ];
+        });
+        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;
@@ -71,9 +240,12 @@ let PromotionChangeService = class PromotionChangeService {
         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 {
-            commitSha: branch.commitSha,
-            source: { configId: branch.configId, branchName: branch.branchName },
-            changes: applyQuery(rows, query),
+            branch,
+            branchManifest: branchDesired?.manifest ?? null,
+            instance,
+            destinationVariables,
+            archiveState,
+            rows,
         };
     }
     assertCanPreview(user, direction) {
@@ -152,9 +324,10 @@ let PromotionChangeService = class PromotionChangeService {
             archiveCheckPaths,
         };
     }
-    async exportInstancePackage(user, projectId) {
+    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],
@@ -168,31 +341,74 @@ let PromotionChangeService = class PromotionChangeService {
             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(`${constants_2.PACKAGE_SUBFOLDER}/${path}`, workflow.isArchived);
+                    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 };
+        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) };
+    }
+    async readBranchManifest(branch) {
         const manifestPath = `${constants_2.PACKAGE_SUBFOLDER}/${constants_1.MANIFEST_FILE}`;
-        const manifest = manifest_schema_1.packageManifestSchema.safeParse(parseBranchJson((await branch.readFiles([manifestPath])).get(manifestPath) ?? ''));
-        if (!manifest.success) {
+        const manifest = parsePackageManifest((await branch.readFiles([manifestPath])).get(manifestPath));
+        if (!manifest) {
             throw new errors_1.BadRequestError('The package manifest on the branch cannot be read');
         }
-        return { files: branch.files, manifest: scopeManifestToProject(manifest.data, projectId) };
+        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.VariablesRepository, backend_common_1.Logger])
+    __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])
 ], PromotionChangeService);
 function parseBranchJson(raw) {
     try {
@@ -202,6 +418,72 @@ function parseBranchJson(raw) {
         return undefined;
     }
 }
+function parsePackageManifest(raw) {
+    const manifest = manifest_schema_1.packageManifestSchema.safeParse(parseBranchJson(raw ?? ''));
+    return manifest.success ? manifest.data : null;
+}
+function parseBranchManifest(raw, projectId) {
+    const manifest = parsePackageManifest(raw);
+    return manifest && (0, promotion_preview_1.scopeManifestToProject)(manifest, projectId);
+}
+function blobsByPath(files) {
+    return new Map(files.map(({ path, blobSha }) => [path, blobSha]));
+}
+function entityIdOfPath(path) {
+    const segments = path.split('/');
+    const directory = segments[segments.length - 2] ?? '';
+    return directory.slice(directory.lastIndexOf('-') + 1);
+}
+function toChanges({ branch, rows }, query) {
+    return {
+        commitSha: branch.commitSha,
+        source: { environmentId: branch.environmentId, branchName: branch.branchName },
+        changes: applyQuery(rows, query),
+    };
+}
+function parseContent(schema, content) {
+    if (content === null)
+        return null;
+    const parsed = schema.safeParse(parseBranchJson(content));
+    return parsed.success ? parsed.data : null;
+}
+function toDetail({ key, type, before, after, hideVariableValues, }) {
+    const parseSides = (schema) => ({
+        key,
+        before: parseContent(schema, before.content),
+        after: parseContent(schema, after.content),
+        revision: { before: before.blobSha, after: after.blobSha },
+    });
+    switch (type) {
+        case 'project':
+            return { type, ...parseSides(api_types_1.serializedProjectSchema) };
+        case 'folder':
+            return { type, ...parseSides(api_types_1.serializedFolderSchema) };
+        case 'workflow':
+            return { type, ...parseSides(api_types_1.serializedWorkflowSchema) };
+        case 'credential':
+            return { type, ...parseSides(api_types_1.serializedCredentialSchema) };
+        case 'tag':
+            return { type, ...parseSides(api_types_1.serializedTagSchema) };
+        case 'variable': {
+            const detail = { type, ...parseSides(api_types_1.serializedVariableSchema) };
+            if (!hideVariableValues)
+                return detail;
+            for (const content of [detail.before, detail.after]) {
+                if (content)
+                    delete content.value;
+            }
+            return { ...detail, valueHidden: true };
+        }
+        case 'dataTable': {
+            const detail = { type, ...parseSides(api_types_1.serializedDataTableSchema) };
+            const { before: current, after: incoming } = detail;
+            if (!current || !incoming)
+                return detail;
+            return { ...detail, dataTableChanges: (0, data_table_compat_1.diffDataTableSchema)(incoming, current) };
+        }
+    }
+}
 async function readBranchArchiveState(branch, paths) {
     const files = await branch.readFiles(paths);
     return new Map([...files].map(([path, raw]) => [
@@ -209,42 +491,6 @@ async function readBranchArchiveState(branch, paths) {
         parseBranchJson(raw)?.isArchived ?? false,
     ]));
 }
-function scopeManifestToProject(manifest, projectId) {
-    const projectTarget = manifest.projects?.find(({ id }) => id === projectId)?.target;
-    const inProject = ({ target }) => projectTarget !== undefined && target.startsWith(`${projectTarget}/`);
-    const workflows = (manifest.workflows ?? []).filter(inProject);
-    const workflowIds = new Set(workflows.map(({ id }) => id));
-    const variables = new Map();
-    for (const entry of manifest.variables ?? []) {
-        const isGlobal = !entry.target.startsWith(`${manifest_entry_1.PACKAGE_ENTITY_LAYOUT.projects.directory}/`);
-        if (inProject(entry) || (isGlobal && !variables.has(entry.name))) {
-            variables.set(entry.name, entry);
-        }
-    }
-    const scopeRows = (rows) => {
-        const kept = rows
-            ?.map((row) => ({
-            ...row,
-            usedBy: row.usedBy.filter(({ kind, id }) => kind === 'workflow' && workflowIds.has(id)),
-        }))
-            .filter((row) => row.usedBy.length > 0);
-        return kept?.length ? kept : undefined;
-    };
-    const { requirements } = manifest;
-    return {
-        ...manifest,
-        workflows,
-        variables: [...variables.values()],
-        requirements: requirements && {
-            credentials: scopeRows(requirements.credentials),
-            dataTables: scopeRows(requirements.dataTables),
-            workflows: scopeRows(requirements.workflows),
-            variables: scopeRows(requirements.variables),
-            tags: scopeRows(requirements.tags),
-            nodeTypes: scopeRows(requirements.nodeTypes),
-        },
-    };
-}
 function applyQuery(changes, query) {
     const search = query.search?.toLowerCase();
     return changes