@limetech/n8n-nodes-lime 3.10.3 → 3.11.0

package/nodes/lime-marketing/resources/transactionsms/operations/send.operation.ts

@@ -0,0 +1,228 @@
+import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
+import {
+    TRANSACTIONAL_SMS_RESOURCE,
+    SendTransactionSmsArgs,
+    TagModel,
+    TransactionSmsModel,
+    MERGE_CODES_INPUT_FIELDS,
+    MERGE_CODES_INPUT_JSON,
+    SEND_OPERATION,
+    TagListInput,
+    AdditionalSmsOptions,
+} from '../../../models';
+import {
+    assertValidSmsDestinationNumber,
+    assertValidSmsFromNumber,
+    omitEmpty,
+} from '../../../utils';
+import {
+    mergeCodesInputMethodProperty,
+    mergeCodesTagFieldOptions,
+    parseMergeCodesJson,
+    readFreeFormTagModels,
+} from '../../../utils/mergeCodes';
+import { limeMarketingRequest } from '../../../transport';
+
+/** @public */
+export const description = {
+    name: 'Send',
+    value: SEND_OPERATION,
+    description: 'Send an SMS',
+    action: 'Send an SMS',
+};
+
+/** @public */
+export const properties: INodeProperties[] = [
+    {
+        displayName: 'From Number',
+        name: 'fromNumber',
+        type: 'string',
+        required: true,
+        default: '',
+        placeholder: 'e.g. MyCompany',
+        description:
+            'The alphanumeric sender ID shown to the recipient (2–11 characters).',
+        displayOptions: {
+            show: {
+                resource: [TRANSACTIONAL_SMS_RESOURCE],
+                operation: [SEND_OPERATION],
+            },
+        },
+    },
+    {
+        displayName: 'Destination Number',
+        name: 'destinationNumber',
+        type: 'string',
+        required: true,
+        default: '',
+        placeholder: 'e.g. +46701234567',
+        description:
+            'The recipient phone number in international format, starting with "+".',
+        displayOptions: {
+            show: {
+                resource: [TRANSACTIONAL_SMS_RESOURCE],
+                operation: [SEND_OPERATION],
+            },
+        },
+    },
+    {
+        displayName: 'Text',
+        name: 'text',
+        type: 'string',
+        typeOptions: { rows: 4 },
+        required: true,
+        default: '',
+        description:
+            'The SMS body. Use merge codes like {{firstname}} and provide values in Merge Code Mapping below.',
+        displayOptions: {
+            show: {
+                resource: [TRANSACTIONAL_SMS_RESOURCE],
+                operation: [SEND_OPERATION],
+            },
+        },
+    },
+    mergeCodesInputMethodProperty({
+        resource: [TRANSACTIONAL_SMS_RESOURCE],
+        operation: [SEND_OPERATION],
+    }),
+    {
+        displayName: 'Merge Code Mapping',
+        name: 'textContentTagModels',
+        type: 'fixedCollection',
+        typeOptions: { multipleValues: true },
+        placeholder: 'Add Merge Code',
+        default: {},
+        description: 'Merge codes and values to substitute into the SMS text.',
+        displayOptions: {
+            show: {
+                resource: [TRANSACTIONAL_SMS_RESOURCE],
+                operation: [SEND_OPERATION],
+                mergeCodesInputMethod: [MERGE_CODES_INPUT_FIELDS],
+            },
+        },
+        options: mergeCodesTagFieldOptions,
+    },
+    {
+        displayName: 'Merge Codes (JSON)',
+        name: 'mergeCodesJson',
+        type: 'json',
+        required: true,
+        default: '{\n  "{{firstname}}": "John"\n}',
+        description:
+            'Object mapping each merge code (with braces) to its replacement value.',
+        typeOptions: {
+            alwaysOpenEditWindow: true,
+        },
+        displayOptions: {
+            show: {
+                resource: [TRANSACTIONAL_SMS_RESOURCE],
+                operation: [SEND_OPERATION],
+                mergeCodesInputMethod: [MERGE_CODES_INPUT_JSON],
+            },
+        },
+    },
+    {
+        displayName: 'Additional Options',
+        name: 'additionalOptions',
+        type: 'collection',
+        placeholder: 'Add Option',
+        default: {},
+        displayOptions: {
+            show: {
+                resource: [TRANSACTIONAL_SMS_RESOURCE],
+                operation: [SEND_OPERATION],
+            },
+        },
+        options: [
+            {
+                displayName: 'Delivery Timeout Hours',
+                name: 'deliveryTimeoutHours',
+                type: 'number',
+                typeOptions: { minValue: 0, maxValue: 168 },
+                default: null,
+                description:
+                    'How long (in hours, 0–168) the provider should keep retrying delivery before giving up.',
+            },
+            {
+                displayName: 'Max Parts',
+                name: 'maxParts',
+                type: 'number',
+                typeOptions: { minValue: 1 },
+                default: null,
+                description:
+                    'Maximum number of SMS segments the message is allowed to split into.',
+            },
+            {
+                displayName: 'Scheduled Send Date',
+                name: 'scheduledSendDate',
+                type: 'dateTime',
+                default: '',
+                description:
+                    'When to send the SMS. Leave empty to send immediately.',
+            },
+        ],
+    },
+];
+
+// Read merge codes from whichever UI surface is active (JSON or free-form
+// fixedCollection) and return them as TagModels.
+function readMergeCodes(ctx: IExecuteFunctions, i: number): TagModel[] {
+    const method = ctx.getNodeParameter(
+        'mergeCodesInputMethod',
+        i,
+        MERGE_CODES_INPUT_FIELDS
+    ) as string;
+    if (method === MERGE_CODES_INPUT_JSON) return parseMergeCodesJson(ctx, i);
+    return readFreeFormTagModels(
+        ctx.getNodeParameter('textContentTagModels', i, {}) as TagListInput
+    );
+}
+
+export async function execute(
+    this: IExecuteFunctions,
+    i: number,
+    baseURL?: string
+) {
+    const fromNumber = this.getNodeParameter('fromNumber', i) as string;
+    const destinationNumber = this.getNodeParameter(
+        'destinationNumber',
+        i
+    ) as string;
+    const text = this.getNodeParameter('text', i) as string;
+
+    assertValidSmsFromNumber(this, fromNumber, 'From Number', i);
+    assertValidSmsDestinationNumber(
+        this,
+        destinationNumber,
+        'Destination Number',
+        i
+    );
+
+    const additional = this.getNodeParameter(
+        'additionalOptions',
+        i,
+        {}
+    ) as AdditionalSmsOptions;
+
+    const textContentTagModels = readMergeCodes(this, i);
+
+    const body: SendTransactionSmsArgs = {
+        Text: text,
+        FromNumber: fromNumber,
+        DestinationNumber: destinationNumber,
+        MaxParts: omitEmpty(additional.maxParts),
+        DeliveryTimeoutHours: omitEmpty(additional.deliveryTimeoutHours),
+        ScheduledSendDate: omitEmpty(additional.scheduledSendDate),
+        TextContentTagModels:
+            textContentTagModels.length > 0 ? textContentTagModels : undefined,
+    };
+
+    return limeMarketingRequest<TransactionSmsModel>(this, {
+        method: 'POST',
+        url: 'transactionsms/send',
+        body,
+        json: true,
+        errorContext: 'send SMS',
+        baseURL,
+    });
+}

package/nodes/lime-marketing/transport/index.ts

@@ -0,0 +1,68 @@
+import {
+    IAllExecuteFunctions,
+    IHttpRequestOptions,
+    NodeApiError,
+} from 'n8n-workflow';
+import { LIME_MARKETING_API_CREDENTIAL_KEY } from '../models';
+import { getBaseUrl } from '../utils';
+import { handleWorkflowError } from '../../errorHandling';
+import { APIResponse } from '../../response';
+import { LimeMarketingErrorBody } from '../models';
+
+const formatErrorDetails = (
+    details: LimeMarketingErrorBody['ErrorDetails']
+): string =>
+    (details ?? [])
+        .map((d) => [d?.Message, d?.Context].filter(Boolean).join(': '))
+        .filter(Boolean)
+        .join('; ');
+
+const createErrorMessage = (error: NodeApiError): string => {
+    const data = error.context.data as LimeMarketingErrorBody;
+    const message = data.Message ?? '';
+    const details = formatErrorDetails(data.ErrorDetails);
+    return details ? `${message}: ${details}` : message;
+};
+
+export type LimeMarketingRequestOptions = Omit<
+    IHttpRequestOptions,
+    'baseURL'
+> & {
+    /**
+     * Action being performed, used to prefix error messages.
+     * Example: 'send email' → "Failed to send email: <api message>".
+     */
+    errorContext?: string;
+    /**
+     * Pre-resolved base URL. Pass it once at the top of execute() to avoid
+     * re-fetching credentials on every per-item HTTP call.
+     */
+    baseURL?: string;
+};
+
+export async function limeMarketingRequest<T>(
+    context: IAllExecuteFunctions,
+    options: LimeMarketingRequestOptions
+): Promise<APIResponse<T>> {
+    const { baseURL: providedBaseURL, ...httpOptions } = options;
+    const baseURL = providedBaseURL ?? (await getBaseUrl(context));
+    try {
+        const data = await context.helpers.httpRequestWithAuthentication.call(
+            context,
+            LIME_MARKETING_API_CREDENTIAL_KEY,
+            { ...httpOptions, baseURL }
+        );
+        return {
+            success: true,
+            data: data,
+        };
+    } catch (error) {
+        return handleWorkflowError(
+            context.getNode(),
+            {
+                message: createErrorMessage(error),
+            },
+            true
+        );
+    }
+}

package/nodes/lime-marketing/utils/index.ts

@@ -0,0 +1,139 @@
+import {
+    IAllExecuteFunctions,
+    IExecuteFunctions,
+    NodeOperationError,
+} from 'n8n-workflow';
+import { LIME_MARKETING_API_CREDENTIAL_KEY, AttachmentModel } from '../models';
+
+/**
+ * Matches the server-side Lime Marketing email regex so we fail fast in the
+ * node rather than round-tripping an obviously bad address to the API.
+ *
+ * Source:
+ *   EmailUsernamePartRegex = @"([a-zA-Z0-9_\-\.'\+\!\#\$\%\&\?\=\^\{\}\|\~\*]+)"
+ *   EmailRegexPattern = "^" + username + "@((\[ipv4\])|(([a-zA-Z0-9-_]+\.)*([a-zA-Z0-9-]+)\.[a-zA-Z0-9]{2,15}))$"
+ */
+const LIME_MARKETING_EMAIL_REGEX =
+    // eslint-disable-next-line sonarjs/regex-complexity, sonarjs/concise-regex
+    /^([a-zA-Z0-9_\-.'+!#$%&?=^{}|~*]+)@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z0-9\-_]+\.)*([a-zA-Z0-9-]+)\.[a-zA-Z0-9]{2,15}))$/;
+
+export function assertValidEmail(
+    context: IExecuteFunctions,
+    email: string,
+    fieldLabel: string,
+    itemIndex: number
+): void {
+    if (LIME_MARKETING_EMAIL_REGEX.test(email)) return;
+    throw new NodeOperationError(
+        context.getNode(),
+        `${fieldLabel} is not a valid email address: ${email}`,
+        {
+            itemIndex,
+            description:
+                'Expected a format like name@example.com. Lime Marketing rejects addresses that do not match its email pattern.',
+        }
+    );
+}
+
+/**
+ * Destination phone number regex from the /transactionsms/send schema:
+ *   ^([+]+[1-9]{2})+\d{5,20}$
+ * Expects an E.164-style number starting with "+" and a non-zero country code.
+ */
+const LIME_MARKETING_SMS_DESTINATION_REGEX = /^([+]+[1-9]{2})+\d{5,20}$/;
+
+/**
+ * Sender (FromNumber) regex from the /transactionsms/send schema — alphanumeric
+ * sender ID, 2–11 chars, Nordic letters + digits + _ - allowed, spaces allowed
+ * but not as first/last character:
+ *   ^[a-zA-ZåäöÅÄÖæÆøØüÜ_\-\d][a-zA-ZåäöÅÄÖæÆøØüÜ_\-\d\s]{0,9}[a-zA-ZåäöÅÄÖæÆøØüÜ_\-\d]$
+ */
+const LIME_MARKETING_SMS_FROM_NUMBER_REGEX =
+    /^[a-zA-ZåäöÅÄÖæÆøØüÜ_\-\d][a-zA-ZåäöÅÄÖæÆøØüÜ_\-\d\s]{0,9}[a-zA-ZåäöÅÄÖæÆøØüÜ_\-\d]$/;
+
+export function assertValidSmsDestinationNumber(
+    context: IExecuteFunctions,
+    value: string,
+    fieldLabel: string,
+    itemIndex: number
+): void {
+    if (LIME_MARKETING_SMS_DESTINATION_REGEX.test(value)) return;
+    throw new NodeOperationError(
+        context.getNode(),
+        `${fieldLabel} is not a valid phone number: ${value}`,
+        {
+            itemIndex,
+            description:
+                'Expected an international format starting with "+", e.g. +46701234567.',
+        }
+    );
+}
+
+export function assertValidSmsFromNumber(
+    context: IExecuteFunctions,
+    value: string,
+    fieldLabel: string,
+    itemIndex: number
+): void {
+    if (LIME_MARKETING_SMS_FROM_NUMBER_REGEX.test(value)) return;
+    throw new NodeOperationError(
+        context.getNode(),
+        `${fieldLabel} is not a valid sender ID: ${value}`,
+        {
+            itemIndex,
+            description:
+                'Expected 2–11 characters: letters, digits, underscores, hyphens, or spaces (spaces not allowed at start/end).',
+        }
+    );
+}
+
+type LimeMarketingCredentials = {
+    url: string;
+    apiKey: string;
+};
+
+export async function getBaseUrl(
+    context: IAllExecuteFunctions
+): Promise<string> {
+    const credentials = (await context.getCredentials(
+        LIME_MARKETING_API_CREDENTIAL_KEY
+    )) as unknown as LimeMarketingCredentials;
+    let url = credentials.url;
+    while (url.endsWith('/')) url = url.slice(0, -1);
+    return url;
+}
+
+/**
+ * Coerces empty/null values to undefined so the property is dropped from the
+ * outbound JSON payload rather than sent as "" or null.
+ *
+ * n8n's `collection` UI defaults to '' for string fields and null for number
+ * fields with `default: null`; we treat both as "user did not set this".
+ *
+ * @param value - The value to normalize.
+ */
+export function omitEmpty<T>(value: T | '' | null | undefined): T | undefined {
+    if (value === '' || value === null || value === undefined) return undefined;
+    return value;
+}
+
+export async function buildAttachment(
+    context: IExecuteFunctions,
+    i: number,
+    binaryPropertyName: string,
+    fileNameOverride?: string
+): Promise<AttachmentModel> {
+    const binaryData = context.helpers.assertBinaryData(i, binaryPropertyName);
+    const fileName = fileNameOverride || binaryData.fileName;
+    if (!fileName) {
+        throw new NodeOperationError(
+            context.getNode(),
+            `Attachment "${binaryPropertyName}" is missing a file name. Set one via "File Name Override" or ensure the upstream node sets it.`
+        );
+    }
+    return {
+        FileData: binaryData.data,
+        FileNameWithExtension: fileName,
+        MimeType: binaryData.mimeType,
+    };
+}

package/nodes/lime-marketing/utils/mergeCodes.ts

@@ -0,0 +1,121 @@
+import {
+    IDisplayOptions,
+    IExecuteFunctions,
+    INodeProperties,
+    NodeOperationError,
+} from 'n8n-workflow';
+import {
+    MERGE_CODES_INPUT_FIELDS,
+    MERGE_CODES_INPUT_JSON,
+    TagListInput,
+    TagModel,
+} from '../models';
+
+// Read the "Merge Codes (JSON)" parameter (already-parsed object or string)
+// and turn it into TagModels. Throws NodeOperationError with item context on
+// invalid JSON or non-object roots.
+export function parseMergeCodesJson(
+    ctx: IExecuteFunctions,
+    i: number
+): TagModel[] {
+    const jsonInput = ctx.getNodeParameter('mergeCodesJson', i) as
+        | string
+        | Record<string, string>;
+    let parsed: Record<string, unknown>;
+    try {
+        parsed =
+            typeof jsonInput === 'string' ? JSON.parse(jsonInput) : jsonInput;
+    } catch (error_) {
+        const message =
+            error_ instanceof Error ? error_.message : String(error_);
+        throw new NodeOperationError(
+            ctx.getNode(),
+            `Merge Codes (JSON) is not valid JSON: ${message}`,
+            {
+                itemIndex: i,
+                description:
+                    'Enter a valid JSON object, for example: { "{{firstname}}": "John" }',
+            }
+        );
+    }
+    if (
+        parsed === null ||
+        typeof parsed !== 'object' ||
+        Array.isArray(parsed)
+    ) {
+        throw new NodeOperationError(
+            ctx.getNode(),
+            'Merge Codes (JSON) must be a JSON object of { mergeCode: value } pairs.',
+            {
+                itemIndex: i,
+                description:
+                    'Example: { "{{firstname}}": "John", "{{custom}}": "value" }',
+            }
+        );
+    }
+    // Match the template-mapper path: send "" rather than the literal
+    // strings "null" / "undefined" when the user supplied either.
+    return Object.entries(parsed).map(([Name, Value]) => ({
+        Name,
+        Value: Value === null || Value === undefined ? '' : String(Value),
+    }));
+}
+
+export function readFreeFormTagModels(
+    input: TagListInput | undefined
+): TagModel[] {
+    return (input?.tag ?? []).map((t) => ({ Name: t.name, Value: t.value }));
+}
+
+// Build the "Merge Codes Input Method" UI dropdown (Form vs JSON Object) for
+// the given displayOptions.show selector. Reused by both email and SMS sends.
+export function mergeCodesInputMethodProperty(
+    displayOptionsShow: NonNullable<IDisplayOptions['show']>
+): INodeProperties {
+    return {
+        displayName: 'Merge Codes Input Method',
+        name: 'mergeCodesInputMethod',
+        type: 'options',
+        options: [
+            {
+                name: 'Form',
+                value: MERGE_CODES_INPUT_FIELDS,
+                description: 'Provide merge codes and values using the UI',
+            },
+            {
+                name: 'JSON Object',
+                value: MERGE_CODES_INPUT_JSON,
+                description: 'Provide merge codes and values as a JSON object',
+            },
+        ],
+        default: MERGE_CODES_INPUT_FIELDS,
+        description:
+            'Form: fill in merge codes and values. JSON: provide them as an object.',
+        displayOptions: { show: displayOptionsShow },
+    };
+}
+
+export const mergeCodesTagFieldOptions = [
+    {
+        name: 'tag',
+        displayName: 'Merge Code',
+        values: [
+            {
+                displayName: 'Name',
+                name: 'name',
+                type: 'string' as const,
+                default: '',
+                required: true,
+                placeholder: 'e.g. {{firstname}}',
+                description:
+                    'The full merge code including braces, e.g. {{firstname}}.',
+            },
+            {
+                displayName: 'Value',
+                name: 'value',
+                type: 'string' as const,
+                default: '',
+            },
+        ],
+    },
+];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@limetech/n8n-nodes-lime",
-  "version": "3.10.3",
+  "version": "3.11.0",
   "description": "n8n node to connect to Lime CRM",
   "author": {
     "name": "Lime Technologies",
@@ -9,7 +9,7 @@
   "license": "Apache-2.0",
   "main": "nodes/index.ts",
   "scripts": {
-    "build": "tsc -p tsconfig.build.json && copyfiles \"nodes/**/*.svg\" dist",
+    "build": "tsc -p tsconfig.build.json && copyfiles \"nodes/**/*.svg\" \"credentials/**/*.svg\" dist",
     "dev": "tsc --watch",
     "watch": "tsc --watch",
     "lint": "eslint --max-warnings=0 .",
@@ -34,12 +34,14 @@
     "n8nNodesApiVersion": 1,
     "credentials": [
       "dist/credentials/LimeCrmApi.credentials.js",
-      "dist/credentials/LimeFormsApi.credentials.js"
+      "dist/credentials/LimeFormsApi.credentials.js",
+      "dist/credentials/LimeMarketingApi.credentials.js"
     ],
     "nodes": [
       "dist/nodes/lime-crm/LimeCrmNode.node.js",
       "dist/nodes/lime-crm/LimeCrmTrigger.node.js",
-      "dist/nodes/lime-forms/LimeFormsTrigger.node.js"
+      "dist/nodes/lime-forms/LimeFormsTrigger.node.js",
+      "dist/nodes/lime-marketing/LimeMarketing.node.js"
     ]
   },
   "devDependencies": {