@limetech/n8n-nodes-lime 2.3.1-dev.1 → 2.5.0-dev.1

package/.github/workflows/lint.yml

@@ -4,7 +4,7 @@ on:
     pull_request:
     push:
         branches:
-            - master
+            - main
 
 jobs:
     lint:

package/.github/workflows/release.yml

@@ -1,4 +1,4 @@
-name: Release and Push to ECR
+name: Release and Push to NPM Registry
 
 on:
     push:
@@ -32,4 +32,18 @@ jobs:
                   echo "version=$VERSION" >> $GITHUB_OUTPUT
               env:
                   GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-                  NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+                  NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+
+    push-to-npm:
+        name: Push package to NPM
+        runs-on: ubuntu-latest
+        needs: release
+        permissions:
+            id-token: write
+            contents: read
+        steps:
+            - name: Checkout repository
+              uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 #v5.0.0
+            - run: npm ci
+            - name: Publish
+              run: npm publish

package/.github/workflows/test-and-build.yml

@@ -30,18 +30,3 @@ jobs:
 
             - name: Run tests
               run: npm run test
-
-    docker-build:
-        name: Build docker image
-        runs-on: ubuntu-latest
-
-        steps:
-            - name: Checkout code
-              uses: actions/checkout@v4
-
-            - name: Set up Docker Buildx
-              uses: docker/setup-buildx-action@v3
-
-            - name: Test Docker build
-              run: |
-                  docker build .

package/CHANGELOG.md

@@ -1,9 +1,42 @@
-## [2.3.1-dev.1](https://github.com/Lundalogik/lime-n8n/compare/v2.3.0...v2.3.1-dev.1) (2025-12-01)
+# [2.5.0-dev.1](https://github.com/Lundalogik/lime-n8n/compare/v2.4.0...v2.5.0-dev.1) (2026-01-08)
 
 
 ### Bug Fixes
 
-* create an npm package out of repo ([ec68ddc](https://github.com/Lundalogik/lime-n8n/commit/ec68ddc0fa6c5bf0e9b4302877c1fe64599ea01a))
+* fix npm release ([ebcba3f](https://github.com/Lundalogik/lime-n8n/commit/ebcba3fdc73b0126715af746ade844b2bb1ab1d5))
+
+
+### Features
+
+* create an npm package out of repo ([e65a950](https://github.com/Lundalogik/lime-n8n/commit/e65a950ff42711a6c6fb624cb903d979a6ef8d4f))
+
+# [2.4.0](https://github.com/Lundalogik/lime-n8n/compare/v2.3.3...v2.4.0) (2025-12-12)
+
+
+### Features
+
+* add resourceMapper to create single object ([ba1a537](https://github.com/Lundalogik/lime-n8n/commit/ba1a53774cd05691d9bdd3b70eec768e1cbd4cc6))
+
+## [2.3.3](https://github.com/Lundalogik/lime-n8n/compare/v2.3.2...v2.3.3) (2025-12-09)
+
+
+### Bug Fixes
+
+* fix error handling in n8n ([1e6b878](https://github.com/Lundalogik/lime-n8n/commit/1e6b8782629a16117c7cac3f62b043cf897a2a96))
+
+## [2.3.2](https://github.com/Lundalogik/lime-n8n/compare/v2.3.1...v2.3.2) (2025-12-08)
+
+
+### Bug Fixes
+
+* change timezone to utc ([4ab309f](https://github.com/Lundalogik/lime-n8n/commit/4ab309fc0b9a37743ea398ec8cf594507be7f1be))
+
+## [2.3.1](https://github.com/Lundalogik/lime-n8n/compare/v2.3.0...v2.3.1) (2025-12-02)
+
+
+### Bug Fixes
+
+* fix master reference in lint.yml ([0a91f70](https://github.com/Lundalogik/lime-n8n/commit/0a91f7092de81139294328f6cb114593c963bc69))
 
 # [2.3.0](https://github.com/Lundalogik/lime-n8n/compare/v2.2.0...v2.3.0) (2025-11-21)
 

package/nodes/errorHandling.ts

@@ -0,0 +1,60 @@
+import {
+    IExecuteFunctions,
+    IAllExecuteFunctions,
+    NodeApiError,
+    NodeOperationError,
+    JsonObject,
+} from 'n8n-workflow';
+
+/**
+ * Type guard checking if the class conforms to {@link IExecuteFunctions}
+ * interface
+ * @param nodeContext - a subclass of n8n's FunctionsBase interface
+ */
+function isIExecuteFunctions(
+    nodeContext: IAllExecuteFunctions
+): nodeContext is IExecuteFunctions {
+    return (nodeContext as IExecuteFunctions).continueOnFail !== undefined;
+}
+
+/**
+ * Wrapper for the error data used in Lime workflows
+ */
+export type WorkflowErrorContext = {
+    message: string;
+} & JsonObject;
+
+/**
+ * Structure for unsuccessful response used in communication layer.
+ */
+export type ErrorResponse = {
+    success: false;
+    data: { error: WorkflowErrorContext };
+};
+
+/**
+ * Function which handles how are the errors handled in n8n workflows. It
+ * either throws an error or returns the error data, depending on the
+ * `continue on Error` flag.
+ * @param nodeContext - the context of a Node - we need to check if it's a
+ * subclass of {@link IExecuteFunctions}
+ * @param errorContext - the data of the error we want to return to the user
+ * @param isApiError - flag checking if the error is connected to the external
+ * API or internal N8N's logic - based on it we either throw {@link NodeApiError}
+ * or {@link NodeOperationError}
+ */
+export function handleWorkflowError(
+    nodeContext: IAllExecuteFunctions,
+    errorContext: WorkflowErrorContext,
+    isApiError: boolean = false
+): ErrorResponse {
+    if (isIExecuteFunctions(nodeContext) && nodeContext.continueOnFail()) {
+        return {
+            success: false,
+            data: { error: errorContext },
+        };
+    } else if (isApiError) {
+        throw new NodeApiError(nodeContext.getNode(), errorContext);
+    }
+    throw new NodeOperationError(nodeContext.getNode(), errorContext.message);
+}

package/nodes/lime-crm/LimeCrmNode.node.ts

@@ -24,6 +24,8 @@ import {
     getLimetypeProperties,
     getLimetypes,
     getNoHasManyProperties,
+    getCreateMappingColumns,
+    getUpdateMappingColumns,
 } from './methods';
 
 /**
@@ -137,6 +139,8 @@ export class LimeCrmNode implements INodeType {
      * - {@link getFileProperties}
      * - {@link getLimetypeProperties}
      * - {@link getNoHasManyProperties}
+     * - {@link getUpdateMappingColumns}
+     * - {@link getCreateMappingColumns}
      */
     methods = {
         loadOptions: {
@@ -145,6 +149,10 @@ export class LimeCrmNode implements INodeType {
             getFileProperties,
             getNoHasManyProperties,
         },
+        resourceMapping: {
+            getUpdateMappingColumns,
+            getCreateMappingColumns,
+        },
     };
 
     /**

package/nodes/lime-crm/LimeCrmTrigger.node.ts

@@ -8,6 +8,7 @@ import {
     NodeOperationError,
     LoggerProxy as Logger,
     NodeConnectionTypes,
+    NodeApiError,
 } from 'n8n-workflow';
 
 import { LIME_CRM_API_CREDENTIAL_KEY } from './models';
@@ -173,7 +174,7 @@ export class LimeCrmTrigger implements INodeType {
                     Logger.warn(
                         `There was en error while getting a webhook from Lime CRM: ${error}`
                     );
-                    throw new NodeOperationError(this.getNode(), error);
+                    throw new NodeApiError(this.getNode(), error);
                 }
                 return true;
             },
@@ -193,8 +194,14 @@ export class LimeCrmTrigger implements INodeType {
                 // but it's only suited for production environment
                 const existingSubscriptionResponse =
                     await listSubscriptionsWithExistingData(this, webhook);
+                if (!existingSubscriptionResponse.success) {
+                    throw new NodeApiError(this.getNode(), {
+                        message:
+                            existingSubscriptionResponse.data.error.message,
+                    });
+                }
 
-                if (existingSubscriptionResponse.length === 0) {
+                if (existingSubscriptionResponse.data.length === 0) {
                     const credentials = await this.getCredentials(
                         LIME_CRM_API_CREDENTIAL_KEY
                     );
@@ -208,8 +215,15 @@ export class LimeCrmTrigger implements INodeType {
                         webhookCreateData
                     );
 
-                    const subscriptionId = createSubscriptionResponse.id;
-                    const events = createSubscriptionResponse.events;
+                    if (!createSubscriptionResponse.success) {
+                        throw new NodeApiError(this.getNode(), {
+                            message:
+                                createSubscriptionResponse.data.error.message,
+                        });
+                    }
+
+                    const subscriptionId = createSubscriptionResponse.data.id;
+                    const events = createSubscriptionResponse.data.events;
 
                     webhook.data.webhookId = subscriptionId;
                     webhook.data.webhookEvents = events;
@@ -218,7 +232,7 @@ export class LimeCrmTrigger implements INodeType {
                     );
                     return true;
                 } else {
-                    const limeWebhook = existingSubscriptionResponse[0];
+                    const limeWebhook = existingSubscriptionResponse.data[0];
                     webhook.data.webhookId = limeWebhook.id;
                     webhook.data.webhookEvents = limeWebhook.events;
                     Logger.info(

package/nodes/lime-crm/methods/getLimetypeProperties.ts

@@ -22,7 +22,9 @@ async function fetchAllProperties(nodeContext: ILoadOptionsFunctions) {
     Logger.info(`Fetching file properties for Lime type: ${limetype}`);
     if (!limetype) return [];
     try {
-        return await getProperties(nodeContext, limetype);
+        const response = await getProperties(nodeContext, limetype);
+        if (!response.success) return [];
+        return response.data;
     } catch (error) {
         Logger.warn(`There was a problem with fetching properties: ${error}`);
         return [];

package/nodes/lime-crm/methods/getLimetypes.ts

@@ -14,8 +14,9 @@ export async function getLimetypes(
 ): Promise<INodePropertyOptions[]> {
     const data: INodePropertyOptions[] = [];
     const response = await getLimetypesFromApi(this);
+    if (!response.success) return [];
 
-    for (const limetype of response) {
+    for (const limetype of response.data) {
         data.push({
             name: limetype.localname?.singular || limetype.name,
             value: limetype.name,

package/nodes/lime-crm/methods/index.ts

@@ -5,3 +5,8 @@ export {
     getLimetypeProperties,
     getNoHasManyProperties,
 } from './getLimetypeProperties';
+export {
+    getCreateMappingColumns,
+    getUpdateMappingColumns,
+    parseResourceMapperFields,
+} from './resourceMapping';

package/nodes/lime-crm/methods/resourceMapping.ts

@@ -0,0 +1,141 @@
+import {
+    FieldType,
+    ILoadOptionsFunctions,
+    ResourceMapperFields,
+    LoggerProxy as Logger,
+    IExecuteFunctions,
+    IDataObject,
+    ResourceMapperValue,
+} from 'n8n-workflow';
+import { getProperties } from '../transport';
+import { LimetypeProperty } from '../models';
+
+/**
+ * A map of Lime CRM field types to n8n native types
+ */
+const LimeCrmTypeToFieldType = new Map(
+    Object.entries({
+        option: 'options',
+        yesno: 'boolean',
+        decimal: 'number',
+        number: 'number',
+    })
+);
+
+/**
+ * Function which maps Lime CRM to n8n types using the map above. If the type
+ * is not declared in a map, string is used.
+ * @param limeCrmType
+ * @returns n8n native {@link FieldType}
+ */
+function mapLimeCrmType(limeCrmType: string): FieldType {
+    return (LimeCrmTypeToFieldType.get(limeCrmType) as FieldType) || 'string';
+}
+
+/**
+ * Get a `length` addition to the input headers when there's a string field
+ *
+ * @param property - a {@link LimetypeProperty}
+ * @returns a string with length wrapped in quotes or an empty string
+ */
+function getPropertyLength(property: LimetypeProperty): string {
+    return property.type === 'string' ? `(${property.length})` : '';
+}
+
+/**
+ * Base function to get the description of ResourceMapper fields
+ * @param nodeContext
+ * @param mode - either `create` or `update` - based on this flag a `required`
+ * @param limetype - name of a limetype we are creating or updating
+ * property is set
+ */
+async function getMappingColumns(
+    nodeContext: ILoadOptionsFunctions,
+    mode: 'create' | 'update',
+    limetype: string
+): Promise<ResourceMapperFields> {
+    const propertiesResponse = await getProperties(nodeContext, limetype);
+    if (!propertiesResponse.success) {
+        Logger.error(
+            `There was an error with fetching properties: ${JSON.stringify(propertiesResponse.data)}`
+        );
+        return {
+            fields: [],
+        };
+    }
+    const noRelationProperties = propertiesResponse.data.filter(
+        (property) => property.type !== 'hasmany'
+    );
+
+    const fields = noRelationProperties.map((property) => {
+        const propertyLengthDescription = getPropertyLength(property);
+        return {
+            id: property.name,
+            displayName: `${property.localname} [${property.type}${propertyLengthDescription}]`,
+            required: mode === 'create' ? property.required : false,
+            defaultMatch: false,
+            display: true,
+            type: mapLimeCrmType(property.type),
+            options:
+                property.type === 'option' && property.options
+                    ? property.options
+                          .filter((option) => !option.inactive)
+                          .map((option) => {
+                              return {
+                                  value: option.key,
+                                  name: option.text,
+                              };
+                          })
+                    : undefined,
+        };
+    });
+    return {
+        fields: fields.sort((a, b) => {
+            if (a.required !== b.required) {
+                return a.required ? -1 : 1;
+            }
+            return a.displayName.localeCompare(b.displayName);
+        }),
+    };
+}
+
+/**
+ * Parse resource mapper fields from n8n workflow
+ * @param context - Node execution context
+ * @param i - The index of the current item in the workflow execution
+ * @param inputName - name of the resource mapper input
+ * @returns IDataObject - parsed data from resource mapper
+ */
+
+export function parseResourceMapperFields(
+    context: IExecuteFunctions,
+    i: number,
+    inputName: string
+): IDataObject {
+    const propertiesInput = context.getNodeParameter(
+        inputName,
+        i
+    ) as ResourceMapperValue;
+
+    return propertiesInput.value as IDataObject;
+}
+
+/**
+ * Method for getting resource mapper fields in `create` mode
+ */
+export async function getCreateMappingColumns(
+    this: ILoadOptionsFunctions
+): Promise<ResourceMapperFields> {
+    const limetype = this.getNodeParameter('limetype') as string;
+    return getMappingColumns(this, 'create', limetype);
+}
+
+/**
+ * Method for getting resource mapper fields in `update` mode
+ */
+export async function getUpdateMappingColumns(
+    this: ILoadOptionsFunctions
+): Promise<ResourceMapperFields> {
+    const limetype = this.getNodeParameter('limetype') as string;
+    return getMappingColumns(this, 'update', limetype);
+}

package/nodes/lime-crm/models/limetype.ts

@@ -1,11 +1,26 @@
 import { APIResponseValue } from './constants';
 
+/**
+ * Limetype option used only for fields with `option` type.
+ * @property key - ID of an option, used as a value for POST/PUT requests in API
+ * @property text - display name of an option
+ * @property inactive - flag describing whether the property is used or not
+ */
+type LimetypePropertyOption = {
+    key: string;
+    text: string;
+    inactive: boolean;
+};
+
 /**
  * Representation of a property of a Limetype.
  *
  * @property name - The internal name of the property
  * @property localname - The display name of the property
  * @property type - The type of the property (e.g., string, file, hasmany)
+ * @property required - describes whether a property is required or not
+ * @property options - a set of {@link LimetypePropertyOption} used only for
+ * fields with type `option`.
  *
  * @public
  * @group Models
@@ -14,6 +29,9 @@ export type LimetypeProperty = {
     name: string;
     localname: string;
     type: string;
+    required: boolean;
+    length?: number;
+    options?: LimetypePropertyOption[];
 } & Record<string, APIResponseValue>;
 
 /**

package/nodes/lime-crm/resources/admin/index.ts

@@ -68,10 +68,15 @@ export async function adminOperations(
     switch (operation) {
         case 'getManyUsers': {
             const result = await operations.getManyUsers.execute.call(this, i);
-
-            return result.map((item: User) => ({
-                json: item,
-            }));
+            if (Array.isArray(result)) {
+                return result.map((item: User) => ({
+                    json: item,
+                }));
+            } else {
+                return {
+                    json: result,
+                };
+            }
         }
         case 'getSingleUser': {
             return {

package/nodes/lime-crm/resources/admin/operations/getManyUsers.operation.ts

@@ -8,6 +8,7 @@ import {
     DEFAULT_API_OBJECT_LIMIT,
 } from '../../../models';
 import { fetchManyUsers } from '../../../transport';
+import { WorkflowResponse } from '../../../../response';
 
 export const description = {
     name: 'Get many users',
@@ -144,7 +145,7 @@ export const properties: INodeProperties[] = [
 export async function execute(
     this: IExecuteFunctions,
     i: number
-): Promise<User[]> {
+): Promise<WorkflowResponse<User[]>> {
     const active = this.getNodeParameter('active', i) as
         | boolean
         | NullOptionType;
@@ -162,5 +163,12 @@ export async function execute(
         i,
         false
     ) as boolean;
-    return await fetchManyUsers(this, active, userType, limit, withCoworker);
+    const response = await fetchManyUsers(
+        this,
+        active,
+        userType,
+        limit,
+        withCoworker
+    );
+    return response.data;
 }

package/nodes/lime-crm/resources/admin/operations/getSingleUser.operation.ts

@@ -1,14 +1,11 @@
-import {
-    IExecuteFunctions,
-    INodeProperties,
-    NodeOperationError,
-} from 'n8n-workflow';
-
+import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
 import { User, ADMIN_RESOURCE } from '../../../models';
 import {
     fetchSingleUserById,
     fetchSingleUserByLimeobjectId,
 } from '../../../transport';
+import { WorkflowResponse, APIResponse } from '../../../../response';
+import { handleWorkflowError } from '../../../../errorHandling';
 
 export const description = {
     name: 'Get single user',
@@ -94,20 +91,22 @@ export const properties: INodeProperties[] = [
 export async function execute(
     this: IExecuteFunctions,
     i: number
-): Promise<User> {
+): Promise<WorkflowResponse<User>> {
     const source = this.getNodeParameter('source', i) as string;
     const id = this.getNodeParameter('identifier', i) as string;
     const withCoworker = this.getNodeParameter('withCoworker', i) as boolean;
 
+    let response: APIResponse<User>;
+
     if (source == 'byUser') {
-        return await fetchSingleUserById(this, id, withCoworker);
-    }
-    if (source == 'byLimeobject') {
-        return await fetchSingleUserByLimeobjectId(this, id, withCoworker);
+        response = await fetchSingleUserById(this, id, withCoworker);
+    } else if (source == 'byLimeobject') {
+        response = await fetchSingleUserByLimeobjectId(this, id, withCoworker);
+    } else {
+        response = handleWorkflowError(this, {
+            message: `The source ${source} is not supported!`,
+        });
     }
 
-    throw new NodeOperationError(
-        this.getNode(),
-        `The source "${source}" is not supported!`
-    );
+    return response.data;
 }

package/nodes/lime-crm/resources/data/index.ts

@@ -87,21 +87,30 @@ export async function dataOperations(
         }
         case 'updateSingleObject': {
             return {
-                json: await operations.updateSingleObject.execute.call(this, i),
+                ...(await operations.updateSingleObject.execute.call(this, i)),
             };
         }
         case 'deleteSingleObject': {
-            await operations.deleteSingleObject.execute.call(this, i);
-            return { json: {} };
+            const response = await operations.deleteSingleObject.execute.call(
+                this,
+                i
+            );
+            return { json: response };
         }
         case 'getManyObjects': {
             const result = await operations.getManyObjects.execute.call(
                 this,
                 i
             );
-            return result.map((item) => ({
-                json: item,
-            }));
+            if (Array.isArray(result)) {
+                return result.map((item) => ({
+                    json: item,
+                }));
+            } else {
+                return {
+                    json: result,
+                };
+            }
         }
         case 'getSingleFile': {
             return await operations.getSingleFile.execute.call(this, i);