@atom8n/n8n 2.4.6 → 2.5.0

package/dist/commands/execute-batch.d.ts

@@ -20,8 +20,8 @@ declare const flagsSchema: z.ZodObject<{
     concurrency: number;
     retries: number;
     output?: string | undefined;
-    ids?: string | undefined;
     compare?: string | undefined;
+    ids?: string | undefined;
     snapshot?: string | undefined;
     shallow?: boolean | undefined;
     githubWorkflow?: boolean | undefined;
@@ -31,8 +31,8 @@ declare const flagsSchema: z.ZodObject<{
     debug?: boolean | undefined;
     output?: string | undefined;
     concurrency?: number | undefined;
-    ids?: string | undefined;
     compare?: string | undefined;
+    ids?: string | undefined;
     snapshot?: string | undefined;
     shallow?: boolean | undefined;
     githubWorkflow?: boolean | undefined;

package/dist/commands/import/credentials.d.ts

@@ -8,12 +8,12 @@ declare const flagsSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     separate: boolean;
     input?: string | undefined;
-    userId?: string | undefined;
     projectId?: string | undefined;
+    userId?: string | undefined;
 }, {
     input?: string | undefined;
-    userId?: string | undefined;
     projectId?: string | undefined;
+    userId?: string | undefined;
     separate?: boolean | undefined;
 }>;
 export declare class ImportCredentialsCommand extends BaseCommand<z.infer<typeof flagsSchema>> {

package/dist/commands/import/workflow.d.ts

@@ -8,12 +8,12 @@ declare const flagsSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     separate: boolean;
     input?: string | undefined;
-    userId?: string | undefined;
     projectId?: string | undefined;
+    userId?: string | undefined;
 }, {
     input?: string | undefined;
-    userId?: string | undefined;
     projectId?: string | undefined;
+    userId?: string | undefined;
     separate?: boolean | undefined;
 }>;
 export declare class ImportWorkflowsCommand extends BaseCommand<z.infer<typeof flagsSchema>> {

package/dist/commands/ldap/reset.d.ts

@@ -5,12 +5,12 @@ declare const flagsSchema: z.ZodObject<{
     projectId: z.ZodOptional<z.ZodString>;
     deleteWorkflowsAndCredentials: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
-    userId?: string | undefined;
     projectId?: string | undefined;
+    userId?: string | undefined;
     deleteWorkflowsAndCredentials?: boolean | undefined;
 }, {
-    userId?: string | undefined;
     projectId?: string | undefined;
+    userId?: string | undefined;
     deleteWorkflowsAndCredentials?: boolean | undefined;
 }>;
 export declare class Reset extends BaseCommand<z.infer<typeof flagsSchema>> {

package/dist/events/relays/workflow-failure-notification.event-relay.d.ts

@@ -0,0 +1,13 @@
+import { Logger } from '@n8n/backend-common';
+import { UserRepository } from '@n8n/db';
+import { EventService } from '../../events/event.service';
+import { EventRelay } from '../../events/relays/event-relay';
+import { UserManagementMailer } from '../../user-management/email';
+export declare class WorkflowFailureNotificationEventRelay extends EventRelay {
+    private readonly mailer;
+    private readonly userRepository;
+    private readonly logger;
+    constructor(eventService: EventService, mailer: UserManagementMailer, userRepository: UserRepository, logger: Logger);
+    init(): void;
+    private onFirstProductionWorkflowFailed;
+}

package/dist/events/relays/workflow-failure-notification.event-relay.js

@@ -0,0 +1,77 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowFailureNotificationEventRelay = void 0;
+const backend_common_1 = require("@n8n/backend-common");
+const db_1 = require("@n8n/db");
+const di_1 = require("@n8n/di");
+const event_service_1 = require("../../events/event.service");
+const event_relay_1 = require("../../events/relays/event-relay");
+const email_1 = require("../../user-management/email");
+let WorkflowFailureNotificationEventRelay = class WorkflowFailureNotificationEventRelay extends event_relay_1.EventRelay {
+    constructor(eventService, mailer, userRepository, logger) {
+        super(eventService);
+        this.mailer = mailer;
+        this.userRepository = userRepository;
+        this.logger = logger;
+    }
+    init() {
+        this.setupListeners({
+            'instance-first-production-workflow-failed': async (event) => await this.onFirstProductionWorkflowFailed(event),
+        });
+    }
+    async onFirstProductionWorkflowFailed(event) {
+        const { workflowId, workflowName, userId } = event;
+        if (!this.mailer.isEmailSetUp) {
+            this.logger.debug('Skipping first production failure email - SMTP not configured', {
+                workflowId,
+                userId,
+            });
+            return;
+        }
+        try {
+            const user = await this.userRepository.findOneBy({ id: userId });
+            if (!user || !user.email) {
+                this.logger.warn('Cannot send first production failure email - user not found or no email', {
+                    workflowId,
+                    userId,
+                });
+                return;
+            }
+            await this.mailer.workflowFailure({
+                email: user.email,
+                firstName: user.firstName,
+                workflowId,
+                workflowName,
+            });
+            this.logger.info('Sent first production failure email', {
+                workflowId,
+                userId,
+                email: user.email,
+            });
+        }
+        catch (error) {
+            this.logger.error('Failed to send first production failure email', {
+                workflowId,
+                userId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+};
+exports.WorkflowFailureNotificationEventRelay = WorkflowFailureNotificationEventRelay;
+exports.WorkflowFailureNotificationEventRelay = WorkflowFailureNotificationEventRelay = __decorate([
+    (0, di_1.Service)(),
+    __metadata("design:paramtypes", [event_service_1.EventService,
+        email_1.UserManagementMailer,
+        db_1.UserRepository,
+        backend_common_1.Logger])
+], WorkflowFailureNotificationEventRelay);

package/dist/executions/execution-data/types.d.ts

@@ -0,0 +1,17 @@
+import type { IWorkflowBase } from 'n8n-workflow';
+type ExecutionRef = {
+    workflowId: string;
+    executionId: string;
+};
+type ExecutionDataPayload = {
+    data: string;
+    workflowData: IWorkflowBase;
+    workflowVersionId: string | null;
+};
+export interface ExecutionDataManager {
+    init?(): Promise<void>;
+    write(ref: ExecutionRef, payload: ExecutionDataPayload): Promise<void>;
+    read(ref: ExecutionRef): Promise<ExecutionDataPayload>;
+    delete(ref: ExecutionRef | ExecutionRef[]): Promise<void>;
+}
+export {};

package/dist/executions/execution-data/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/executions/failed-run-factory.d.ts

@@ -0,0 +1,4 @@
+import { type ExecutionError, type INode, type IRun, type WorkflowExecuteMode } from 'n8n-workflow';
+export declare class FailedRunFactory {
+    generateFailedExecutionFromError(mode: WorkflowExecuteMode, error: ExecutionError, node: INode | undefined, startTime?: number): IRun;
+}

package/dist/executions/failed-run-factory.js

@@ -0,0 +1,71 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FailedRunFactory = void 0;
+const di_1 = require("@n8n/di");
+const n8n_workflow_1 = require("n8n-workflow");
+let FailedRunFactory = class FailedRunFactory {
+    generateFailedExecutionFromError(mode, error, node, startTime = Date.now()) {
+        const executionError = {
+            ...error,
+            message: error.message,
+            stack: error.stack,
+        };
+        const returnData = {
+            data: (0, n8n_workflow_1.createRunExecutionData)({
+                resultData: {
+                    error: executionError,
+                    runData: {},
+                },
+            }),
+            finished: false,
+            mode,
+            startedAt: new Date(),
+            stoppedAt: new Date(),
+            status: 'error',
+        };
+        if (node) {
+            returnData.data.startData = {
+                destinationNode: {
+                    nodeName: node.name,
+                    mode: 'inclusive',
+                },
+                runNodeFilter: [node.name],
+            };
+            returnData.data.resultData.lastNodeExecuted = node.name;
+            returnData.data.resultData.runData[node.name] = [
+                {
+                    startTime,
+                    executionIndex: 0,
+                    executionTime: 0,
+                    executionStatus: 'error',
+                    error: executionError,
+                    source: [],
+                },
+            ];
+            returnData.data.executionData = {
+                contextData: {},
+                metadata: {},
+                waitingExecution: {},
+                waitingExecutionSource: {},
+                nodeExecutionStack: [
+                    {
+                        node,
+                        data: {},
+                        source: null,
+                    },
+                ],
+            };
+        }
+        return returnData;
+    }
+};
+exports.FailedRunFactory = FailedRunFactory;
+exports.FailedRunFactory = FailedRunFactory = __decorate([
+    (0, di_1.Service)()
+], FailedRunFactory);

package/dist/interfaces.d.ts

@@ -7,7 +7,7 @@ import type { ActiveWorkflowManager } from './active-workflow-manager';
 import type { ExternalHooks } from './external-hooks';
 import type WebSocket from 'ws';
 export interface ExtendedWebSocket extends WebSocket {
-    isAlive?: boolean;
+    isAlive: boolean;
 }
 export interface ICredentialsTypeData {
     [key: string]: CredentialLoadingDetails;

package/dist/license.js

@@ -236,7 +236,7 @@ let License = class License {
         return this.isLicensed(constants_1.LICENSE_FEATURES.DYNAMIC_CREDENTIALS);
     }
     isSharingEnabled() {
-        return this.isLicensed(constants_1.LICENSE_FEATURES.SHARING);
+        return false;
     }
     isLogStreamingEnabled() {
         return this.isLicensed(constants_1.LICENSE_FEATURES.LOG_STREAMING);

package/dist/middlewares/webview-frame-options.d.ts

@@ -0,0 +1,2 @@
+import type { RequestHandler } from 'express';
+export declare const webviewFrameOptionsMiddleware: RequestHandler;

package/dist/middlewares/webview-frame-options.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webviewFrameOptionsMiddleware = void 0;
+const webviewFrameOptionsMiddleware = (req, res, next) => {
+    const origin = req.headers.origin;
+    const referer = req.headers.referer;
+    const isVSCodeWebview = origin?.startsWith('vscode-webview://') ||
+        referer?.includes('vscode-webview://') ||
+        req.headers['x-vscode-webview'] === 'true';
+    if (isVSCodeWebview) {
+        const originalSetHeader = res.setHeader.bind(res);
+        res.setHeader = function (name, value) {
+            if (name.toLowerCase() === 'x-frame-options') {
+                return this;
+            }
+            return originalSetHeader(name, value);
+        };
+        res.removeHeader('X-Frame-Options');
+    }
+    next();
+};
+exports.webviewFrameOptionsMiddleware = webviewFrameOptionsMiddleware;

package/dist/modules/chat-hub/chat-hub-extractor.d.ts

@@ -0,0 +1,22 @@
+import { Logger } from '@n8n/backend-common';
+import { ContextEstablishmentOptions, ContextEstablishmentResult, HookDescription, IContextEstablishmentHook } from '@n8n/decorators';
+import { z } from 'zod';
+declare const ChatHubTriggerItemSchema: z.ZodObject<{
+    authToken: z.ZodString;
+    browserId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    authToken: string;
+    browserId?: string | undefined;
+}, {
+    authToken: string;
+    browserId?: string | undefined;
+}>;
+export type ChatHubTriggerItem = z.output<typeof ChatHubTriggerItemSchema>;
+export declare class ChatHubExtractor implements IContextEstablishmentHook {
+    private readonly logger;
+    constructor(logger: Logger);
+    hookDescription: HookDescription;
+    isApplicableToTriggerNode(_nodeType: string): boolean;
+    execute(options: ContextEstablishmentOptions): Promise<ContextEstablishmentResult>;
+}
+export {};

package/dist/modules/chat-hub/chat-hub-extractor.js

@@ -0,0 +1,63 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatHubExtractor = void 0;
+const backend_common_1 = require("@n8n/backend-common");
+const decorators_1 = require("@n8n/decorators");
+const zod_1 = require("zod");
+const ChatHubTriggerItemSchema = zod_1.z.object({
+    authToken: zod_1.z.string(),
+    browserId: zod_1.z.string().optional(),
+});
+let ChatHubExtractor = class ChatHubExtractor {
+    constructor(logger) {
+        this.logger = logger;
+        this.hookDescription = {
+            name: 'ChatHubExtractor',
+            displayName: 'Chat Hub Extractor',
+            options: [],
+        };
+    }
+    isApplicableToTriggerNode(_nodeType) {
+        return false;
+    }
+    async execute(options) {
+        if (!options.triggerItems || options.triggerItems.length === 0) {
+            this.logger.debug('No trigger items found, skipping ChatHubExtractor hook.');
+            return {};
+        }
+        const [triggerItem] = options.triggerItems;
+        const chatHubInformation = ChatHubTriggerItemSchema.safeParse(triggerItem.json);
+        delete triggerItem.json.authToken;
+        delete triggerItem.json.browserId;
+        if (chatHubInformation.success) {
+            return {
+                triggerItems: options.triggerItems,
+                contextUpdate: {
+                    credentials: {
+                        version: 1,
+                        identity: chatHubInformation.data.authToken,
+                        metadata: {
+                            source: 'chat-hub-injected',
+                            browserId: chatHubInformation.data.browserId ?? null,
+                        },
+                    },
+                },
+            };
+        }
+        return {};
+    }
+};
+exports.ChatHubExtractor = ChatHubExtractor;
+exports.ChatHubExtractor = ChatHubExtractor = __decorate([
+    (0, decorators_1.ContextEstablishmentHook)(),
+    __metadata("design:paramtypes", [backend_common_1.Logger])
+], ChatHubExtractor);

package/dist/modules/dynamic-credentials.ee/credential-resolvers/storage/dynamic-credential-user-entry-storage.d.ts

@@ -0,0 +1,11 @@
+import { CredentialResolverHandle } from '@n8n/decorators';
+import { ICredentialEntriesStorage } from './storage-interface';
+import { DynamicCredentialUserEntryRepository } from '../../database/repositories/dynamic-credential-user-entry.repository';
+export declare class DynamicCredentialUserEntryStorage implements ICredentialEntriesStorage {
+    private readonly dynamicCredentialUserEntryRepository;
+    constructor(dynamicCredentialUserEntryRepository: DynamicCredentialUserEntryRepository);
+    getCredentialData(credentialId: string, userId: string, resolverId: string, _: Record<string, unknown>): Promise<string | null>;
+    setCredentialData(credentialId: string, userId: string, resolverId: string, data: string, _: Record<string, unknown>): Promise<void>;
+    deleteCredentialData(credentialId: string, userId: string, resolverId: string, _: Record<string, unknown>): Promise<void>;
+    deleteAllCredentialData(handle: CredentialResolverHandle): Promise<void>;
+}

package/dist/modules/dynamic-credentials.ee/credential-resolvers/storage/dynamic-credential-user-entry-storage.js

@@ -0,0 +1,58 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamicCredentialUserEntryStorage = void 0;
+const di_1 = require("@n8n/di");
+const dynamic_credential_user_entry_1 = require("../../database/entities/dynamic-credential-user-entry");
+const dynamic_credential_user_entry_repository_1 = require("../../database/repositories/dynamic-credential-user-entry.repository");
+let DynamicCredentialUserEntryStorage = class DynamicCredentialUserEntryStorage {
+    constructor(dynamicCredentialUserEntryRepository) {
+        this.dynamicCredentialUserEntryRepository = dynamicCredentialUserEntryRepository;
+    }
+    async getCredentialData(credentialId, userId, resolverId, _) {
+        const entry = await this.dynamicCredentialUserEntryRepository.findOne({
+            where: {
+                credentialId,
+                userId,
+                resolverId,
+            },
+        });
+        return entry?.data ?? null;
+    }
+    async setCredentialData(credentialId, userId, resolverId, data, _) {
+        let entry = await this.dynamicCredentialUserEntryRepository.findOne({
+            where: { credentialId, userId, resolverId },
+        });
+        if (!entry) {
+            entry = new dynamic_credential_user_entry_1.DynamicCredentialUserEntry();
+            entry.credentialId = credentialId;
+            entry.userId = userId;
+            entry.resolverId = resolverId;
+        }
+        entry.data = data;
+        await this.dynamicCredentialUserEntryRepository.save(entry);
+    }
+    async deleteCredentialData(credentialId, userId, resolverId, _) {
+        await this.dynamicCredentialUserEntryRepository.delete({
+            credentialId,
+            userId,
+            resolverId,
+        });
+    }
+    async deleteAllCredentialData(handle) {
+        await this.dynamicCredentialUserEntryRepository.delete({ resolverId: handle.resolverId });
+    }
+};
+exports.DynamicCredentialUserEntryStorage = DynamicCredentialUserEntryStorage;
+exports.DynamicCredentialUserEntryStorage = DynamicCredentialUserEntryStorage = __decorate([
+    (0, di_1.Service)(),
+    __metadata("design:paramtypes", [dynamic_credential_user_entry_repository_1.DynamicCredentialUserEntryRepository])
+], DynamicCredentialUserEntryStorage);

package/dist/modules/dynamic-credentials.ee/database/entities/dynamic-credential-user-entry.d.ts

@@ -0,0 +1,12 @@
+import { CredentialsEntity, User, WithTimestamps } from '@n8n/db';
+import { DynamicCredentialResolver } from './credential-resolver';
+export declare class DynamicCredentialUserEntry extends WithTimestamps {
+    constructor();
+    credentialId: string;
+    userId: string;
+    resolverId: string;
+    data: string;
+    credential: CredentialsEntity;
+    user: User;
+    resolver: DynamicCredentialResolver;
+}

package/dist/modules/dynamic-credentials.ee/database/entities/dynamic-credential-user-entry.js

@@ -0,0 +1,64 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamicCredentialUserEntry = void 0;
+const db_1 = require("@n8n/db");
+const typeorm_1 = require("@n8n/typeorm");
+const credential_resolver_1 = require("./credential-resolver");
+let DynamicCredentialUserEntry = class DynamicCredentialUserEntry extends db_1.WithTimestamps {
+    constructor() {
+        super();
+    }
+};
+exports.DynamicCredentialUserEntry = DynamicCredentialUserEntry;
+__decorate([
+    (0, typeorm_1.PrimaryColumn)({
+        name: 'credentialId',
+    }),
+    __metadata("design:type", String)
+], DynamicCredentialUserEntry.prototype, "credentialId", void 0);
+__decorate([
+    (0, typeorm_1.PrimaryColumn)({
+        name: 'userId',
+    }),
+    __metadata("design:type", String)
+], DynamicCredentialUserEntry.prototype, "userId", void 0);
+__decorate([
+    (0, typeorm_1.PrimaryColumn)({
+        name: 'resolverId',
+    }),
+    __metadata("design:type", String)
+], DynamicCredentialUserEntry.prototype, "resolverId", void 0);
+__decorate([
+    (0, typeorm_1.Column)('text'),
+    __metadata("design:type", String)
+], DynamicCredentialUserEntry.prototype, "data", void 0);
+__decorate([
+    (0, typeorm_1.ManyToOne)(() => db_1.CredentialsEntity, { onDelete: 'CASCADE' }),
+    (0, typeorm_1.JoinColumn)({ name: 'credentialId' }),
+    __metadata("design:type", db_1.CredentialsEntity)
+], DynamicCredentialUserEntry.prototype, "credential", void 0);
+__decorate([
+    (0, typeorm_1.ManyToOne)(() => db_1.User, { onDelete: 'CASCADE' }),
+    (0, typeorm_1.JoinColumn)({ name: 'userId' }),
+    __metadata("design:type", db_1.User)
+], DynamicCredentialUserEntry.prototype, "user", void 0);
+__decorate([
+    (0, typeorm_1.ManyToOne)(() => credential_resolver_1.DynamicCredentialResolver, { onDelete: 'CASCADE' }),
+    (0, typeorm_1.JoinColumn)({ name: 'resolverId' }),
+    __metadata("design:type", credential_resolver_1.DynamicCredentialResolver)
+], DynamicCredentialUserEntry.prototype, "resolver", void 0);
+exports.DynamicCredentialUserEntry = DynamicCredentialUserEntry = __decorate([
+    (0, typeorm_1.Entity)({
+        name: 'dynamic_credential_user_entry',
+    }),
+    __metadata("design:paramtypes", [])
+], DynamicCredentialUserEntry);

package/dist/modules/dynamic-credentials.ee/database/repositories/dynamic-credential-user-entry.repository.d.ts

@@ -0,0 +1,5 @@
+import { DataSource, Repository } from '@n8n/typeorm';
+import { DynamicCredentialUserEntry } from '../entities/dynamic-credential-user-entry';
+export declare class DynamicCredentialUserEntryRepository extends Repository<DynamicCredentialUserEntry> {
+    constructor(dataSource: DataSource);
+}

package/dist/modules/dynamic-credentials.ee/database/repositories/dynamic-credential-user-entry.repository.js

@@ -0,0 +1,25 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamicCredentialUserEntryRepository = void 0;
+const di_1 = require("@n8n/di");
+const typeorm_1 = require("@n8n/typeorm");
+const dynamic_credential_user_entry_1 = require("../entities/dynamic-credential-user-entry");
+let DynamicCredentialUserEntryRepository = class DynamicCredentialUserEntryRepository extends typeorm_1.Repository {
+    constructor(dataSource) {
+        super(dynamic_credential_user_entry_1.DynamicCredentialUserEntry, dataSource.manager);
+    }
+};
+exports.DynamicCredentialUserEntryRepository = DynamicCredentialUserEntryRepository;
+exports.DynamicCredentialUserEntryRepository = DynamicCredentialUserEntryRepository = __decorate([
+    (0, di_1.Service)(),
+    __metadata("design:paramtypes", [typeorm_1.DataSource])
+], DynamicCredentialUserEntryRepository);

package/dist/modules/dynamic-credentials.ee/dynamic-credentials.config.d.ts

@@ -0,0 +1,5 @@
+export declare class DynamicCredentialsConfig {
+    corsOrigin: string;
+    corsAllowCredentials: boolean;
+    endpointAuthToken: string;
+}

package/dist/modules/dynamic-credentials.ee/dynamic-credentials.config.js

@@ -0,0 +1,36 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamicCredentialsConfig = void 0;
+const config_1 = require("@n8n/config");
+let DynamicCredentialsConfig = class DynamicCredentialsConfig {
+    constructor() {
+        this.corsOrigin = '';
+        this.corsAllowCredentials = false;
+        this.endpointAuthToken = '';
+    }
+};
+exports.DynamicCredentialsConfig = DynamicCredentialsConfig;
+__decorate([
+    (0, config_1.Env)('N8N_DYNAMIC_CREDENTIALS_CORS_ORIGIN'),
+    __metadata("design:type", String)
+], DynamicCredentialsConfig.prototype, "corsOrigin", void 0);
+__decorate([
+    (0, config_1.Env)('N8N_DYNAMIC_CREDENTIALS_CORS_ALLOW_CREDENTIALS'),
+    __metadata("design:type", Boolean)
+], DynamicCredentialsConfig.prototype, "corsAllowCredentials", void 0);
+__decorate([
+    (0, config_1.Env)('N8N_DYNAMIC_CREDENTIALS_ENDPOINT_AUTH_TOKEN'),
+    __metadata("design:type", String)
+], DynamicCredentialsConfig.prototype, "endpointAuthToken", void 0);
+exports.DynamicCredentialsConfig = DynamicCredentialsConfig = __decorate([
+    config_1.Config
+], DynamicCredentialsConfig);

package/dist/modules/dynamic-credentials.ee/services/dynamic-credential-cors.service.d.ts

@@ -0,0 +1,12 @@
+import { CorsService } from '../../../services/cors-service';
+import type { Method } from '@n8n/decorators';
+import type { Request, Response } from 'express';
+import { DynamicCredentialsConfig } from '../dynamic-credentials.config';
+export declare class DynamicCredentialCorsService {
+    private readonly corsService;
+    private readonly dynamicCredentialConfig;
+    private readonly defaultOptions;
+    constructor(corsService: CorsService, dynamicCredentialConfig: DynamicCredentialsConfig);
+    preflightHandler(req: Request, res: Response, allowedMethods: Method[]): void;
+    applyCorsHeadersIfEnabled(req: Request, res: Response, allowedMethods: Method[]): boolean;
+}