n8n-nodes-imis 0.1.0

package/dist/credentials/ImisCrmApi.credentials.d.ts

@@ -0,0 +1,7 @@
+import { ICredentialType, INodeProperties } from 'n8n-workflow';
+export declare class ImisCrmApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    documentationUrl: string;
+    properties: INodeProperties[];
+}

package/dist/credentials/ImisCrmApi.credentials.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImisCrmApi = void 0;
+class ImisCrmApi {
+    constructor() {
+        this.name = 'imisCrmApi';
+        this.displayName = 'iMIS CRM API';
+        this.documentationUrl = 'https://developer.imis.com/';
+        this.properties = [
+            {
+                displayName: 'Host URL',
+                name: 'hostUrl',
+                type: 'string',
+                default: '',
+                placeholder: 'https://your-imis-instance.com',
+                required: true,
+                description: 'The base URL of your iMIS instance (without trailing slash)',
+            },
+            {
+                displayName: 'Username',
+                name: 'username',
+                type: 'string',
+                default: '',
+                required: true,
+                description: 'Your iMIS username',
+            },
+            {
+                displayName: 'Password',
+                name: 'password',
+                type: 'string',
+                typeOptions: {
+                    password: true,
+                },
+                default: '',
+                required: true,
+                description: 'Your iMIS password',
+            },
+        ];
+        // Note: Credential testing will be handled by the authentication flow in the node
+    }
+}
+exports.ImisCrmApi = ImisCrmApi;

package/dist/credentials/TdnWorkflowApi.credentials.d.ts

@@ -0,0 +1,7 @@
+import { ICredentialType, INodeProperties } from 'n8n-workflow';
+export declare class TdnWorkflowApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    documentationUrl: string;
+    properties: INodeProperties[];
+}

package/dist/credentials/TdnWorkflowApi.credentials.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TdnWorkflowApi = void 0;
+class TdnWorkflowApi {
+    constructor() {
+        this.name = 'tdnWorkflowApi';
+        this.displayName = '3DN Workflow API';
+        this.documentationUrl = '';
+        this.properties = [
+            {
+                displayName: 'Base URL',
+                name: 'baseUrl',
+                type: 'string',
+                default: '',
+                placeholder: 'http://localhost:3000',
+                required: true,
+                description: 'The base URL of your 3DN Workflow instance (without trailing slash)',
+            },
+            {
+                displayName: 'API Key',
+                name: 'apiKey',
+                type: 'string',
+                typeOptions: {
+                    password: true,
+                },
+                default: '',
+                required: true,
+                description: 'Your 3DN Workflow API key',
+            },
+        ];
+    }
+}
+exports.TdnWorkflowApi = TdnWorkflowApi;

package/dist/nodes/ImisCrmIqa/ImisCrmIqa.node.d.ts

@@ -0,0 +1,5 @@
+import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
+export declare class ImisCrmIqa implements INodeType {
+    description: INodeTypeDescription;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/ImisCrmIqa/ImisCrmIqa.node.js

@@ -0,0 +1,281 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImisCrmIqa = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const ImisAuth_1 = require("./helpers/ImisAuth");
+function transformImisData(rawData) {
+    const cleanObject = (obj) => {
+        if (obj === null || obj === undefined) {
+            return obj;
+        }
+        if (Array.isArray(obj)) {
+            return obj.map(item => cleanObject(item));
+        }
+        if (typeof obj === 'object') {
+            const cleaned = {};
+            for (const [key, value] of Object.entries(obj)) {
+                if (key === '$type') {
+                    continue;
+                }
+                const cleanKey = key.startsWith('$') ? key.substring(1) : key;
+                cleaned[cleanKey] = cleanObject(value);
+            }
+            return cleaned;
+        }
+        return obj;
+    };
+    return cleanObject(rawData);
+}
+class ImisCrmIqa {
+    constructor() {
+        this.description = {
+            displayName: 'iMIS IQA Query',
+            name: 'imisCrmIqa',
+            icon: 'file:3DN.png',
+            group: ['transform'],
+            version: 1,
+            description: 'Execute iMIS IQA queries and return iterable JSON results',
+            defaults: {
+                name: 'iMIS IQA Query',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'imisCrmApi',
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Execute Query',
+                            value: 'executeQuery',
+                            description: 'Execute an IQA query and return results',
+                        },
+                    ],
+                    default: 'executeQuery',
+                    required: true,
+                },
+                {
+                    displayName: 'Query Name',
+                    name: 'queryName',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            operation: ['executeQuery'],
+                        },
+                    },
+                    default: '',
+                    required: true,
+                    description: 'The full path to the IQA query (e.g., $/Common/Queries/Value Lists/MemberTypeList)',
+                    placeholder: '$/Common/Queries/Value Lists/MemberTypeList',
+                },
+                {
+                    displayName: 'Split Results',
+                    name: 'splitResults',
+                    type: 'boolean',
+                    displayOptions: {
+                        show: {
+                            operation: ['executeQuery'],
+                        },
+                    },
+                    default: true,
+                    description: 'Whether to split results into separate items (one per result row) or return all results as a single item',
+                },
+                {
+                    displayName: 'Additional Options',
+                    name: 'additionalOptions',
+                    type: 'collection',
+                    placeholder: 'Add Option',
+                    default: {},
+                    displayOptions: {
+                        show: {
+                            operation: ['executeQuery'],
+                        },
+                    },
+                    options: [
+                        {
+                            displayName: 'Limit',
+                            name: 'limit',
+                            type: 'number',
+                            default: 100,
+                            description: 'Maximum number of results to return',
+                            typeOptions: {
+                                minValue: 1,
+                                maxValue: 10000,
+                            },
+                        },
+                        {
+                            displayName: 'Offset',
+                            name: 'offset',
+                            type: 'number',
+                            default: 0,
+                            description: 'Number of results to skip (for pagination)',
+                            typeOptions: {
+                                minValue: 0,
+                            },
+                        },
+                        {
+                            displayName: 'Query Parameters',
+                            name: 'queryParameters',
+                            type: 'fixedCollection',
+                            typeOptions: {
+                                multipleValues: true,
+                            },
+                            default: {},
+                            description: 'Query parameters to pass to the IQA query',
+                            options: [
+                                {
+                                    name: 'parameter',
+                                    displayName: 'Parameter',
+                                    values: [
+                                        {
+                                            displayName: 'Name',
+                                            name: 'name',
+                                            type: 'string',
+                                            default: '',
+                                            description: 'Parameter name (for reference - iMIS uses positional parameters)',
+                                        },
+                                        {
+                                            displayName: 'Value',
+                                            name: 'value',
+                                            type: 'string',
+                                            default: '',
+                                            description: 'Parameter value (must match order in IQA query definition)',
+                                        },
+                                    ],
+                                },
+                            ],
+                        },
+                    ],
+                },
+            ],
+        };
+    }
+    async execute() {
+        var _a, _b;
+        const items = this.getInputData();
+        const returnData = [];
+        const operation = this.getNodeParameter('operation', 0);
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const credentials = await this.getCredentials('imisCrmApi');
+                const imisAuth = new ImisAuth_1.ImisAuth({
+                    hostUrl: credentials.hostUrl,
+                    username: credentials.username,
+                    password: credentials.password,
+                });
+                if (operation === 'executeQuery') {
+                    const queryName = this.getNodeParameter('queryName', i);
+                    const splitResults = this.getNodeParameter('splitResults', i, true);
+                    const additionalOptions = this.getNodeParameter('additionalOptions', i, {});
+                    if (!queryName || queryName.trim() === '') {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Query Name is required for item ${i}`);
+                    }
+                    // Build the query URL
+                    let queryUrl = `${credentials.hostUrl}/api/IQA?QueryName=${encodeURIComponent(queryName.trim())}`;
+                    // Add limit and offset if specified
+                    if (additionalOptions.limit !== undefined) {
+                        queryUrl += `&limit=${additionalOptions.limit}`;
+                    }
+                    if (additionalOptions.offset !== undefined) {
+                        queryUrl += `&offset=${additionalOptions.offset}`;
+                    }
+                    // Add query parameters if specified
+                    // iMIS IQA API requires parameters as &Parameter=value (repeated for each parameter in order)
+                    // The parameter name is not included - only values, in the order defined in the IQA query
+                    if ((_a = additionalOptions.queryParameters) === null || _a === void 0 ? void 0 : _a.parameter) {
+                        const params = additionalOptions.queryParameters.parameter;
+                        params.forEach(param => {
+                            // Pass the value using &Parameter= format as required by iMIS IQA API
+                            queryUrl += `&Parameter=${encodeURIComponent(param.value || '')}`;
+                        });
+                    }
+                    // Execute the query
+                    const response = await imisAuth.makeAuthenticatedRequest(this.helpers.httpRequest.bind(this.helpers), {
+                        method: 'GET',
+                        url: queryUrl,
+                    });
+                    // Extract items from response
+                    // IQA returns: { Items: { $values: [...] } } or { $values: [...] }
+                    const items = ((_b = response.Items) === null || _b === void 0 ? void 0 : _b.$values) || response.$values || [];
+                    if (!Array.isArray(items)) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Expected array of results from IQA query, got: ${typeof items}`);
+                    }
+                    // Transform the data
+                    const cleanedItems = items.map((item) => {
+                        var _a;
+                        // IQA returns data in Properties collection
+                        const properties = ((_a = item.Properties) === null || _a === void 0 ? void 0 : _a.$values) || [];
+                        // Convert properties array to object
+                        const dataObject = {};
+                        if (Array.isArray(properties)) {
+                            properties.forEach((prop) => {
+                                const name = prop.Name || prop.name;
+                                const value = prop.Value !== undefined ? prop.Value : prop.value;
+                                if (name) {
+                                    dataObject[name] = value;
+                                }
+                            });
+                        }
+                        // If no properties found, return the transformed item as-is
+                        if (Object.keys(dataObject).length === 0) {
+                            return transformImisData(item);
+                        }
+                        return dataObject;
+                    });
+                    const metadata = {
+                        operation,
+                        queryName: queryName.trim(),
+                        resultCount: cleanedItems.length,
+                        executedAt: new Date().toISOString(),
+                    };
+                    if (splitResults) {
+                        // Return each result as a separate item
+                        cleanedItems.forEach((item, index) => {
+                            returnData.push({
+                                json: item,
+                                meta: {
+                                    ...metadata,
+                                    itemIndex: index,
+                                },
+                            });
+                        });
+                    }
+                    else {
+                        // Return all results as a single item
+                        returnData.push({
+                            json: {
+                                results: cleanedItems,
+                                metadata,
+                            },
+                            meta: metadata,
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: {
+                            error: error.message,
+                        },
+                        meta: {
+                            error: true,
+                        },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+}
+exports.ImisCrmIqa = ImisCrmIqa;

package/dist/nodes/ImisCrmIqa/helpers/ImisAuth.d.ts

@@ -0,0 +1,17 @@
+import { IHttpRequestOptions } from 'n8n-workflow';
+interface ImisCredentials {
+    hostUrl: string;
+    username: string;
+    password: string;
+}
+export declare class ImisAuth {
+    private accessToken;
+    private tokenExpiry;
+    private credentials;
+    constructor(credentials: ImisCredentials);
+    private requestNewToken;
+    private isTokenExpired;
+    getAccessToken(httpRequest: (options: IHttpRequestOptions) => Promise<any>): Promise<string>;
+    makeAuthenticatedRequest(httpRequest: (options: IHttpRequestOptions) => Promise<any>, requestOptions: IHttpRequestOptions): Promise<any>;
+}
+export {};

package/dist/nodes/ImisCrmIqa/helpers/ImisAuth.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImisAuth = void 0;
+class ImisAuth {
+    constructor(credentials) {
+        this.accessToken = null;
+        this.tokenExpiry = null;
+        this.credentials = credentials;
+    }
+    async requestNewToken(httpRequest) {
+        var _a, _b;
+        const formData = `grant_type=password&username=${encodeURIComponent(this.credentials.username)}&password=${encodeURIComponent(this.credentials.password)}`;
+        // Clean URL - remove trailing slash
+        const cleanUrl = this.credentials.hostUrl.replace(/\/$/, '');
+        try {
+            const response = await httpRequest({
+                method: 'POST',
+                url: `${cleanUrl}/token`,
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                },
+                body: formData,
+            });
+            if (!response.access_token) {
+                throw new Error('Failed to obtain access token from iMIS - no access_token in response');
+            }
+            return response;
+        }
+        catch (error) {
+            if (((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 401) {
+                throw new Error('Invalid iMIS credentials - check username and password');
+            }
+            else if (((_b = error.response) === null || _b === void 0 ? void 0 : _b.status) === 404) {
+                throw new Error('iMIS token endpoint not found - check Host URL');
+            }
+            throw new Error(`Failed to obtain access token: ${error.message || 'Unknown error'}`);
+        }
+    }
+    isTokenExpired() {
+        if (!this.tokenExpiry) {
+            return true;
+        }
+        // Add 5 minute buffer before actual expiry
+        const bufferTime = 5 * 60 * 1000; // 5 minutes in milliseconds
+        return new Date().getTime() > (this.tokenExpiry.getTime() - bufferTime);
+    }
+    async getAccessToken(httpRequest) {
+        if (!this.accessToken || this.isTokenExpired()) {
+            const tokenResponse = await this.requestNewToken(httpRequest);
+            this.accessToken = tokenResponse.access_token;
+            // Calculate expiry time
+            const expiryTime = new Date();
+            expiryTime.setSeconds(expiryTime.getSeconds() + tokenResponse.expires_in);
+            this.tokenExpiry = expiryTime;
+        }
+        return this.accessToken;
+    }
+    async makeAuthenticatedRequest(httpRequest, requestOptions) {
+        var _a;
+        const token = await this.getAccessToken(httpRequest);
+        const authenticatedOptions = {
+            ...requestOptions,
+            headers: {
+                ...requestOptions.headers,
+                Authorization: `Bearer ${token}`,
+            },
+        };
+        try {
+            return await httpRequest(authenticatedOptions);
+        }
+        catch (error) {
+            // If we get a 401, token might be invalid, try refreshing once
+            if (((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 401) {
+                // Force token refresh
+                this.accessToken = null;
+                this.tokenExpiry = null;
+                const newToken = await this.getAccessToken(httpRequest);
+                authenticatedOptions.headers = {
+                    ...authenticatedOptions.headers,
+                    Authorization: `Bearer ${newToken}`,
+                };
+                return await httpRequest(authenticatedOptions);
+            }
+            throw error;
+        }
+    }
+}
+exports.ImisAuth = ImisAuth;

package/dist/nodes/ImisCrmTrigger/ImisAuth.d.ts

@@ -0,0 +1,17 @@
+import { IHttpRequestOptions } from 'n8n-workflow';
+interface ImisCredentials {
+    hostUrl: string;
+    username: string;
+    password: string;
+}
+export declare class ImisAuth {
+    private accessToken;
+    private tokenExpiry;
+    private credentials;
+    constructor(credentials: ImisCredentials);
+    private requestNewToken;
+    private isTokenExpired;
+    getAccessToken(httpRequest: (options: IHttpRequestOptions) => Promise<any>): Promise<string>;
+    makeAuthenticatedRequest(httpRequest: (options: IHttpRequestOptions) => Promise<any>, requestOptions: IHttpRequestOptions): Promise<any>;
+}
+export {};

package/dist/nodes/ImisCrmTrigger/ImisAuth.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImisAuth = void 0;
+class ImisAuth {
+    constructor(credentials) {
+        this.accessToken = null;
+        this.tokenExpiry = null;
+        this.credentials = credentials;
+    }
+    async requestNewToken(httpRequest) {
+        var _a, _b;
+        const formData = `grant_type=password&username=${encodeURIComponent(this.credentials.username)}&password=${encodeURIComponent(this.credentials.password)}`;
+        // Clean URL - remove trailing slash
+        const cleanUrl = this.credentials.hostUrl.replace(/\/$/, '');
+        try {
+            const response = await httpRequest({
+                method: 'POST',
+                url: `${cleanUrl}/token`,
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                },
+                body: formData,
+            });
+            if (!response.access_token) {
+                throw new Error('Failed to obtain access token from iMIS - no access_token in response');
+            }
+            return response;
+        }
+        catch (error) {
+            if (((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 401) {
+                throw new Error('Invalid iMIS credentials - check username and password');
+            }
+            else if (((_b = error.response) === null || _b === void 0 ? void 0 : _b.status) === 404) {
+                throw new Error('iMIS token endpoint not found - check Host URL');
+            }
+            throw new Error(`Failed to obtain access token: ${error.message || 'Unknown error'}`);
+        }
+    }
+    isTokenExpired() {
+        if (!this.tokenExpiry) {
+            return true;
+        }
+        // Add 5 minute buffer before actual expiry
+        const bufferTime = 5 * 60 * 1000; // 5 minutes in milliseconds
+        return new Date().getTime() > (this.tokenExpiry.getTime() - bufferTime);
+    }
+    async getAccessToken(httpRequest) {
+        if (!this.accessToken || this.isTokenExpired()) {
+            const tokenResponse = await this.requestNewToken(httpRequest);
+            this.accessToken = tokenResponse.access_token;
+            // Calculate expiry time
+            const expiryTime = new Date();
+            expiryTime.setSeconds(expiryTime.getSeconds() + tokenResponse.expires_in);
+            this.tokenExpiry = expiryTime;
+        }
+        return this.accessToken;
+    }
+    async makeAuthenticatedRequest(httpRequest, requestOptions) {
+        var _a;
+        const token = await this.getAccessToken(httpRequest);
+        const authenticatedOptions = {
+            ...requestOptions,
+            headers: {
+                ...requestOptions.headers,
+                Authorization: `Bearer ${token}`,
+            },
+        };
+        try {
+            return await httpRequest(authenticatedOptions);
+        }
+        catch (error) {
+            // If we get a 401, token might be invalid, try refreshing once
+            if (((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 401) {
+                // Force token refresh
+                this.accessToken = null;
+                this.tokenExpiry = null;
+                const newToken = await this.getAccessToken(httpRequest);
+                authenticatedOptions.headers = {
+                    ...authenticatedOptions.headers,
+                    Authorization: `Bearer ${newToken}`,
+                };
+                return await httpRequest(authenticatedOptions);
+            }
+            throw error;
+        }
+    }
+}
+exports.ImisAuth = ImisAuth;

package/dist/nodes/ImisCrm_Unified/ImisCrm.node.d.ts

@@ -0,0 +1,15 @@
+import { IExecuteFunctions, ILoadOptionsFunctions, INodeExecutionData, INodePropertyOptions, INodeType, INodeTypeDescription } from 'n8n-workflow';
+export declare class ImisCrm implements INodeType {
+    description: INodeTypeDescription;
+    methods: {
+        loadOptions: {
+            getSalutations(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getGenders(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getMemberStatuses(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getCategories(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getMemberTypes(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getActivityTypes(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+        };
+    };
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}