n8n
Version:
n8n Workflow Automation Tool
269 lines • 13.1 kB
JavaScript
;
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.loadPublicApiVersions = void 0;
exports.isApiEnabled = isApiEnabled;
const backend_common_1 = require("@n8n/backend-common");
const config_1 = require("@n8n/config");
const di_1 = require("@n8n/di");
const express_1 = __importDefault(require("express"));
const promises_1 = __importDefault(require("fs/promises"));
const n8n_workflow_1 = require("n8n-workflow");
const path_1 = __importDefault(require("path"));
const validator_1 = __importDefault(require("validator"));
const public_api_controller_registry_1 = require("./public-api-controller.registry");
const public_api_error_response_1 = require("./v1/public-api-error-response");
const event_service_1 = require("../events/event.service");
const license_1 = require("../license");
const import_package_upload_1 = require("../modules/n8n-packages/utils/import-package-upload");
const auth_strategy_registry_1 = require("../services/auth-strategy.registry");
const last_active_at_service_1 = require("../services/last-active-at.service");
const url_service_1 = require("../services/url.service");
require("./v1/controllers");
function scopeBadgePlugin() {
const wrapOperationSummary = (originalComponent, system) => (props) => {
const pathArr = props.specPath?.toJS ? props.specPath.toJS() : null;
const op = pathArr ? (system.specSelectors?.specJson().getIn(pathArr) ?? null) : null;
const rawScope = op?.get ? op.get('x-required-scope') : null;
const scope = typeof rawScope === 'string' ? rawScope : null;
const method = pathArr ? pathArr[2] : null;
const pathStr = pathArr ? pathArr[1] : null;
system.React.useEffect(() => {
if (!scope || scope === 'none' || !method || !pathStr)
return;
const candidates = document.querySelectorAll('.opblock-summary-' + method);
let target = null;
for (const c of candidates) {
const pathEl = c.querySelector('.opblock-summary-path');
if (pathEl && pathEl.getAttribute('data-path') === pathStr) {
target =
c.querySelector('.opblock-summary-path-description-wrapper') ??
c.querySelector('.opblock-summary-description');
break;
}
}
if (!target)
return;
const existing = target.querySelector(':scope > .x-scope-badge');
if (existing)
existing.remove();
const badge = document.createElement('span');
badge.className = 'x-scope-badge';
badge.textContent = scope;
target.appendChild(badge);
return () => {
badge.remove();
};
}, [scope, method, pathStr]);
return system.React.createElement(originalComponent, props);
};
return { wrapComponents: { OperationSummary: wrapOperationSummary } };
}
function createLazySwaggerMiddleware(openApiSpecPath, publicApiEndpoint, version) {
let cachedRouter;
return async (req, res, next) => {
if (!cachedRouter) {
const globalConfig = di_1.Container.get(config_1.GlobalConfig);
const n8nPath = globalConfig.path;
const YAML = await import('yaml');
const spec = await promises_1.default.readFile(openApiSpecPath, 'utf-8');
const swaggerDocument = YAML.parse(spec);
swaggerDocument.server = [
{
url: `${di_1.Container.get(url_service_1.UrlService).getInstanceBaseUrl()}/${publicApiEndpoint}/${version}}`,
},
];
const { serveFiles, setup } = await import('swagger-ui-express');
const swaggerThemePath = path_1.default.join(__dirname, 'swagger-theme.css');
const swaggerThemeCss = await promises_1.default.readFile(swaggerThemePath, { encoding: 'utf-8' });
const swaggerSetupOpts = {
customCss: swaggerThemeCss,
customSiteTitle: 'n8n Public API UI',
customfavIcon: `${n8nPath}favicon.ico`,
swaggerOptions: {
plugins: [scopeBadgePlugin],
},
};
cachedRouter = express_1.default.Router();
cachedRouter.use(serveFiles(swaggerDocument, swaggerSetupOpts), setup(swaggerDocument, swaggerSetupOpts));
}
void cachedRouter(req, res, next);
};
}
async function importOperationHandlerResolver(handlersPath, routeArg, apiDocArg) {
return resolveOperationHandler(handlersPath, routeArg, apiDocArg, 'import');
}
function requireOperationHandlerResolver(handlersPath, routeArg, apiDocArg) {
return resolveOperationHandler(handlersPath, routeArg, apiDocArg, 'require');
}
function controllerOwnedNoopHandler() {
return [
(_req, _res, next) => {
next();
},
];
}
function resolveOperationHandler(handlersPath, routeArg, apiDocArg, loader) {
const route = routeArg;
const apiDoc = apiDocArg;
const pathKey = route.openApiRoute.substring(route.basePath.length);
const operation = apiDoc.paths?.[pathKey]?.[route.method.toLowerCase()];
const operationId = operation?.['x-eov-operation-id'] ?? operation?.operationId;
const handlerModule = operation?.['x-eov-operation-handler'];
if (!handlerModule) {
return controllerOwnedNoopHandler();
}
if (!operationId) {
throw new n8n_workflow_1.UnexpectedError(`Missing operation id for [${route.method}] ${route.expressRoute}`);
}
const modulePath = path_1.default.join(handlersPath, handlerModule);
if (loader === 'require') {
const imported = require(modulePath);
const handler = imported[operationId] ?? imported.default?.[operationId] ?? imported.default;
if (!handler) {
throw new n8n_workflow_1.UnexpectedError(`Could not find handler '${operationId}' in module '${modulePath}'`);
}
return handler;
}
return (async () => {
const imported = (await import(modulePath));
const handler = imported[operationId] ?? imported.default?.[operationId] ?? imported.default;
if (!handler) {
throw new n8n_workflow_1.UnexpectedError(`Could not find handler '${operationId}' in module '${modulePath}'`);
}
return handler;
})();
}
function createPublicControllerMiddleware(version) {
const router = express_1.default.Router({ mergeParams: true });
di_1.Container.get(public_api_controller_registry_1.PublicApiControllerRegistry).activate(router, version);
return router;
}
function createLazyValidatorMiddleware(openApiSpecPath, handlersDirectory, version) {
let cachedRouter;
let initPromise;
return async (req, res, next) => {
if (!cachedRouter) {
initPromise ??= (async () => {
const { middleware: openApiValidatorMiddleware } = await import('express-openapi-validator');
const authStrategyRegistry = di_1.Container.get(auth_strategy_registry_1.AuthStrategyRegistry);
const eventService = di_1.Container.get(event_service_1.EventService);
const lastActiveAtService = di_1.Container.get(last_active_at_service_1.LastActiveAtService);
const logger = di_1.Container.get(backend_common_1.Logger);
const authenticate = async (req) => {
const authenticated = await authStrategyRegistry.authenticate(req);
if (authenticated) {
lastActiveAtService.updateLastActiveIfStale(req.user.id).catch((error) => {
logger.error('Failed to update last active timestamp', { error });
});
eventService.emit('public-api-invoked', {
userId: req.user.id,
path: req.path,
method: req.method,
apiVersion: version,
userAgent: req.headers['user-agent'],
});
}
return authenticated;
};
const globalConfig = di_1.Container.get(config_1.GlobalConfig);
const router = express_1.default.Router();
router.use(openApiValidatorMiddleware({
apiSpec: openApiSpecPath,
operationHandlers: {
basePath: handlersDirectory,
resolver: process.env.VITEST
? importOperationHandlerResolver
: requireOperationHandlerResolver,
},
validateRequests: true,
validateApiSpec: true,
fileUploader: (0, import_package_upload_1.createN8nPackageMulterOptions)(globalConfig),
formats: {
email: {
type: 'string',
validate: (email) => validator_1.default.isEmail(email),
},
identifier: {
type: 'string',
validate: (identifier) => validator_1.default.isUUID(identifier) || validator_1.default.isEmail(identifier),
},
jsonString: {
validate: (data) => {
try {
JSON.parse(data);
return true;
}
catch (e) {
return false;
}
},
},
nanoid: {
type: 'string',
validate: (id) => {
return /^[A-Za-z0-9]{16}$/.test(id);
},
},
},
validateSecurity: {
handlers: {
ApiKeyAuth: authenticate,
BearerAuth: authenticate,
},
},
}));
return router;
})();
cachedRouter = await initPromise;
}
void cachedRouter(req, res, next);
};
}
function createApiRouter(version, openApiSpecPath, handlersDirectory, publicApiEndpoint) {
const globalConfig = di_1.Container.get(config_1.GlobalConfig);
const payloadLimit = `${globalConfig.endpoints.payloadSizeMax}mb`;
const apiController = express_1.default.Router();
if (!globalConfig.publicApi.swaggerUiDisabled) {
apiController.use(`/${publicApiEndpoint}/${version}/docs`, createLazySwaggerMiddleware(openApiSpecPath, publicApiEndpoint, version));
}
apiController.get(`/${publicApiEndpoint}/${version}/openapi.yml`, (_, res) => {
res.header('Access-Control-Allow-Origin', '*');
res.sendFile(openApiSpecPath);
});
const jsonParseErrorHandler = (error, _req, res, next) => {
if (error instanceof SyntaxError && 'body' in error) {
res.status(400).json({
message: 'Invalid JSON in request body',
});
return;
}
next(error);
};
apiController.use(`/${publicApiEndpoint}/${version}`, express_1.default.json({ limit: payloadLimit }), jsonParseErrorHandler, createPublicControllerMiddleware(version), createLazyValidatorMiddleware(openApiSpecPath, handlersDirectory, version));
const publicApiErrorHandler = (error, _req, res, _next) => {
(0, public_api_error_response_1.sendPublicApiErrorResponse)(res, error);
};
apiController.use(publicApiErrorHandler);
return apiController;
}
const loadPublicApiVersions = async (publicApiEndpoint) => {
const folders = await promises_1.default.readdir(__dirname);
const versions = folders.filter((folderName) => folderName.startsWith('v'));
const apiRouters = versions.map((version) => {
const openApiPath = path_1.default.join(__dirname, version, 'openapi.yml');
return createApiRouter(version, openApiPath, __dirname, publicApiEndpoint);
});
const version = versions.pop()?.charAt(1);
return {
apiRouters,
apiLatestVersion: version ? Number(version) : 1,
};
};
exports.loadPublicApiVersions = loadPublicApiVersions;
function isApiEnabled() {
return !di_1.Container.get(config_1.GlobalConfig).publicApi.disabled && !di_1.Container.get(license_1.License).isAPIDisabled();
}
//# sourceMappingURL=index.js.map