n8n-nodes-elearning-magic 0.1.11 → 0.1.13

package/dist/nodes/ElearningMagic/ElearningMagicTrigger.node.d.ts

@@ -1,5 +1,9 @@
-import type { INodeType, INodeTypeDescription, IWebhookFunctions, IWebhookResponseData } from 'n8n-workflow';
-export declare class ElearningMagicTrigger implements INodeType {
+import type { IWebhookFunctions, INodeTypeDescription, IWebhookResponseData } from 'n8n-workflow';
+import { Node } from 'n8n-workflow';
+export declare class ElearningMagicTrigger extends Node {
+    authPropertyName: string;
     description: INodeTypeDescription;
-    webhook(this: IWebhookFunctions): Promise<IWebhookResponseData>;
+    webhook(context: IWebhookFunctions): Promise<IWebhookResponseData>;
+    private validateAuth;
+    private handleBinaryData;
 }

package/dist/nodes/ElearningMagic/ElearningMagicTrigger.node.js

@@ -1,83 +1,84 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ElearningMagicTrigger = void 0;
-const crypto_1 = require("crypto");
-const computeSignature = (secret, rawBody) => {
-    return (0, crypto_1.createHmac)('sha256', secret).update(rawBody).digest('hex');
-};
-const safeCompare = (a, b) => {
-    if (!a || !b || a.length !== b.length) {
-        return false;
-    }
-    try {
-        return (0, crypto_1.timingSafeEqual)(Buffer.from(a), Buffer.from(b));
-    }
-    catch {
-        return false;
-    }
-};
-class ElearningMagicTrigger {
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const promises_2 = require("stream/promises");
+const tmp_promise_1 = require("tmp-promise");
+const uuid_1 = require("uuid");
+const isbot_1 = __importDefault(require("isbot"));
+const n8n_workflow_1 = require("n8n-workflow");
+const description_1 = require("./description");
+const error_1 = require("./error");
+const utils_1 = require("./utils");
+class ElearningMagicTrigger extends n8n_workflow_1.Node {
     constructor() {
+        super(...arguments);
+        this.authPropertyName = 'authentication';
         this.description = {
             displayName: 'eLearning Magic',
-            name: 'elearningMagicTrigger',
             icon: 'file:elearningMagic.svg',
+            name: 'elearningMagicTrigger',
             group: ['trigger'],
-            version: 1,
-            description: 'Receive SCORM wrapper payloads from eLearning Magic via a signed webhook',
+            version: [1],
+            defaultVersion: 1,
+            description: 'Starts the workflow when eLearning Magic calls this webhook',
+            eventTriggerDescription: 'Waiting for you to call the Test URL',
+            activationMessage: 'You can now make calls to your production webhook URL.',
             defaults: {
                 name: 'eLearning Magic',
             },
-            subtitle: '={{$parameter["path"]}}',
-            inputs: [],
-            outputs: ['main'],
+            supportsCORS: true,
             triggerPanel: {
-                header: 'Webhook URLs',
+                header: '',
                 executionsHelp: {
-                    inactive: 'Webhooks have two modes: test and production. <br /> <br /> <b>Use test mode while you build your workflow</b>. Click the \'Execute workflow\' button, then make a request to the test URL. The executions will show up in the editor.<br /> <br /> <b>Use production mode to run your workflow automatically</b>. Activate the workflow, then make requests to the production URL. These executions will show up in the executions list, but not in the editor.',
-                    active: 'Webhooks have two modes: test and production. <br /> <br /> <b>Use test mode while you build your workflow</b>. Click the \'Execute workflow\' button, then make a request to the test URL. The executions will show up in the editor.<br /> <br /> <b>Use production mode to run your workflow automatically</b>. Since the workflow is activated, requests to the production URL will trigger executions. These executions will show up in the executions list, but not in the editor.',
-                },
-                activationHint: {
-                    active: 'This node will also trigger automatically on new webhook requests (but those executions won\'t show up here).',
-                    inactive: 'Activate this workflow to have it also run automatically for new webhook requests via the production URL.',
+                    inactive: "Webhooks have two modes: test and production. <br /> <br /> <b>Use test mode while you build your workflow</b>. Click the 'listen' button, then make a request to the test URL. The executions will show up in the editor.<br /> <br /> <b>Use production mode to run your workflow automatically</b>. Publish the workflow, then make requests to the production URL. These executions will show up in the executions list, but not in the editor.",
+                    active: 'Webhooks have two modes: test and production. <br /> <br /> <b>Use test mode while you build your workflow</b>. Click the \'listen\' button, then make a request to the test URL. The executions will show up in the editor.<br /> <br /> <b>Use production mode to run your workflow automatically</b>. Since the workflow is activated, you can make requests to the production URL. These executions will show up in the executions list, but not in the editor.',
                 },
+                activationHint: "Once you've finished building your workflow, run it without having to click this button by using the production webhook URL.",
             },
-            credentials: [
-                {
-                    name: 'elearningMagicApi',
-                    required: false,
-                },
-            ],
-            webhooks: [
+            inputs: [],
+            outputs: `={{(${utils_1.configuredOutputs})($parameter)}}`,
+            credentials: (0, description_1.credentialsProperty)(this.authPropertyName),
+            webhooks: [description_1.defaultWebhookDescription],
+            properties: [
                 {
-                    name: 'default',
-                    httpMethod: 'POST',
-                    responseMode: 'onReceived',
-                    path: '={{$parameter["path"]}}',
-                    restartWebhook: true,
+                    displayName: 'Allow Multiple HTTP Methods',
+                    name: 'multipleMethods',
+                    type: 'boolean',
+                    default: false,
+                    isNodeSetting: true,
+                    description: 'Whether to allow the webhook to listen for multiple HTTP methods',
                 },
-            ],
-            properties: [
                 {
-                    displayName: '<strong>📌 Webhook URL for your eLearning Magic App:</strong><br><br>' +
-                        'The production URL below is auto-generated from your n8n base URL (WEBHOOK_URL / N8N_WEBHOOK_URL / N8N_HOST) and the Path value.',
-                    name: 'webhookUrlNotice',
-                    type: 'notice',
-                    default: '',
+                    ...description_1.httpMethodsProperty,
+                    displayOptions: {
+                        show: {
+                            multipleMethods: [false],
+                        },
+                    },
                 },
                 {
-                    displayName: 'Production Webhook URL (auto-generated)',
-                    name: 'productionWebhookUrl',
-                    type: 'string',
-                    default: '={{ ' +
-                        '((($env.WEBHOOK_URL || $env.N8N_WEBHOOK_URL) || ' +
-                        "($env.N8N_HOST ? ('https://' + $env.N8N_HOST + ($env.N8N_PORT ? (':' + $env.N8N_PORT) : '')) : 'https://YOUR-N8N-INSTANCE'))" +
-                        " + '/webhook/' + $parameter['path']" +
-                        ' ) }}',
-                    description: 'Copy this URL into the eLearning Magic app when configuring the connection. Change Path to update it.',
-                    placeholder: 'https://your-n8n-server/webhook/elearning-magic',
-                    typeOptions: {
-                        rows: 2,
+                    displayName: 'HTTP Methods',
+                    name: 'httpMethod',
+                    type: 'multiOptions',
+                    options: [
+                        { name: 'DELETE', value: 'DELETE' },
+                        { name: 'GET', value: 'GET' },
+                        { name: 'HEAD', value: 'HEAD' },
+                        { name: 'PATCH', value: 'PATCH' },
+                        { name: 'POST', value: 'POST' },
+                        { name: 'PUT', value: 'PUT' },
+                    ],
+                    default: ['GET', 'POST'],
+                    description: 'The HTTP methods to listen to',
+                    displayOptions: {
+                        show: {
+                            multipleMethods: [true],
+                        },
                     },
                 },
                 {
@@ -85,56 +86,187 @@ class ElearningMagicTrigger {
                     name: 'path',
                     type: 'string',
                     default: 'elearning-magic',
-                    placeholder: 'elearning-magic',
-                    required: true,
-                    description: 'The path segment for the webhook URL',
+                    placeholder: 'webhook',
+                    description: "The path to listen to, dynamic values could be specified by using ':', e.g. 'your-path/:dynamic-value'. If dynamic values are set 'webhookId' would be prepended to path.",
+                },
+                (0, description_1.authenticationProperty)(this.authPropertyName),
+                description_1.responseModeProperty,
+                description_1.responseModePropertyStreaming,
+                {
+                    displayName: 'Insert a \'Respond to Webhook\' node to control when and how you respond. <a href="https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.respondtowebhook/" target="_blank">More details</a>',
+                    name: 'webhookNotice',
+                    type: 'notice',
+                    displayOptions: {
+                        show: {
+                            responseMode: ['responseNode'],
+                        },
+                    },
+                    default: '',
+                },
+                {
+                    displayName: 'Insert a node that supports streaming (e.g. \'AI Agent\') and enable streaming to stream directly to the response while the workflow is executed. <a href="https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.respondtowebhook/" target="_blank">More details</a>',
+                    name: 'webhookStreamingNotice',
+                    type: 'notice',
+                    displayOptions: {
+                        show: {
+                            responseMode: ['streaming'],
+                        },
+                    },
+                    default: '',
+                },
+                {
+                    ...description_1.responseCodeProperty,
+                    displayOptions: {
+                        show: {
+                            '@version': [1],
+                        },
+                        hide: {
+                            responseMode: ['responseNode'],
+                        },
+                    },
+                },
+                description_1.responseDataProperty,
+                description_1.responseBinaryPropertyNameProperty,
+                {
+                    displayName: 'If you are sending back a response, add a "Content-Type" response header with the appropriate value to avoid unexpected behavior',
+                    name: 'contentTypeNotice',
+                    type: 'notice',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            responseMode: ['onReceived'],
+                        },
+                    },
+                },
+                {
+                    ...description_1.optionsProperty,
+                    options: [...description_1.optionsProperty.options, description_1.responseCodeOption].sort((a, b) => {
+                        const nameA = a.displayName.toUpperCase();
+                        const nameB = b.displayName.toUpperCase();
+                        if (nameA < nameB)
+                            return -1;
+                        if (nameA > nameB)
+                            return 1;
+                        return 0;
+                    }),
                 },
             ],
         };
     }
-    async webhook() {
-        const req = this.getRequestObject();
-        const res = this.getResponseObject();
-        const credentials = await this.getCredentials('elearningMagicApi');
-        const signingSecret = (credentials === null || credentials === void 0 ? void 0 : credentials.signingSecret) || '';
-        const rawBody = req.rawBody !== undefined
-            ? req.rawBody.toString('utf8')
-            : JSON.stringify(req.body || {});
-        const headerSignature = req.headers['x-em-signature'] || '';
-        let signatureValid = false;
-        if (headerSignature && signingSecret) {
-            const computed = computeSignature(signingSecret, rawBody);
-            signatureValid = safeCompare(computed, headerSignature);
+    async webhook(context) {
+        var _a, _b, _c, _d;
+        const { typeVersion: nodeVersion } = context.getNode();
+        const responseMode = context.getNodeParameter('responseMode', 'onReceived');
+        (0, utils_1.checkResponseModeConfiguration)(context);
+        const options = context.getNodeParameter('options', {});
+        const req = context.getRequestObject();
+        const resp = context.getResponseObject();
+        const requestMethod = req.method;
+        if (!(0, utils_1.isIpWhitelisted)(options.ipWhitelist, req.ips, req.ip)) {
+            resp.writeHead(403);
+            resp.end('IP is not whitelisted to access the webhook!');
+            return { noWebhookResponse: true };
         }
-        if (!signingSecret) {
-            res.status(401);
-            return {
-                webhookResponse: { error: 'Signing secret is not configured on this node' },
-            };
+        let validationData;
+        try {
+            if (options.ignoreBots && (0, isbot_1.default)(req.headers['user-agent']))
+                throw new error_1.WebhookAuthorizationError(403);
+            validationData = await this.validateAuth(context);
         }
-        if (!headerSignature || !signatureValid) {
-            res.status(403);
-            return {
-                webhookResponse: { error: 'Invalid or missing X-EM-Signature header' },
-            };
+        catch (error) {
+            if (error instanceof error_1.WebhookAuthorizationError) {
+                resp.writeHead(error.responseCode, { 'WWW-Authenticate': 'Basic realm="Webhook"' });
+                resp.end(error.message);
+                return { noWebhookResponse: true };
+            }
+            throw error;
+        }
+        const prepareOutput = (0, utils_1.setupOutputConnection)(context, requestMethod, {
+            jwtPayload: validationData,
+        });
+        if (options.binaryData) {
+            return await this.handleBinaryData(context, prepareOutput);
+        }
+        if (req.contentType === 'multipart/form-data') {
+            return await (0, utils_1.handleFormData)(context, prepareOutput);
+        }
+        if (nodeVersion > 1 && !req.body && !options.rawBody) {
+            try {
+                return await this.handleBinaryData(context, prepareOutput);
+            }
+            catch (error) { }
+        }
+        if (options.rawBody && !req.rawBody) {
+            await ((_b = (_a = req).readRawBody) === null || _b === void 0 ? void 0 : _b.call(_a));
         }
-        const payload = {
+        const response = {
             json: {
-                body: req.body,
-                query: req.query,
                 headers: req.headers,
-                meta: {
-                    receivedAt: new Date().toISOString(),
-                    signatureValid,
-                    webhookPath: req.url,
-                },
+                params: req.params,
+                query: req.query,
+                body: req.body,
             },
+            binary: options.rawBody
+                ? {
+                    data: {
+                        data: ((_c = req.rawBody) !== null && _c !== void 0 ? _c : '').toString(n8n_workflow_1.BINARY_ENCODING),
+                        mimeType: (_d = req.contentType) !== null && _d !== void 0 ? _d : 'application/json',
+                    },
+                }
+                : undefined,
         };
-        res.status(200);
+        if (responseMode === 'streaming') {
+            const res = context.getResponseObject();
+            res.writeHead(200, {
+                'Content-Type': 'application/json; charset=utf-8',
+                'Transfer-Encoding': 'chunked',
+                'Cache-Control': 'no-cache',
+                Connection: 'keep-alive',
+            });
+            res.flushHeaders();
+            return {
+                noWebhookResponse: true,
+                workflowData: prepareOutput(response),
+            };
+        }
         return {
-            webhookResponse: { received: true },
-            workflowData: [this.helpers.returnJsonArray([payload.json])],
+            webhookResponse: options.responseData,
+            workflowData: prepareOutput(response),
         };
     }
+    async validateAuth(context) {
+        return await (0, utils_1.validateWebhookAuthentication)(context, this.authPropertyName);
+    }
+    async handleBinaryData(context, prepareOutput) {
+        var _a, _b, _c, _d;
+        const req = context.getRequestObject();
+        const options = context.getNodeParameter('options', {});
+        const binaryFile = await (0, tmp_promise_1.file)({ prefix: 'elearning-magic-webhook-' });
+        try {
+            await (0, promises_2.pipeline)(req, (0, fs_1.createWriteStream)(binaryFile.path));
+            const returnItem = {
+                json: {
+                    headers: req.headers,
+                    params: req.params,
+                    query: req.query,
+                    body: {},
+                },
+            };
+            const stats = await (0, promises_1.stat)(binaryFile.path);
+            if (stats.size) {
+                const binaryPropertyName = ((_a = options.binaryPropertyName) !== null && _a !== void 0 ? _a : 'data');
+                const fileName = (_c = (_b = req.contentDisposition) === null || _b === void 0 ? void 0 : _b.filename) !== null && _c !== void 0 ? _c : (0, uuid_1.v4)();
+                const binaryData = await context.nodeHelpers.copyBinaryFile(binaryFile.path, fileName, (_d = req.contentType) !== null && _d !== void 0 ? _d : 'application/octet-stream');
+                returnItem.binary = { [binaryPropertyName]: binaryData };
+            }
+            return { workflowData: prepareOutput(returnItem) };
+        }
+        catch (error) {
+            throw new n8n_workflow_1.NodeOperationError(context.getNode(), error);
+        }
+        finally {
+            await binaryFile.cleanup();
+        }
+    }
 }
 exports.ElearningMagicTrigger = ElearningMagicTrigger;

package/dist/nodes/ElearningMagic/description.d.ts

@@ -0,0 +1,13 @@
+import type { INodeProperties, INodeTypeDescription, IWebhookDescription } from 'n8n-workflow';
+export declare const defaultWebhookDescription: IWebhookDescription;
+export declare const credentialsProperty: (propertyName?: string) => INodeTypeDescription["credentials"];
+export declare const authenticationProperty: (propertyName?: string) => INodeProperties;
+export declare const httpMethodsProperty: INodeProperties;
+export declare const responseCodeProperty: INodeProperties;
+export declare const responseModeProperty: INodeProperties;
+export declare const responseModePropertyStreaming: INodeProperties;
+export declare const responseDataProperty: INodeProperties;
+export declare const responseBinaryPropertyNameProperty: INodeProperties;
+export declare const optionsProperty: INodeProperties;
+export declare const responseCodeSelector: INodeProperties;
+export declare const responseCodeOption: INodeProperties;

package/dist/nodes/ElearningMagic/description.js

@@ -0,0 +1,421 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.responseCodeOption = exports.responseCodeSelector = exports.optionsProperty = exports.responseBinaryPropertyNameProperty = exports.responseDataProperty = exports.responseModePropertyStreaming = exports.responseModeProperty = exports.responseCodeProperty = exports.httpMethodsProperty = exports.authenticationProperty = exports.credentialsProperty = exports.defaultWebhookDescription = void 0;
+const utils_1 = require("./utils");
+exports.defaultWebhookDescription = {
+    name: 'default',
+    httpMethod: '={{$parameter["httpMethod"] || "GET"}}',
+    isFullPath: true,
+    responseCode: `={{(${utils_1.getResponseCode})($parameter)}}`,
+    responseMode: '={{$parameter["responseMode"]}}',
+    responseData: `={{(${utils_1.getResponseData})($parameter)}}`,
+    responseBinaryPropertyName: '={{$parameter["responseBinaryPropertyName"]}}',
+    responseContentType: '={{$parameter["options"]["responseContentType"]}}',
+    responsePropertyName: '={{$parameter["options"]["responsePropertyName"]}}',
+    responseHeaders: '={{$parameter["options"]["responseHeaders"]}}',
+    path: '={{$parameter["path"]}}',
+};
+const credentialsProperty = (propertyName = 'authentication') => [
+    {
+        name: 'elearningMagicApi',
+        required: true,
+        displayOptions: {
+            show: {
+                [propertyName]: ['signingSecret'],
+            },
+        },
+    },
+];
+exports.credentialsProperty = credentialsProperty;
+const authenticationProperty = (propertyName = 'authentication') => ({
+    displayName: 'Authentication',
+    name: propertyName,
+    type: 'options',
+    options: [
+        {
+            name: 'Signing Secret (X-EM-Signature)',
+            value: 'signingSecret',
+        },
+        {
+            name: 'None',
+            value: 'none',
+        },
+    ],
+    default: 'signingSecret',
+    description: 'Verify requests using your eLearning Magic signing secret header',
+});
+exports.authenticationProperty = authenticationProperty;
+exports.httpMethodsProperty = {
+    displayName: 'HTTP Method',
+    name: 'httpMethod',
+    type: 'options',
+    options: [
+        { name: 'DELETE', value: 'DELETE' },
+        { name: 'GET', value: 'GET' },
+        { name: 'HEAD', value: 'HEAD' },
+        { name: 'PATCH', value: 'PATCH' },
+        { name: 'POST', value: 'POST' },
+        { name: 'PUT', value: 'PUT' },
+    ],
+    default: 'GET',
+    description: 'The HTTP method to listen to',
+};
+exports.responseCodeProperty = {
+    displayName: 'Response Code',
+    name: 'responseCode',
+    type: 'number',
+    displayOptions: {
+        hide: {
+            responseMode: ['responseNode'],
+        },
+    },
+    typeOptions: {
+        minValue: 100,
+        maxValue: 599,
+    },
+    default: 200,
+    description: 'The HTTP Response code to return',
+};
+const responseModeOptions = [
+    {
+        name: 'Immediately',
+        value: 'onReceived',
+        description: 'As soon as this node executes',
+    },
+    {
+        name: 'When Last Node Finishes',
+        value: 'lastNode',
+        description: 'Returns data of the last-executed node',
+    },
+    {
+        name: "Using 'Respond to Webhook' Node",
+        value: 'responseNode',
+        description: 'Response defined in that node',
+    },
+];
+exports.responseModeProperty = {
+    displayName: 'Respond',
+    name: 'responseMode',
+    type: 'options',
+    options: responseModeOptions,
+    default: 'onReceived',
+    description: 'When and how to respond to the webhook',
+    displayOptions: {
+        show: {
+            '@version': [1],
+        },
+    },
+};
+exports.responseModePropertyStreaming = {
+    displayName: 'Respond',
+    name: 'responseMode',
+    type: 'options',
+    options: [
+        ...responseModeOptions,
+        {
+            name: 'Streaming',
+            value: 'streaming',
+            description: 'Returns data in real time from streaming enabled nodes',
+        },
+    ],
+    default: 'onReceived',
+    description: 'When and how to respond to the webhook',
+    displayOptions: {
+        hide: {
+            '@version': [1],
+        },
+    },
+};
+exports.responseDataProperty = {
+    displayName: 'Response Data',
+    name: 'responseData',
+    type: 'options',
+    displayOptions: {
+        show: {
+            responseMode: ['lastNode'],
+        },
+    },
+    options: [
+        {
+            name: 'All Entries',
+            value: 'allEntries',
+            description: 'Returns all the entries of the last node. Always returns an array.',
+        },
+        {
+            name: 'First Entry JSON',
+            value: 'firstEntryJson',
+            description: 'Returns the JSON data of the first entry of the last node. Always returns a JSON object.',
+        },
+        {
+            name: 'First Entry Binary',
+            value: 'firstEntryBinary',
+            description: 'Returns the binary data of the first entry of the last node. Always returns a binary file.',
+        },
+        {
+            name: 'No Response Body',
+            value: 'noData',
+            description: 'Returns without a body',
+        },
+    ],
+    default: 'firstEntryJson',
+    description: 'What data should be returned. If it should return all items as an array or only the first item as object.',
+};
+exports.responseBinaryPropertyNameProperty = {
+    displayName: 'Property Name',
+    name: 'responseBinaryPropertyName',
+    type: 'string',
+    required: true,
+    default: 'data',
+    displayOptions: {
+        show: {
+            responseData: ['firstEntryBinary'],
+        },
+    },
+    description: 'Name of the binary property to return',
+};
+exports.optionsProperty = {
+    displayName: 'Options',
+    name: 'options',
+    type: 'collection',
+    placeholder: 'Add option',
+    default: {},
+    options: [
+        {
+            displayName: 'Binary File',
+            name: 'binaryData',
+            type: 'boolean',
+            displayOptions: {
+                show: {
+                    '/httpMethod': ['PATCH', 'PUT', 'POST'],
+                    '@version': [1],
+                },
+            },
+            default: false,
+            description: 'Whether the webhook will receive binary data',
+        },
+        {
+            displayName: 'Put Output File in Field',
+            name: 'binaryPropertyName',
+            type: 'string',
+            default: 'data',
+            displayOptions: {
+                show: {
+                    binaryData: [true],
+                    '@version': [1],
+                },
+            },
+            hint: 'The name of the output binary field to put the file in',
+            description: 'If the data gets received via "Form-Data Multipart" it will be the prefix and a number starting with 0 will be attached to it',
+        },
+        {
+            displayName: 'Field Name for Binary Data',
+            name: 'binaryPropertyName',
+            type: 'string',
+            default: 'data',
+            displayOptions: {
+                hide: {
+                    '@version': [1],
+                },
+            },
+            description: 'The name of the output field to put any binary file data in. Only relevant if binary data is received.',
+        },
+        {
+            displayName: 'Ignore Bots',
+            name: 'ignoreBots',
+            type: 'boolean',
+            default: false,
+            description: 'Whether to ignore requests from bots like link previewers and web crawlers',
+        },
+        {
+            displayName: 'IP(s) Whitelist',
+            name: 'ipWhitelist',
+            type: 'string',
+            placeholder: 'e.g. 127.0.0.1',
+            default: '',
+            description: 'Comma-separated list of allowed IP addresses. Leave empty to allow all IPs.',
+        },
+        {
+            displayName: 'No Response Body',
+            name: 'noResponseBody',
+            type: 'boolean',
+            default: false,
+            description: 'Whether to send any body in the response',
+            displayOptions: {
+                hide: {
+                    rawBody: [true],
+                },
+                show: {
+                    '/responseMode': ['onReceived'],
+                },
+            },
+        },
+        {
+            displayName: 'Raw Body',
+            name: 'rawBody',
+            type: 'boolean',
+            displayOptions: {
+                show: {
+                    '@version': [1],
+                },
+                hide: {
+                    binaryData: [true],
+                    noResponseBody: [true],
+                },
+            },
+            default: false,
+            description: 'Raw body (binary)',
+        },
+        {
+            displayName: 'Raw Body',
+            name: 'rawBody',
+            type: 'boolean',
+            displayOptions: {
+                hide: {
+                    noResponseBody: [true],
+                    '@version': [1],
+                },
+            },
+            default: false,
+            description: 'Whether to return the raw body',
+        },
+        {
+            displayName: 'Response Data',
+            name: 'responseData',
+            type: 'string',
+            displayOptions: {
+                show: {
+                    '/responseMode': ['onReceived'],
+                },
+                hide: {
+                    noResponseBody: [true],
+                },
+            },
+            default: '',
+            placeholder: 'success',
+            description: 'Custom response data to send',
+        },
+        {
+            displayName: 'Response Content-Type',
+            name: 'responseContentType',
+            type: 'string',
+            displayOptions: {
+                show: {
+                    '/responseData': ['firstEntryJson'],
+                    '/responseMode': ['lastNode'],
+                },
+            },
+            default: '',
+            placeholder: 'application/xml',
+            description: 'Set a custom content-type to return if another one as the "application/json" should be returned',
+        },
+        {
+            displayName: 'Response Headers',
+            name: 'responseHeaders',
+            placeholder: 'Add Response Header',
+            description: 'Add headers to the webhook response',
+            type: 'fixedCollection',
+            typeOptions: {
+                multipleValues: true,
+            },
+            default: {},
+            options: [
+                {
+                    name: 'entries',
+                    displayName: 'Entries',
+                    values: [
+                        {
+                            displayName: 'Name',
+                            name: 'name',
+                            type: 'string',
+                            default: '',
+                            description: 'Name of the header',
+                        },
+                        {
+                            displayName: 'Value',
+                            name: 'value',
+                            type: 'string',
+                            default: '',
+                            description: 'Value of the header',
+                        },
+                    ],
+                },
+            ],
+        },
+        {
+            displayName: 'Property Name',
+            name: 'responsePropertyName',
+            type: 'string',
+            displayOptions: {
+                show: {
+                    '/responseData': ['firstEntryJson'],
+                    '/responseMode': ['lastNode'],
+                },
+            },
+            default: 'data',
+            description: 'Name of the property to return the data of instead of the whole JSON',
+        },
+    ],
+};
+exports.responseCodeSelector = {
+    displayName: 'Response Code',
+    name: 'responseCode',
+    type: 'options',
+    options: [
+        { name: '200', value: 200, description: 'OK - Request has succeeded' },
+        { name: '201', value: 201, description: 'Created - Request has been fulfilled' },
+        { name: '204', value: 204, description: 'No Content - Request processed, no content returned' },
+        { name: '301', value: 301, description: 'Moved Permanently - Requested resource moved permanently' },
+        { name: '302', value: 302, description: 'Found - Requested resource moved temporarily' },
+        { name: '304', value: 304, description: 'Not Modified - Resource has not been modified' },
+        { name: '400', value: 400, description: 'Bad Request - Request could not be understood' },
+        { name: '401', value: 401, description: 'Unauthorized - Request requires user authentication' },
+        { name: '403', value: 403, description: 'Forbidden - Server understood, but refuses to fulfill' },
+        { name: '404', value: 404, description: 'Not Found - Server has not found a match' },
+        { name: 'Custom Code', value: 'customCode', description: 'Write any HTTP code' },
+    ],
+    default: 200,
+    description: 'The HTTP response code to return',
+};
+exports.responseCodeOption = {
+    displayName: 'Response Code',
+    name: 'responseCode',
+    placeholder: 'Add Response Code',
+    type: 'fixedCollection',
+    default: {
+        values: {
+            responseCode: 200,
+        },
+    },
+    options: [
+        {
+            name: 'values',
+            displayName: 'Values',
+            values: [
+                exports.responseCodeSelector,
+                {
+                    displayName: 'Code',
+                    name: 'customCode',
+                    type: 'number',
+                    default: 200,
+                    placeholder: 'e.g. 400',
+                    typeOptions: {
+                        minValue: 100,
+                    },
+                    displayOptions: {
+                        show: {
+                            responseCode: ['customCode'],
+                        },
+                    },
+                },
+            ],
+        },
+    ],
+    displayOptions: {
+        show: {
+            '@version': [{ _cnd: { gte: 2 } }],
+        },
+        hide: {
+            '/responseMode': ['responseNode'],
+        },
+    },
+};

package/dist/nodes/ElearningMagic/error.d.ts

@@ -0,0 +1,5 @@
+import { ApplicationError } from '@n8n/errors';
+export declare class WebhookAuthorizationError extends ApplicationError {
+    readonly responseCode: number;
+    constructor(responseCode: number, message?: string);
+}

package/dist/nodes/ElearningMagic/error.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebhookAuthorizationError = void 0;
+const errors_1 = require("@n8n/errors");
+class WebhookAuthorizationError extends errors_1.ApplicationError {
+    constructor(responseCode, message) {
+        if (message === undefined) {
+            message = 'Authorization problem!';
+            if (responseCode === 401) {
+                message = 'Authorization is required!';
+            }
+            else if (responseCode === 403) {
+                message = 'Authorization data is wrong!';
+            }
+        }
+        super(message);
+        this.responseCode = responseCode;
+    }
+}
+exports.WebhookAuthorizationError = WebhookAuthorizationError;

package/dist/nodes/ElearningMagic/utils.d.ts

@@ -0,0 +1,32 @@
+import type { IWebhookFunctions, INodeExecutionData, IDataObject } from 'n8n-workflow';
+export type WebhookParameters = {
+    httpMethod: string | string[];
+    responseMode: string;
+    responseData: string;
+    responseCode?: number;
+    options?: {
+        responseData?: string;
+        responseCode?: {
+            values?: {
+                responseCode: number;
+                customCode?: number;
+            };
+        };
+        noResponseBody?: boolean;
+    };
+};
+export declare const getResponseCode: (parameters: WebhookParameters) => number;
+export declare const getResponseData: (parameters: WebhookParameters) => string | undefined;
+export declare const configuredOutputs: (parameters: WebhookParameters) => {
+    type: string;
+    displayName: string;
+}[];
+export declare const setupOutputConnection: (ctx: IWebhookFunctions, method: string, additionalData: {
+    jwtPayload?: IDataObject;
+}) => (outputData: INodeExecutionData) => INodeExecutionData[][];
+export declare const isIpWhitelisted: (whitelist: string | string[] | undefined, ips: string[], ip?: string) => boolean;
+export declare const checkResponseModeConfiguration: (context: IWebhookFunctions) => void;
+export declare function validateWebhookAuthentication(ctx: IWebhookFunctions, authPropertyName: string): Promise<IDataObject | undefined>;
+export declare function handleFormData(context: IWebhookFunctions, prepareOutput: (data: INodeExecutionData) => INodeExecutionData[][]): Promise<{
+    workflowData: INodeExecutionData[][];
+}>;

package/dist/nodes/ElearningMagic/utils.js

@@ -0,0 +1,264 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkResponseModeConfiguration = exports.isIpWhitelisted = exports.setupOutputConnection = exports.configuredOutputs = exports.getResponseData = exports.getResponseCode = void 0;
+exports.validateWebhookAuthentication = validateWebhookAuthentication;
+exports.handleFormData = handleFormData;
+const promises_1 = require("fs/promises");
+const crypto_1 = require("crypto");
+const n8n_workflow_1 = require("n8n-workflow");
+const a = __importStar(require("node:assert"));
+const node_net_1 = require("node:net");
+const error_1 = require("./error");
+const computeSignature = (secret, rawBody) => (0, crypto_1.createHmac)('sha256', secret).update(rawBody).digest('hex');
+const safeCompare = (a, b) => {
+    if (!a || !b || a.length !== b.length) {
+        return false;
+    }
+    try {
+        return (0, crypto_1.timingSafeEqual)(Buffer.from(a), Buffer.from(b));
+    }
+    catch {
+        return false;
+    }
+};
+const getResponseCode = (parameters) => {
+    var _a;
+    if (parameters.responseCode) {
+        return parameters.responseCode;
+    }
+    const responseCodeOptions = parameters.options;
+    if ((_a = responseCodeOptions === null || responseCodeOptions === void 0 ? void 0 : responseCodeOptions.responseCode) === null || _a === void 0 ? void 0 : _a.values) {
+        const { responseCode, customCode } = responseCodeOptions.responseCode.values;
+        if (customCode) {
+            return customCode;
+        }
+        return responseCode;
+    }
+    return 200;
+};
+exports.getResponseCode = getResponseCode;
+const getResponseData = (parameters) => {
+    const { responseData, responseMode, options } = parameters;
+    if (responseData)
+        return responseData;
+    if (responseMode === 'onReceived') {
+        const data = options === null || options === void 0 ? void 0 : options.responseData;
+        if (data)
+            return data;
+    }
+    if (options === null || options === void 0 ? void 0 : options.noResponseBody)
+        return 'noData';
+    return undefined;
+};
+exports.getResponseData = getResponseData;
+const configuredOutputs = (parameters) => {
+    const httpMethod = parameters.httpMethod;
+    if (!Array.isArray(httpMethod))
+        return [
+            {
+                type: 'main',
+                displayName: httpMethod,
+            },
+        ];
+    const outputs = httpMethod.map((method) => {
+        return {
+            type: 'main',
+            displayName: method,
+        };
+    });
+    return outputs;
+};
+exports.configuredOutputs = configuredOutputs;
+const setupOutputConnection = (ctx, method, additionalData) => {
+    const httpMethod = ctx.getNodeParameter('httpMethod', []);
+    let webhookUrl = ctx.getNodeWebhookUrl('default');
+    const executionMode = ctx.getMode() === 'manual' ? 'test' : 'production';
+    if (executionMode === 'test') {
+        webhookUrl = webhookUrl.replace('/webhook/', '/webhook-test/');
+    }
+    if (!Array.isArray(httpMethod)) {
+        return (outputData) => {
+            outputData.json.webhookUrl = webhookUrl;
+            outputData.json.executionMode = executionMode;
+            if (additionalData === null || additionalData === void 0 ? void 0 : additionalData.jwtPayload) {
+                outputData.json.jwtPayload = additionalData.jwtPayload;
+            }
+            return [[outputData]];
+        };
+    }
+    const outputIndex = httpMethod.indexOf(method.toUpperCase());
+    const outputs = httpMethod.map(() => []);
+    return (outputData) => {
+        outputData.json.webhookUrl = webhookUrl;
+        outputData.json.executionMode = executionMode;
+        if (additionalData === null || additionalData === void 0 ? void 0 : additionalData.jwtPayload) {
+            outputData.json.jwtPayload = additionalData.jwtPayload;
+        }
+        outputs[outputIndex] = [outputData];
+        return outputs;
+    };
+};
+exports.setupOutputConnection = setupOutputConnection;
+const isIpWhitelisted = (whitelist, ips, ip) => {
+    if (whitelist === undefined || whitelist === '') {
+        return true;
+    }
+    if (!Array.isArray(whitelist)) {
+        whitelist = whitelist.split(',').map((entry) => entry.trim());
+    }
+    const allowList = getAllowList(whitelist);
+    if (allowList.check(ip !== null && ip !== void 0 ? ip : '')) {
+        return true;
+    }
+    if (ips.some((ipEntry) => allowList.check(ipEntry))) {
+        return true;
+    }
+    return false;
+};
+exports.isIpWhitelisted = isIpWhitelisted;
+const getAllowList = (whitelist) => {
+    const allowList = new node_net_1.BlockList();
+    for (const entry of whitelist) {
+        try {
+            allowList.addAddress(entry);
+        }
+        catch {
+            // Ignore invalid entries
+        }
+    }
+    return allowList;
+};
+const checkResponseModeConfiguration = (context) => {
+    const responseMode = context.getNodeParameter('responseMode', 'onReceived');
+    const connectedNodes = context.getChildNodes(context.getNode().name);
+    const isRespondToWebhookConnected = connectedNodes.some((node) => node.type === 'n8n-nodes-base.respondToWebhook');
+    if (!isRespondToWebhookConnected && responseMode === 'responseNode') {
+        throw new n8n_workflow_1.WorkflowConfigurationError(context.getNode(), new Error('No Respond to Webhook node found in the workflow'), {
+            description: 'Insert a Respond to Webhook node to your workflow to respond to the webhook or choose another option for the “Respond” parameter',
+        });
+    }
+    if (isRespondToWebhookConnected && !['responseNode', 'streaming'].includes(responseMode)) {
+        throw new n8n_workflow_1.WorkflowConfigurationError(context.getNode(), new Error('Unused Respond to Webhook node found in the workflow'), {
+            description: 'Set the “Respond” parameter to “Using Respond to Webhook Node” or remove the Respond to Webhook node',
+        });
+    }
+};
+exports.checkResponseModeConfiguration = checkResponseModeConfiguration;
+async function validateWebhookAuthentication(ctx, authPropertyName) {
+    var _a, _b, _c;
+    const authentication = ctx.getNodeParameter(authPropertyName);
+    if (authentication === 'none')
+        return;
+    const req = ctx.getRequestObject();
+    const headers = ctx.getHeaderData();
+    if (authentication === 'signingSecret') {
+        let credentials;
+        try {
+            credentials = await ctx.getCredentials('elearningMagicApi');
+        }
+        catch { }
+        const secret = (credentials === null || credentials === void 0 ? void 0 : credentials.signingSecret) || '';
+        if (!secret) {
+            throw new error_1.WebhookAuthorizationError(500, 'No signing secret defined on node!');
+        }
+        if (!req.rawBody) {
+            await ((_b = (_a = req).readRawBody) === null || _b === void 0 ? void 0 : _b.call(_a));
+        }
+        const raw = req.rawBody !== undefined
+            ? req.rawBody.toString('utf8')
+            : JSON.stringify((_c = req.body) !== null && _c !== void 0 ? _c : {});
+        const headerSignature = headers['x-em-signature'] || '';
+        if (!headerSignature) {
+            throw new error_1.WebhookAuthorizationError(401, 'Missing X-EM-Signature header');
+        }
+        const computed = computeSignature(secret, raw);
+        if (!safeCompare(computed, headerSignature)) {
+            throw new error_1.WebhookAuthorizationError(403, 'Invalid X-EM-Signature');
+        }
+        return undefined;
+    }
+    return undefined;
+}
+async function handleFormData(context, prepareOutput) {
+    var _a;
+    const req = context.getRequestObject();
+    a.ok(req.contentType === 'multipart/form-data', 'Expected multipart/form-data');
+    const options = context.getNodeParameter('options', {});
+    const { data, files } = req.body;
+    const returnItem = {
+        json: {
+            headers: req.headers,
+            params: req.params,
+            query: req.query,
+            body: data,
+        },
+    };
+    if (files && Object.keys(files).length) {
+        returnItem.binary = {};
+    }
+    let count = 0;
+    for (const key of Object.keys(files)) {
+        const processFiles = [];
+        let multiFile = false;
+        if (Array.isArray(files[key])) {
+            processFiles.push.apply(processFiles, files[key]);
+            multiFile = true;
+        }
+        else {
+            processFiles.push(files[key]);
+        }
+        let fileCount = 0;
+        for (const file of processFiles) {
+            let binaryPropertyName = key;
+            if (binaryPropertyName.endsWith('[]')) {
+                binaryPropertyName = binaryPropertyName.slice(0, -2);
+            }
+            if (!binaryPropertyName.trim().length) {
+                binaryPropertyName = `data${count}`;
+            }
+            else if (multiFile) {
+                binaryPropertyName += fileCount++;
+            }
+            if (options.binaryPropertyName) {
+                binaryPropertyName = `${options.binaryPropertyName}${count}`;
+            }
+            returnItem.binary[binaryPropertyName] = await context.nodeHelpers.copyBinaryFile(file.filepath, (_a = file.originalFilename) !== null && _a !== void 0 ? _a : file.newFilename, file.mimetype);
+            await (0, promises_1.rm)(file.filepath, { force: true });
+            count += 1;
+        }
+    }
+    return { workflowData: prepareOutput(returnItem) };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-elearning-magic",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "n8n community node for receiving signed payloads from the eLearning Magic SCORM wrapper",
   "keywords": [
     "n8n-community-node",
@@ -37,8 +37,10 @@
     "typescript": "^5.6.3"
   },
   "dependencies": {
+    "isbot": "^3.7.0",
     "n8n-core": "^1.0.0",
-    "n8n-workflow": "^1.0.0"
+    "n8n-workflow": "^1.0.0",
+    "tmp-promise": "^3.0.3"
   },
   "overrides": {
     "form-data": "^4.0.4"