@limetech/n8n-nodes-lime 0.1.0

package/nodes/lime-crm/resources/limeType/operations/getRelations.operation.ts

@@ -0,0 +1,105 @@
+import {
+    IExecuteFunctions,
+    INodeProperties,
+    IDataObject,
+    NodeOperationError,
+} from 'n8n-workflow';
+
+export const description = {
+    name: 'Get Relations',
+    value: 'getRelations',
+    description: 'Get all relations for a specific entity type',
+    action: 'Get entity type relations',
+};
+
+export const properties: INodeProperties[] = [
+    // Limetype selection
+    {
+        displayName: 'Type Name',
+        name: 'typeName',
+        type: 'options',
+        typeOptions: {
+            loadOptionsMethod: 'getLimeTypes',
+        },
+        required: true,
+        default: '',
+        description: 'The name of the entity type to get relations for',
+        displayOptions: {
+            show: {
+                resource: [
+                    'limeType',
+                ],
+                operation: [
+                    'getRelations',
+                ],
+            },
+        },
+    },
+
+    // Options for the operation
+    {
+        displayName: 'Options',
+        name: 'options',
+        type: 'collection',
+        placeholder: 'Add Option',
+        default: {},
+        displayOptions: {
+            show: {
+                resource: [
+                    'limeType',
+                ],
+                operation: [
+                    'getRelations',
+                ],
+            },
+        },
+        options: [
+            {
+                displayName: 'Include System Relations',
+                name: 'includeSystemRelations',
+                type: 'boolean',
+                default: false,
+                description: 'Whether to include system relations in the response',
+            },
+            {
+                displayName: 'Include Hidden Relations',
+                name: 'includeHiddenRelations',
+                type: 'boolean',
+                default: false,
+                description: 'Whether to include hidden relations in the response',
+            },
+        ],
+    },
+];
+
+export async function execute(
+    this: IExecuteFunctions,
+    i: number,
+) {
+    const { apiRequest } = await import('../../../transport');
+    const typeName = this.getNodeParameter('typeName', i) as string;
+    const options = this.getNodeParameter('options', i, {}) as IDataObject;
+
+    if (!typeName) {
+        throw new NodeOperationError(this.getNode(), 'Type name must be provided');
+    }
+
+    // Prepare query parameters
+    const qs: IDataObject = {};
+    if (options.includeSystemRelations) {
+        qs.includeSystem = true;
+    }
+    if (options.includeHiddenRelations) {
+        qs.includeHidden = true;
+    }
+
+    // Make API request
+    const response = await apiRequest.call(this, {
+        method: 'GET',
+        endpoint: `/api/v1/limetype/${encodeURIComponent(typeName)}/relation`,
+        qs,
+    });
+
+    // Return the response data
+    return response;
+}

package/nodes/lime-crm/resources/limeType/operations/getType.operation.ts

@@ -0,0 +1,58 @@
+import {
+    IExecuteFunctions,
+    INodeProperties,
+    NodeOperationError,
+} from 'n8n-workflow';
+
+export const description = {
+    name: 'Get Type',
+    value: 'getType',
+    description: 'Get details about a specific entity type',
+    action: 'Get entity type details',
+};
+
+export const properties: INodeProperties[] = [
+    // Limetype selection
+    {
+        displayName: 'Type Name',
+        name: 'typeName',
+        type: 'options',
+        typeOptions: {
+            loadOptionsMethod: 'getLimeTypes',
+        },
+        required: true,
+        default: '',
+        description: 'The name of the entity type to get details for',
+        displayOptions: {
+            show: {
+                resource: [
+                    'limeType',
+                ],
+                operation: [
+                    'getType',
+                ],
+            },
+        },
+    },
+];
+
+export async function execute(
+    this: IExecuteFunctions,
+    i: number,
+) {
+    const { apiRequest } = await import('../../../transport');
+    const typeName = this.getNodeParameter('typeName', i) as string;
+
+    if (!typeName) {
+        throw new NodeOperationError(this.getNode(), 'Type name must be provided');
+    }
+
+    // Make API request
+    const response = await apiRequest.call(this, {
+        method: 'GET',
+        endpoint: `/api/v1/limetype/${encodeURIComponent(typeName)}`,
+    });
+
+    // Return the response data
+    return response;
+}

package/nodes/lime-crm/resources/limeType/operations/listTypes.operation.ts

@@ -0,0 +1,76 @@
+import {
+    IExecuteFunctions,
+    INodeProperties,
+    IDataObject,
+} from 'n8n-workflow';
+
+export const description = {
+    name: 'List Types',
+    value: 'listTypes',
+    description: 'Get a list of all available entity types',
+    action: 'List all entity types',
+};
+
+export const properties: INodeProperties[] = [
+    // Options for the operation
+    {
+        displayName: 'Options',
+        name: 'options',
+        type: 'collection',
+        placeholder: 'Add Option',
+        default: {},
+        displayOptions: {
+            show: {
+                resource: [
+                    'limeType',
+                ],
+                operation: [
+                    'listTypes',
+                ],
+            },
+        },
+        options: [
+            {
+                displayName: 'Include System Types',
+                name: 'includeSystemTypes',
+                type: 'boolean',
+                default: false,
+                description: 'Whether to include system types in the response',
+            },
+            {
+                displayName: 'Include Hidden Types',
+                name: 'includeHiddenTypes',
+                type: 'boolean',
+                default: false,
+                description: 'Whether to include hidden types in the response',
+            },
+        ],
+    },
+];
+
+export async function execute(
+    this: IExecuteFunctions,
+    i: number,
+) {
+    const { apiRequest } = await import('../../../transport');
+    const options = this.getNodeParameter('options', i, {}) as IDataObject;
+
+    // Prepare query parameters
+    const qs: IDataObject = {};
+    if (options.includeSystemTypes) {
+        qs.includeSystem = true;
+    }
+    if (options.includeHiddenTypes) {
+        qs.includeHidden = true;
+    }
+
+    // Make API request
+    const response = await apiRequest.call(this, {
+        method: 'GET',
+        endpoint: '/api/v1/limetype',
+        qs,
+    });
+
+    // Return the response data
+    return response;
+}

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

@@ -0,0 +1,42 @@
+import { IExecuteFunctions, INodeProperties, NodePropertyTypes } from 'n8n-workflow';
+
+import * as executeQuery from './operations/executeQuery.operation';
+
+// Export fields for the node
+export const queryApiFields: INodeProperties[] = [
+    // Operation selection for Query API
+    {
+        displayName: 'Operation',
+        name: 'operation',
+        type: 'options' as NodePropertyTypes,
+        noDataExpression: true,
+        displayOptions: {
+            show: {
+                resource: [
+                    'queryApi',
+                ],
+            },
+        },
+        options: [
+            {
+                ...executeQuery.description,
+            },
+        ],
+        default: 'executeQuery',
+    },
+
+    // All operation-specific fields are now imported from operations
+    ...executeQuery.properties,
+];
+
+// Operations router
+export async function queryApiOperations(
+    this: IExecuteFunctions,
+    { operation, i }: { operation: string; i: number },
+) {
+    if (operation === 'executeQuery') {
+        return await executeQuery.execute.call(this, i);
+    }
+
+    return null;
+}