n8n
Version:
n8n Workflow Automation Tool
140 lines • 7.82 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.ProjectPackageImporter = void 0;
const backend_common_1 = require("@n8n/backend-common");
const di_1 = require("@n8n/di");
const forbidden_error_1 = require("../../../errors/response-errors/forbidden.error");
const event_service_1 = require("../../../events/event.service");
const project_importer_1 = require("../entities/project/project-importer");
const n8n_packages_types_1 = require("../n8n-packages.types");
const import_blocked_error_1 = require("./import-blocked.error");
const import_orchestrator_1 = require("./import-orchestrator");
const import_result_1 = require("./import-result");
const import_telemetry_1 = require("./import-telemetry");
const n8n_package_parser_1 = require("./n8n-package-parser");
let ProjectPackageImporter = class ProjectPackageImporter {
constructor(packageParser, projectImporter, importOrchestrator, eventService, licenseState) {
this.packageParser = packageParser;
this.projectImporter = projectImporter;
this.importOrchestrator = importOrchestrator;
this.eventService = eventService;
this.licenseState = licenseState;
}
async import(request, reader, manifest) {
this.assertAdequatePermissions(request, manifest);
const projects = await this.packageParser.getProjects(reader);
const projectPlan = await this.projectImporter.plan(request.user, projects);
const pendingCreateIds = new Set(projectPlan.filter((item) => item.action === 'create').map((item) => item.sourceProjectId));
const planned = [];
const blockingIssues = [];
for (const project of manifest.projects ?? []) {
const input = await this.buildImportContextForProject(request, reader, manifest, project, pendingCreateIds.has(project.id));
const plan = await this.importOrchestrator.plan(input);
planned.push({ project, plan });
blockingIssues.push(...plan.blockingIssues);
}
if (blockingIssues.length > 0) {
throw (0, import_blocked_error_1.toImportBlockedError)(blockingIssues);
}
const projectSummaries = await this.projectImporter.apply(request.user, projectPlan);
const workflows = [];
const folders = [];
const scopedBindings = [];
const matched = [];
const stubbed = [];
const variablesMatched = new Set();
const variablesMissing = new Set();
const scopes = [];
for (const { project, plan } of planned) {
const imported = await this.importOrchestrator.apply(plan);
workflows.push(...(0, import_result_1.toImportedWorkflowSummaries)(imported.workflowOutcomes, project.id));
folders.push(...imported.folderSummaries);
scopedBindings.push(imported.bindings);
matched.push(...imported.credentialResult.matched);
stubbed.push(...imported.credentialResult.stubbed);
imported.variablePlan.matched.forEach((name) => variablesMatched.add(name));
imported.variablePlan.missing.forEach(({ name }) => variablesMissing.add(name));
scopes.push({
context: plan.input.context,
imported,
credentialRequest: plan.input.credentialRequest,
dataTableRequest: plan.input.dataTableRequest,
variableRequest: plan.input.variableRequest,
});
}
(0, import_telemetry_1.emitPackageImportedEvent)(this.eventService, { request, manifest, scopes });
return (0, import_result_1.buildImportResult)({
package: (0, import_result_1.toPackageSummary)(manifest),
workflows,
folders,
projects: projectSummaries,
bindings: (0, n8n_packages_types_1.mergeBindings)(...scopedBindings),
credentials: { matched, stubbed },
variables: { matched: [...variablesMatched], missing: [...variablesMissing] },
});
}
async buildImportContextForProject(request, reader, manifest, project, projectPendingCreation) {
const basePrefix = `${project.target}/`;
const folders = await this.packageParser.getFolders(reader, basePrefix);
const workflows = await this.packageParser.getWorkflows(reader, basePrefix);
const requirements = (0, import_result_1.identifyRequirements)(manifest.requirements?.credentials, workflows);
const credentialRequest = {
requirements,
matchingMode: request.credentialMatchingMode,
missingMode: request.credentialMissingMode,
credentialBindings: (0, import_result_1.scopeCredentialBindingsToRequirements)(request.bindings?.credentials, requirements),
};
const dataTableRequest = {
requirements: (0, import_result_1.identifyRequirements)(manifest.requirements?.dataTables, workflows),
packageDataTables: await this.packageParser.getDataTables(reader),
matchingMode: request.dataTableMatchingMode,
missingMode: request.dataTableMissingMode,
schemaConflictPolicy: request.dataTableSchemaConflictPolicy,
};
const variableRequest = {
requirements: (0, import_result_1.identifyRequirements)(manifest.requirements?.variables, workflows),
missingMode: request.variableMissingMode,
};
return {
context: {
user: request.user,
projectId: project.id,
folderId: null,
},
folders,
workflows,
credentialRequest,
dataTableRequest,
variableRequest,
options: request,
projectPendingCreation,
};
}
assertAdequatePermissions(request, manifest) {
(0, import_result_1.assertPackageImportApiKeyScopes)(request.apiKeyScopes, ['project:create', 'project:update']);
if ((manifest.folders?.length ?? 0) > 0) {
if (!this.licenseState.isLicensed('feat:folders')) {
throw new forbidden_error_1.ForbiddenError('Your license does not allow folders. Importing a package with folders requires a license that supports folders.');
}
(0, import_result_1.assertPackageImportApiKeyScopes)(request.apiKeyScopes, ['folder:create', 'folder:update']);
}
if ((manifest.workflows?.length ?? 0) > 0) {
(0, import_result_1.assertPackageImportApiKeyScopes)(request.apiKeyScopes, ['workflow:import']);
}
}
};
exports.ProjectPackageImporter = ProjectPackageImporter;
exports.ProjectPackageImporter = ProjectPackageImporter = __decorate([
(0, di_1.Service)(),
__metadata("design:paramtypes", [n8n_package_parser_1.N8nPackageParser, project_importer_1.ProjectImporter, import_orchestrator_1.ImportOrchestrator, event_service_1.EventService, backend_common_1.LicenseState])
], ProjectPackageImporter);
//# sourceMappingURL=project-package-importer.js.map