n8n
Version:
n8n Workflow Automation Tool
156 lines • 7.16 kB
JavaScript
;
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.CredentialResolverWorkflowService = void 0;
const db_1 = require("@n8n/db");
const di_1 = require("@n8n/di");
const n8n_core_1 = require("n8n-core");
const n8n_workflow_1 = require("n8n-workflow");
const credential_resolver_registry_service_1 = require("./credential-resolver-registry.service");
const credential_resolver_repository_1 = require("../database/repositories/credential-resolver.repository");
function isCredentialStatus(obj) {
if (typeof obj !== 'object' || obj === null) {
return false;
}
return ('credentialId' in obj &&
typeof obj.credentialId === 'string' &&
'credentialType' in obj &&
typeof obj.credentialType === 'string' &&
'status' in obj &&
(obj.status === 'missing' || obj.status === 'configured' || obj.status === 'resolver_missing'));
}
let CredentialResolverWorkflowService = class CredentialResolverWorkflowService {
constructor(workflowRepository, credentialRepository, resolverRegistry, resolverRepository, cipher) {
this.workflowRepository = workflowRepository;
this.credentialRepository = credentialRepository;
this.resolverRegistry = resolverRegistry;
this.resolverRepository = resolverRepository;
this.cipher = cipher;
}
async getResolver(resolverId) {
const resolver = await this.resolverRepository.findOneBy({ id: resolverId });
if (!resolver) {
throw new Error('Credential resolver not found');
}
const resolverInstance = this.resolverRegistry.getResolverByTypename(resolver.type);
if (!resolverInstance) {
throw new Error('Credential resolver implementation not found');
}
try {
const decryptedConfig = await this.cipher.decryptV2(resolver.config);
const resolverConfig = (0, n8n_workflow_1.jsonParse)(decryptedConfig);
return {
resolverInstance,
resolverConfig,
};
}
catch (error) {
throw new Error('Failed to decrypt or parse resolver configuration');
}
}
async getWorkflowStatus(workflowId, credentialContext) {
const workflow = await this.workflowRepository.get({
id: workflowId,
});
if (!workflow) {
throw new Error('Workflow not found');
}
const resolverId = workflow.settings?.credentialResolverId;
let workflowResolverInstance = null;
let workflowResolverConfig = null;
if (resolverId) {
const { resolverInstance, resolverConfig } = await this.getResolver(resolverId);
workflowResolverInstance = resolverInstance;
workflowResolverConfig = resolverConfig;
}
const credentialsToCheck = [];
for (const node of workflow.nodes ?? []) {
for (const credentialName in node.credentials ?? {}) {
const credentialData = node.credentials?.[credentialName];
if (credentialData?.id) {
credentialsToCheck.push(credentialData.id);
}
}
}
if (credentialsToCheck.length === 0) {
return [];
}
const credentials = await this.credentialRepository.find({
where: {
id: (0, db_1.In)(credentialsToCheck),
isResolvable: true,
},
});
const credentialStatusPromises = credentials.map(async (credential) => {
return await this.checkCredentialStatus(credential, {
workflowResolverInstance,
workflowResolverConfig,
resolverId,
credentialContext,
});
});
return (await Promise.all(credentialStatusPromises)).filter(isCredentialStatus);
}
async checkCredentialStatus(credential, options) {
let resolverInstance = options.workflowResolverInstance;
let resolverConfig = options.workflowResolverConfig;
const credentialResolverId = credential.resolverId ?? options.resolverId;
if (!credentialResolverId) {
return {
credentialId: credential.id,
credentialName: credential.name,
status: 'resolver_missing',
credentialType: credential.type,
};
}
if (credentialResolverId !== options.resolverId) {
const { resolverInstance: credentialResolverInstance, resolverConfig: credentialResolverConfig, } = await this.getResolver(credentialResolverId);
resolverInstance = credentialResolverInstance;
resolverConfig = credentialResolverConfig;
}
if (resolverConfig && resolverInstance) {
try {
await resolverInstance.getSecret(credential.id, options.credentialContext, {
configuration: resolverConfig,
resolverName: resolverInstance.metadata.name,
resolverId: credentialResolverId,
});
return {
credentialId: credential.id,
resolverId: credentialResolverId,
credentialName: credential.name,
status: 'configured',
credentialType: credential.type,
};
}
catch (error) {
return {
credentialId: credential.id,
resolverId: credentialResolverId,
credentialName: credential.name,
status: 'missing',
credentialType: credential.type,
};
}
}
return null;
}
};
exports.CredentialResolverWorkflowService = CredentialResolverWorkflowService;
exports.CredentialResolverWorkflowService = CredentialResolverWorkflowService = __decorate([
(0, di_1.Service)(),
__metadata("design:paramtypes", [db_1.WorkflowRepository,
db_1.CredentialsRepository,
credential_resolver_registry_service_1.DynamicCredentialResolverRegistry,
credential_resolver_repository_1.DynamicCredentialResolverRepository,
n8n_core_1.Cipher])
], CredentialResolverWorkflowService);
//# sourceMappingURL=credential-resolver-workflow.service.js.map