@crowdin/app-project-module 0.100.3 → 0.101.0

package/out/index.js

@@ -87,6 +87,7 @@ const projectToolsApp = __importStar(require("./modules/project-tools"));
 const webhooks = __importStar(require("./modules/webhooks"));
 const workflowStepType = __importStar(require("./modules/workflow-step-type"));
 const aiRequestProcessors = __importStar(require("./modules/ai-request-processors"));
+const automationAction = __importStar(require("./modules/automation-action"));
 const subscription_1 = require("./util/subscription");
 var types_2 = require("./types");
 Object.defineProperty(exports, "ProjectPermissions", { enumerable: true, get: function () { return types_2.ProjectPermissions; } });
@@ -220,6 +221,7 @@ function addCrowdinEndpoints(app, clientConfig) {
     webhooks.register({ config, app });
     workflowStepType.register({ config, app });
     aiRequestProcessors.register({ config, app });
+    automationAction.register({ config, app });
     addFormSchema({ config, app });
     return Object.assign(Object.assign({}, exports.metadataStore), { storage: storage.getStorage(), establishCrowdinConnection: (authRequest, moduleKey) => {
             let jwtToken = '';

package/out/middlewares/render-ui-module.js

@@ -26,6 +26,7 @@ function handle(moduleConfig) {
                     : `/api/${moduleConfig.key}/form-data`,
                 formSchema: JSON.stringify(moduleConfig.formSchema),
                 formUiSchema: moduleConfig.formUiSchema ? JSON.stringify(moduleConfig.formUiSchema) : '{}',
+                formPatchDataUrl: moduleConfig.formPatchDataUrl,
             });
         }
         if (moduleConfig.uiPath) {

package/out/middlewares/ui-module.js

@@ -11,6 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 const crowdin_apps_functions_1 = require("@crowdin/crowdin-apps-functions");
 const storage_1 = require("../storage");
+const types_1 = require("../types");
 const util_1 = require("../util");
 const connection_1 = require("../util/connection");
 const logger_1 = require("../util/logger");
@@ -48,16 +49,19 @@ function handle({ config, allowUnauthorized = false, moduleType, }) {
         if (!credentials) {
             throw new Error("Can't find organization by id");
         }
-        logInfo('Building crowdin client instance');
-        const { token } = yield (0, connection_1.prepareCrowdinClient)({ config, credentials, context });
-        const { expired, subscribeLink } = yield (0, subscription_1.checkSubscription)({
-            config,
-            token,
-            organization: credentials.id,
-            accountType: credentials.type,
-        });
-        if (expired) {
-            return res.render('subscription', { subscribeLink });
+        // TODO Skip subscription check here for APP_WITH_CODE
+        if (config.authenticationType !== types_1.AuthenticationType.APP_WITH_CODE) {
+            logInfo('Building crowdin client instance');
+            const { token } = yield (0, connection_1.prepareCrowdinClient)({ config, credentials, context });
+            const { expired, subscribeLink } = yield (0, subscription_1.checkSubscription)({
+                config,
+                token,
+                organization: credentials.id,
+                accountType: credentials.type,
+            });
+            if (expired) {
+                return res.render('subscription', { subscribeLink });
+            }
         }
         next();
     }));

package/out/modules/automation-action/handlers/execute.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="qs" />
+import { Response } from 'express';
+import { CrowdinClientRequest } from '../../../types';
+import { AutomationActionModule } from '../types';
+export default function getExecuteHandler(automationAction: AutomationActionModule): (req: CrowdinClientRequest | import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>, res: Response<any, Record<string, any>>, next: Function) => void;

package/out/modules/automation-action/handlers/execute.js

@@ -0,0 +1,78 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../../../util");
+const logger_1 = require("../../../util/logger");
+const validate_input_1 = require("../util/validate-input");
+// Maximum response size: 250KB
+const MAX_RESPONSE_SIZE = 250 * 1024;
+function getExecuteHandler(automationAction) {
+    return (0, util_1.runAsyncWrapper)((req, res) => __awaiter(this, void 0, void 0, function* () {
+        req.logInfo('Received automation action execute request');
+        const isTaskTokenMode = automationAction.invocationWaitMode === 'taskToken';
+        // In taskToken mode, respond immediately to prevent Crowdin retries
+        // Execution continues asynchronously, communicating via API calls
+        if (isTaskTokenMode) {
+            res.status(200).send();
+        }
+        try {
+            let validationErrors;
+            let inputData = req.body.formData || req.body;
+            if (automationAction.inputSchema) {
+                req.logInfo('Validate automation input data');
+                const { errors, data } = (0, validate_input_1.validateAutomationData)({
+                    data: req.body,
+                    schema: automationAction.inputSchema,
+                });
+                validationErrors = errors;
+                inputData = data;
+            }
+            const result = yield automationAction.execute({
+                client: req.crowdinApiClient,
+                inputData,
+                validationErrors,
+                context: req.crowdinContext,
+                req: req.body,
+            });
+            if (result) {
+                const responseJson = JSON.stringify(result);
+                const responseSize = Buffer.byteLength(responseJson, 'utf8');
+                // Check response size before sending
+                if (responseSize > MAX_RESPONSE_SIZE) {
+                    throw new Error(`Response size (${responseSize} bytes) exceeds the maximum allowed size of ${MAX_RESPONSE_SIZE} bytes (250KB)`);
+                }
+            }
+            if (automationAction.validateOutputData !== false && result && automationAction.outputSchema) {
+                req.logInfo('Validate automation output data');
+                const { errors } = (0, validate_input_1.validateAutomationData)({
+                    data: result,
+                    schema: automationAction.outputSchema,
+                    preserveEmptyArrays: true,
+                });
+                if (errors) {
+                    throw new Error(JSON.stringify(errors));
+                }
+            }
+            if (!isTaskTokenMode) {
+                res.json({
+                    data: result,
+                });
+            }
+        }
+        catch (error) {
+            req.logError(error);
+            if (!isTaskTokenMode) {
+                res.status(500).send({ error: { message: (0, logger_1.getErrorMessage)(error) } });
+            }
+        }
+    }));
+}
+exports.default = getExecuteHandler;

package/out/modules/automation-action/handlers/input-schema.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="qs" />
+import { Response } from 'express';
+import { AutomationActionModule } from '../types';
+import { CrowdinClientRequest } from '../../../types';
+export default function getInputSchemaHandler(automationAction: AutomationActionModule): (req: CrowdinClientRequest | import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>, res: Response<any, Record<string, any>>, next: Function) => void;

package/out/modules/automation-action/handlers/input-schema.js

@@ -0,0 +1,29 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = require("../../../util/logger");
+const util_1 = require("../../../util");
+function getInputSchemaHandler(automationAction) {
+    return (0, util_1.runAsyncWrapper)((req, res) => __awaiter(this, void 0, void 0, function* () {
+        try {
+            let schema = {};
+            if (automationAction.inputSchema) {
+                schema = automationAction.inputSchema;
+            }
+            res.json(schema);
+        }
+        catch (error) {
+            req.logError(error);
+            res.status(500).send({ error: { message: (0, logger_1.getErrorMessage)(error) } });
+        }
+    }));
+}
+exports.default = getInputSchemaHandler;

package/out/modules/automation-action/handlers/output-schema.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="qs" />
+import { Response } from 'express';
+import { AutomationActionModule } from '../types';
+import { CrowdinClientRequest } from '../../../types';
+export default function getOutputSchemaHandler(automationAction: AutomationActionModule): (req: CrowdinClientRequest | import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>, res: Response<any, Record<string, any>>, next: Function) => void;

package/out/modules/automation-action/handlers/output-schema.js

@@ -0,0 +1,29 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = require("../../../util/logger");
+const util_1 = require("../../../util");
+function getOutputSchemaHandler(automationAction) {
+    return (0, util_1.runAsyncWrapper)((req, res) => __awaiter(this, void 0, void 0, function* () {
+        try {
+            let schema = {};
+            if (automationAction.outputSchema) {
+                schema = automationAction.outputSchema;
+            }
+            res.json(schema);
+        }
+        catch (error) {
+            req.logError(error);
+            res.status(500).send({ error: { message: (0, logger_1.getErrorMessage)(error) } });
+        }
+    }));
+}
+exports.default = getOutputSchemaHandler;

package/out/modules/automation-action/handlers/validate-settings.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="qs" />
+import { Response } from 'express';
+import { AutomationActionModule } from '../types';
+import { CrowdinClientRequest } from '../../../types';
+export default function getInputSchemaHandler(automationAction: AutomationActionModule): (req: CrowdinClientRequest | import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>, res: Response<any, Record<string, any>>, next: Function) => void;

package/out/modules/automation-action/handlers/validate-settings.js

@@ -0,0 +1,35 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = require("../../../util/logger");
+const util_1 = require("../../../util");
+function getInputSchemaHandler(automationAction) {
+    return (0, util_1.runAsyncWrapper)((req, res) => __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        try {
+            let result = {};
+            if (automationAction.validateSettings) {
+                result = yield automationAction.validateSettings({
+                    client: req.crowdinApiClient,
+                    settings: ((_a = req === null || req === void 0 ? void 0 : req.body) === null || _a === void 0 ? void 0 : _a.settings) || [],
+                    context: req.crowdinContext,
+                    req: req.body,
+                });
+            }
+            res.json(result);
+        }
+        catch (error) {
+            req.logError(error);
+            res.status(500).send({ error: { message: (0, logger_1.getErrorMessage)(error) } });
+        }
+    }));
+}
+exports.default = getInputSchemaHandler;

package/out/modules/automation-action/index.d.ts

@@ -0,0 +1,6 @@
+import { Express } from 'express';
+import { Config } from '../../types';
+export declare function register({ config, app }: {
+    config: Config;
+    app: Express;
+}): void;

package/out/modules/automation-action/index.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = void 0;
+const cors_1 = __importDefault(require("cors"));
+const output_schema_1 = __importDefault(require("./handlers/output-schema"));
+const input_schema_1 = __importDefault(require("./handlers/input-schema"));
+const validate_settings_1 = __importDefault(require("./handlers/validate-settings"));
+const execute_1 = __importDefault(require("./handlers/execute"));
+const util_1 = require("./util");
+const crowdin_client_1 = __importDefault(require("../../middlewares/crowdin-client"));
+const ui_module_1 = __importDefault(require("../../middlewares/ui-module"));
+const render_ui_module_1 = __importDefault(require("../../middlewares/render-ui-module"));
+function register({ config, app }) {
+    if (!config.automationAction) {
+        return;
+    }
+    const automationActions = Array.isArray(config.automationAction)
+        ? config.automationAction
+        : [config.automationAction];
+    for (const automationAction of automationActions) {
+        app.options((0, util_1.getAutomationActionUrl)('/automation-action/output-schema', automationAction), (0, cors_1.default)());
+        app.get((0, util_1.getAutomationActionUrl)('/automation-action/output-schema', automationAction), (0, cors_1.default)(), (0, output_schema_1.default)(automationAction));
+        app.options((0, util_1.getAutomationActionUrl)('/automation-action/input-schema', automationAction), (0, cors_1.default)());
+        app.get((0, util_1.getAutomationActionUrl)('/automation-action/input-schema', automationAction), (0, cors_1.default)(), (0, input_schema_1.default)(automationAction));
+        app.post((0, util_1.getAutomationActionUrl)('/automation-action/validate-settings', automationAction), (0, crowdin_client_1.default)({
+            config,
+            optional: true,
+            checkSubscriptionExpiration: false,
+            moduleKey: automationAction.key,
+        }), (0, validate_settings_1.default)(automationAction));
+        app.post((0, util_1.getAutomationActionUrl)('/automation-action/execute', automationAction), (0, cors_1.default)(), (0, crowdin_client_1.default)({
+            config,
+            optional: true,
+            checkSubscriptionExpiration: false,
+            moduleKey: automationAction.key,
+        }), (0, execute_1.default)(automationAction));
+        if (automationAction.settingsUiModule) {
+            app.use((0, util_1.getAutomationActionUrl)('/automation-action', automationAction), (0, ui_module_1.default)({ config, moduleType: automationAction.key }), (0, render_ui_module_1.default)(automationAction.settingsUiModule));
+        }
+    }
+}
+exports.register = register;

package/out/modules/automation-action/types.d.ts

@@ -0,0 +1,49 @@
+import { CrowdinContextInfo, ImagePath, ModuleKey, UiModule } from '../../types';
+import Crowdin from '@crowdin/crowdin-api-client';
+export interface AutomationActionModule extends ModuleKey, ImagePath {
+    /**
+     * module name
+     */
+    name: string;
+    /**
+     * module description
+     */
+    description?: string;
+    /**
+     * invocation wait mode, default is sync
+     */
+    invocationWaitMode?: 'sync' | 'taskToken';
+    /**
+     * JSON schema defining the structure of data returned by the automation action
+     */
+    outputSchema?: any;
+    /**
+     * JSON schema defining the structure of input parameters expected by the automation action
+     */
+    inputSchema?: any;
+    validateSettings?: ({ client, settings, context, req, }: {
+        client: Crowdin;
+        settings: any;
+        context: CrowdinContextInfo;
+        req: any;
+    }) => Promise<any>;
+    /**
+     * function to execute the automation action
+     */
+    execute: ({ client, inputData, validationErrors, context, req, }: {
+        client: Crowdin;
+        inputData: any;
+        validationErrors?: Record<string, string> | undefined;
+        context: CrowdinContextInfo;
+        req: any;
+    }) => Promise<any>;
+    /**
+     * Settings UI module
+     */
+    settingsUiModule?: UiModule;
+    /**
+     * validate output data, default: true
+     * set to false to skip output validation
+     */
+    validateOutputData?: boolean;
+}

package/out/modules/automation-action/types.js

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

package/out/modules/automation-action/util/index.d.ts

@@ -0,0 +1,3 @@
+import { AutomationActionModule } from '../types';
+export declare function getAutomationActionKey(automationAction: AutomationActionModule): string;
+export declare function getAutomationActionUrl(path: string, automationAction: AutomationActionModule): string;

package/out/modules/automation-action/util/index.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAutomationActionUrl = exports.getAutomationActionKey = void 0;
+const lodash_kebabcase_1 = __importDefault(require("lodash.kebabcase"));
+function getAutomationActionKey(automationAction) {
+    return (0, lodash_kebabcase_1.default)(automationAction.name);
+}
+exports.getAutomationActionKey = getAutomationActionKey;
+function getAutomationActionUrl(path, automationAction) {
+    return `${path}/${automationAction.key}`;
+}
+exports.getAutomationActionUrl = getAutomationActionUrl;

package/out/modules/automation-action/util/validate-input.d.ts

@@ -0,0 +1,9 @@
+export declare function validateAutomationData({ data, schema, preserveEmptyArrays, }: {
+    data: any;
+    schema: any;
+    preserveEmptyArrays?: boolean;
+}): {
+    valid: boolean;
+    errors: Record<string, string> | undefined;
+    data: any;
+};

package/out/modules/automation-action/util/validate-input.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAutomationData = void 0;
+const ajv_1 = __importDefault(require("ajv"));
+const ajv = new ajv_1.default({ allErrors: true, strict: false, coerceTypes: true });
+function formatAjvErrors(errors = []) {
+    if (!errors.length) {
+        return undefined;
+    }
+    return errors.reduce((acc, err) => {
+        const path = err.instancePath || '/';
+        acc[path] = err.message || '';
+        return acc;
+    }, {});
+}
+function removeEmptyValues(obj, options = { preserveEmptyArrays: true }) {
+    const { preserveEmptyArrays = true } = options;
+    if (Array.isArray(obj)) {
+        return obj
+            .map((item) => removeEmptyValues(item, options))
+            .filter((v) => v !== undefined &&
+            v !== null &&
+            !(Array.isArray(v) && v.length === 0 && !preserveEmptyArrays) &&
+            !(typeof v === 'object' && Object.keys(v).length === 0));
+    }
+    if (typeof obj === 'object' && obj !== null) {
+        const newObj = {};
+        for (const [key, value] of Object.entries(obj)) {
+            if (value === undefined) {
+                continue;
+            }
+            const cleanedValue = removeEmptyValues(value, options);
+            if (cleanedValue !== '' &&
+                cleanedValue !== null &&
+                cleanedValue !== undefined &&
+                !(Array.isArray(cleanedValue) && cleanedValue.length === 0 && !preserveEmptyArrays) &&
+                !(typeof cleanedValue === 'object' &&
+                    !Array.isArray(cleanedValue) &&
+                    Object.keys(cleanedValue).length === 0)) {
+                newObj[key] = cleanedValue;
+            }
+        }
+        return newObj;
+    }
+    return obj;
+}
+function validateAutomationData({ data, schema, preserveEmptyArrays = false, }) {
+    const cleaned = removeEmptyValues(data, { preserveEmptyArrays });
+    const validate = ajv.compile(schema);
+    const valid = validate(cleaned);
+    return {
+        valid: Boolean(valid),
+        errors: formatAjvErrors((validate === null || validate === void 0 ? void 0 : validate.errors) || []),
+        data: cleaned,
+    };
+}
+exports.validateAutomationData = validateAutomationData;

package/out/modules/install.js

@@ -54,7 +54,7 @@ function handle(config) {
 }
 exports.default = handle;
 function fetchToken(config, event) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
     return __awaiter(this, void 0, void 0, function* () {
         if (config.authenticationType === types_1.AuthenticationType.CODE) {
             const token = yield (0, crowdin_apps_functions_1.generateOAuthToken)({
@@ -86,6 +86,23 @@ function fetchToken(config, event) {
                 refreshToken: '',
             };
         }
+        if (config.authenticationType === types_1.AuthenticationType.APP_WITH_CODE) {
+            const token = yield (0, crowdin_apps_functions_1.fetchAppWithCodeToken)({
+                appId: config.identifier,
+                appSecret: event.appSecret,
+                clientId: config.clientId,
+                clientSecret: config.clientSecret,
+                domain: event.domain || '',
+                userId: event.userId,
+                code: event.code,
+                url: (_c = config.crowdinUrls) === null || _c === void 0 ? void 0 : _c.accountUrl,
+            });
+            return {
+                accessToken: (0, util_1.encryptData)(config, token.accessToken),
+                expiresIn: token.expiresIn,
+                refreshToken: '',
+            };
+        }
         const token = yield (0, crowdin_apps_functions_1.fetchAppToken)({
             appId: config.identifier,
             appSecret: event.appSecret,
@@ -93,7 +110,7 @@ function fetchToken(config, event) {
             clientSecret: config.clientSecret,
             domain: event.domain || '',
             userId: event.userId,
-            url: (_c = config.crowdinUrls) === null || _c === void 0 ? void 0 : _c.accountUrl,
+            url: (_d = config.crowdinUrls) === null || _d === void 0 ? void 0 : _d.accountUrl,
         });
         return {
             accessToken: (0, util_1.encryptData)(config, token.accessToken),

package/out/modules/manifest.js

@@ -6,6 +6,7 @@ const subscription_1 = require("../util/subscription");
 const api_1 = require("./api/api");
 const util_2 = require("./ai-tools/util");
 const util_3 = require("./workflow-step-type/util");
+const index_1 = require("./automation-action/util/index");
 const ai_request_processors_1 = require("./ai-request-processors");
 function normalizeEnvironments(environments) {
     if (Array.isArray(environments)) {
@@ -382,6 +383,30 @@ function handle(config) {
             modules['workflow-step-type'].push(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ key: workflowStep.key, name: workflowStep.name || config.name }, ((workflowStep === null || workflowStep === void 0 ? void 0 : workflowStep.imagePath) ? { logo: (0, util_1.getLogoUrl)(workflowStep, `-${workflowStep.key}`) } : {})), { description: workflowStep.description || config.description, boundaries: workflowStep.boundaries }), (workflowStep.editorMode ? { editorMode: workflowStep.editorMode } : {})), { updateSettingsUrl: (0, util_3.getWorkflowStepUrl)('/workflow-step/settings', workflowStep), deleteSettingsUrl: (0, util_3.getWorkflowStepUrl)('/workflow-step/delete', workflowStep) }), (uiModule ? { url: (0, util_3.getWorkflowStepUrl)('/workflow-step', workflowStep) } : {})));
         }
     }
+    if (config.automationAction) {
+        // prevent possible overrides of the other modules
+        if (Array.isArray(config.automationAction)) {
+            config.automationAction = config.automationAction.map((automationAction) => (Object.assign({}, automationAction)));
+        }
+        else {
+            config.automationAction = Object.assign({}, config.automationAction);
+        }
+        const automationActions = Array.isArray(config.automationAction)
+            ? config.automationAction
+            : [config.automationAction];
+        modules['automation-action'] = [];
+        for (const automationAction of automationActions) {
+            if (!automationAction.key) {
+                automationAction.key = config.identifier + '-' + (0, index_1.getAutomationActionKey)(automationAction);
+            }
+            const uiModule = automationAction.settingsUiModule;
+            modules['automation-action'].push(Object.assign(Object.assign(Object.assign(Object.assign({ key: automationAction.key, name: automationAction.name || config.name, description: automationAction.description || config.description }, (automationAction.outputSchema
+                ? { outputSchemaUrl: (0, index_1.getAutomationActionUrl)('/automation-action/output-schema', automationAction) }
+                : {})), (automationAction.inputSchema
+                ? { inputSchemaUrl: (0, index_1.getAutomationActionUrl)('/automation-action/input-schema', automationAction) }
+                : {})), { validateSettingsUrl: (0, index_1.getAutomationActionUrl)('/automation-action/validate-settings', automationAction), executeUrl: (0, index_1.getAutomationActionUrl)('/automation-action/execute', automationAction), invocationWaitMode: automationAction.invocationWaitMode || 'sync' }), (uiModule ? { url: (0, index_1.getAutomationActionUrl)('/automation-action', automationAction) } : {})));
+        }
+    }
     const events = {
         installed: '/installed',
         uninstall: '/uninstall',