n8n-nodes-james-pro 0.1.0

package/README.md

@@ -0,0 +1,43 @@
+# n8n-nodes-james-pro
+
+Community node for the James PRO API.
+
+## Credentials
+
+The James PRO API uses HTTP Basic Auth with an API `key` as username and `secret` as password.
+Request these credentials from `https://start.jamespro.nl/api/auth/` using your James PRO username, password, and a device type.
+
+## Supported resources
+
+- Branch
+- Company
+- Contact
+- File
+- Invoice
+- Me
+- Note
+- Offer
+- Project
+- Setting
+- Tag
+- Task
+
+List operations support `limit`, `page`, `fields`, `include`, and JSON filters such as:
+
+```json
+{
+  "name": "James PRO B.V.",
+  "client": 1
+}
+```
+
+Create and update operations accept a JSON request body so the node can cover all fields documented by James PRO without forcing a narrow form UI.
+
+## Development
+
+```bash
+npm install
+npm run build
+```
+
+To test locally in n8n, install this package as a community node or link it into your n8n custom extensions setup.

package/dist/credentials/JamesProApi.credentials.d.ts

@@ -0,0 +1,9 @@
+import type { ICredentialTestRequest, ICredentialType, INodeProperties, IAuthenticateGeneric } from 'n8n-workflow';
+export declare class JamesProApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    documentationUrl: string;
+    properties: INodeProperties[];
+    authenticate: IAuthenticateGeneric;
+    test: ICredentialTestRequest;
+}

package/dist/credentials/JamesProApi.credentials.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JamesProApi = void 0;
+class JamesProApi {
+    name = 'jamesProApi';
+    displayName = 'James PRO API';
+    documentationUrl = 'https://start.jamespro.nl/api';
+    properties = [
+        {
+            displayName: 'Base URL',
+            name: 'baseUrl',
+            type: 'string',
+            default: 'https://start.jamespro.nl/api',
+            required: true,
+            description: 'Base URL of the James PRO API',
+        },
+        {
+            displayName: 'API Key',
+            name: 'key',
+            type: 'string',
+            default: '',
+            required: true,
+            description: 'James PRO API key. This is used as the Basic Auth username.',
+        },
+        {
+            displayName: 'API Secret',
+            name: 'secret',
+            type: 'string',
+            typeOptions: {
+                password: true,
+            },
+            default: '',
+            required: true,
+            description: 'James PRO API secret. This is used as the Basic Auth password.',
+        },
+    ];
+    authenticate = {
+        type: 'generic',
+        properties: {
+            auth: {
+                username: '={{$credentials.key}}',
+                password: '={{$credentials.secret}}',
+            },
+        },
+    };
+    test = {
+        request: {
+            baseURL: '={{$credentials.baseUrl}}',
+            url: '/me/',
+            method: 'GET',
+        },
+    };
+}
+exports.JamesProApi = JamesProApi;

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

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

package/dist/nodes/JamesPro/JamesPro.node.js

@@ -0,0 +1,675 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JamesPro = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const RESOURCE_CONFIGS = [
+    {
+        displayName: 'Branch',
+        name: 'branch',
+        listPath: '/branches/',
+        itemPath: '/branch',
+        canCreate: true,
+        canUpdate: true,
+        canDelete: true,
+    },
+    {
+        displayName: 'Company',
+        name: 'company',
+        listPath: '/companies/',
+        itemPath: '/company',
+        canCreate: true,
+        canUpdate: true,
+        canDelete: true,
+    },
+    {
+        displayName: 'Contact',
+        name: 'contact',
+        listPath: '/contacts/',
+        itemPath: '/contact',
+        canCreate: true,
+        canUpdate: true,
+        canDelete: true,
+    },
+    {
+        displayName: 'File',
+        name: 'file',
+        listPath: '/files/',
+        itemPath: '/file',
+        canCreate: true,
+        canUpdate: true,
+        canDelete: true,
+    },
+    {
+        displayName: 'Invoice',
+        name: 'invoice',
+        listPath: '/invoices/',
+        itemPath: '/invoice',
+        canCreate: true,
+        canUpdate: true,
+        canDelete: true,
+    },
+    {
+        displayName: 'Me',
+        name: 'me',
+        itemPath: '/me/',
+        canCreate: false,
+        canUpdate: true,
+        canDelete: false,
+    },
+    {
+        displayName: 'Note',
+        name: 'note',
+        listPath: '/notes/',
+        itemPath: '/note',
+        canCreate: true,
+        canUpdate: true,
+        canDelete: true,
+    },
+    {
+        displayName: 'Offer',
+        name: 'offer',
+        listPath: '/offers/',
+        itemPath: '/offer',
+        canCreate: true,
+        canUpdate: true,
+        canDelete: true,
+    },
+    {
+        displayName: 'Project',
+        name: 'project',
+        listPath: '/projects/',
+        itemPath: '/project',
+        canCreate: true,
+        canUpdate: true,
+        canDelete: true,
+    },
+    {
+        displayName: 'Setting',
+        name: 'setting',
+        listPath: '/settings/',
+        itemPath: '/setting',
+        canCreate: true,
+        canUpdate: true,
+        canDelete: true,
+    },
+    {
+        displayName: 'Tag',
+        name: 'tag',
+        listPath: '/tags/',
+        itemPath: '/tag',
+        canCreate: true,
+        canUpdate: true,
+        canDelete: true,
+    },
+    {
+        displayName: 'Task',
+        name: 'task',
+        listPath: '/tasks/',
+        itemPath: '/task',
+        canCreate: true,
+        canUpdate: true,
+        canDelete: true,
+    },
+];
+const crudResources = RESOURCE_CONFIGS.filter((resource) => resource.name !== 'me').map((resource) => resource.name);
+const listResources = RESOURCE_CONFIGS.filter((resource) => resource.listPath).map((resource) => resource.name);
+const getResources = RESOURCE_CONFIGS.map((resource) => resource.name);
+const commonQueryProperties = [
+    {
+        displayName: 'Fields',
+        name: 'fields',
+        type: 'string',
+        default: '',
+        description: 'Comma-separated list of fields to return, for example: id,name,email',
+        displayOptions: {
+            show: {
+                resource: getResources,
+                operation: ['get', 'getAll'],
+            },
+        },
+    },
+    {
+        displayName: 'Include',
+        name: 'include',
+        type: 'string',
+        default: '',
+        description: 'Related information to include when supported by the endpoint',
+        displayOptions: {
+            show: {
+                resource: getResources,
+                operation: ['get', 'getAll'],
+            },
+        },
+    },
+];
+const listQueryProperties = [
+    {
+        displayName: 'Return All',
+        name: 'returnAll',
+        type: 'boolean',
+        default: false,
+        description: 'Whether to return all results by paging through the API response',
+        displayOptions: {
+            show: {
+                resource: listResources,
+                operation: ['getAll'],
+            },
+        },
+    },
+    {
+        displayName: 'Limit',
+        name: 'limit',
+        type: 'string',
+        default: '30',
+        description: 'Maximum number of records to return. James PRO also supports offset syntax such as 200,100.',
+        displayOptions: {
+            show: {
+                resource: listResources,
+                operation: ['getAll'],
+            },
+        },
+    },
+    {
+        displayName: 'Page',
+        name: 'page',
+        type: 'number',
+        typeOptions: {
+            minValue: 1,
+        },
+        default: 1,
+        description: 'Page number to request when Return All is disabled',
+        displayOptions: {
+            show: {
+                resource: listResources,
+                operation: ['getAll'],
+                returnAll: [false],
+            },
+        },
+    },
+    {
+        displayName: 'Filter JSON',
+        name: 'filterJson',
+        type: 'json',
+        default: '{}',
+        description: 'JSON object converted to filter[column]=value query parameters, for example {"name":"James PRO B.V."}',
+        displayOptions: {
+            show: {
+                resource: listResources,
+                operation: ['getAll'],
+            },
+        },
+    },
+];
+class JamesPro {
+    description = {
+        displayName: 'James PRO',
+        name: 'jamesPro',
+        icon: 'file:jamespro.svg',
+        group: ['transform'],
+        version: 1,
+        subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
+        description: 'Read and write data in James PRO',
+        defaults: {
+            name: 'James PRO',
+        },
+        usableAsTool: true,
+        inputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+        outputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+        credentials: [
+            {
+                name: 'jamesProApi',
+                required: true,
+            },
+        ],
+        properties: [
+            {
+                displayName: 'Resource',
+                name: 'resource',
+                type: 'options',
+                noDataExpression: true,
+                options: [
+                    ...RESOURCE_CONFIGS.map((resource) => ({
+                        name: resource.displayName,
+                        value: resource.name,
+                    })),
+                    {
+                        name: 'Custom Request',
+                        value: 'customRequest',
+                    },
+                ],
+                default: 'company',
+            },
+            {
+                displayName: 'Operation',
+                name: 'operation',
+                type: 'options',
+                noDataExpression: true,
+                displayOptions: {
+                    show: {
+                        resource: crudResources,
+                    },
+                },
+                options: [
+                    {
+                        name: 'Get Many',
+                        value: 'getAll',
+                        description: 'Get many records',
+                        action: 'Get many records',
+                    },
+                    {
+                        name: 'Get',
+                        value: 'get',
+                        description: 'Get one record',
+                        action: 'Get one record',
+                    },
+                    {
+                        name: 'Create',
+                        value: 'create',
+                        description: 'Create a record',
+                        action: 'Create a record',
+                    },
+                    {
+                        name: 'Update',
+                        value: 'update',
+                        description: 'Update a record',
+                        action: 'Update a record',
+                    },
+                    {
+                        name: 'Delete',
+                        value: 'delete',
+                        description: 'Delete a record',
+                        action: 'Delete a record',
+                    },
+                ],
+                default: 'getAll',
+            },
+            {
+                displayName: 'Operation',
+                name: 'operation',
+                type: 'options',
+                noDataExpression: true,
+                displayOptions: {
+                    show: {
+                        resource: ['me'],
+                    },
+                },
+                options: [
+                    {
+                        name: 'Get',
+                        value: 'get',
+                        description: 'Get authenticated user information',
+                        action: 'Get authenticated user information',
+                    },
+                    {
+                        name: 'Update',
+                        value: 'update',
+                        description: 'Update authenticated user information',
+                        action: 'Update authenticated user information',
+                    },
+                ],
+                default: 'get',
+            },
+            {
+                displayName: 'Operation',
+                name: 'operation',
+                type: 'options',
+                noDataExpression: true,
+                displayOptions: {
+                    show: {
+                        resource: ['customRequest'],
+                    },
+                },
+                options: [
+                    {
+                        name: 'Send',
+                        value: 'send',
+                        description: 'Send a custom request to the James PRO API',
+                        action: 'Send a custom request',
+                    },
+                ],
+                default: 'send',
+            },
+            {
+                displayName: 'ID or Name',
+                name: 'entityId',
+                type: 'string',
+                required: true,
+                default: '',
+                description: 'The entity ID. For Setting, use the setting name, for example settingTendertextcolor.',
+                displayOptions: {
+                    show: {
+                        resource: crudResources,
+                        operation: ['get', 'update', 'delete'],
+                    },
+                },
+            },
+            ...commonQueryProperties,
+            ...listQueryProperties,
+            {
+                displayName: 'Body JSON',
+                name: 'bodyJson',
+                type: 'json',
+                default: '{}',
+                required: true,
+                description: 'Request body as JSON',
+                displayOptions: {
+                    show: {
+                        resource: [...crudResources, 'me'],
+                        operation: ['create', 'update'],
+                    },
+                },
+            },
+            {
+                displayName: 'Confirm Delete',
+                name: 'confirmDelete',
+                type: 'boolean',
+                default: true,
+                description: 'Whether to send {"confirm":true} in the delete request body',
+                displayOptions: {
+                    show: {
+                        resource: crudResources,
+                        operation: ['delete'],
+                    },
+                },
+            },
+            {
+                displayName: 'Method',
+                name: 'method',
+                type: 'options',
+                options: [
+                    { name: 'GET', value: 'GET' },
+                    { name: 'POST', value: 'POST' },
+                    { name: 'PUT', value: 'PUT' },
+                    { name: 'DELETE', value: 'DELETE' },
+                ],
+                default: 'GET',
+                displayOptions: {
+                    show: {
+                        resource: ['customRequest'],
+                        operation: ['send'],
+                    },
+                },
+            },
+            {
+                displayName: 'Endpoint',
+                name: 'endpoint',
+                type: 'string',
+                default: '/companies/',
+                required: true,
+                description: 'API endpoint path, for example /companies/ or /company/1000',
+                displayOptions: {
+                    show: {
+                        resource: ['customRequest'],
+                        operation: ['send'],
+                    },
+                },
+            },
+            {
+                displayName: 'Query JSON',
+                name: 'queryJson',
+                type: 'json',
+                default: '{}',
+                description: 'Query string parameters as JSON',
+                displayOptions: {
+                    show: {
+                        resource: ['customRequest'],
+                        operation: ['send'],
+                    },
+                },
+            },
+            {
+                displayName: 'Body JSON',
+                name: 'customBodyJson',
+                type: 'json',
+                default: '{}',
+                description: 'Request body as JSON',
+                displayOptions: {
+                    show: {
+                        resource: ['customRequest'],
+                        operation: ['send'],
+                        method: ['POST', 'PUT', 'DELETE'],
+                    },
+                },
+            },
+            {
+                displayName: 'Return Body Only',
+                name: 'returnBodyOnly',
+                type: 'boolean',
+                default: true,
+                description: 'Whether to return the James PRO response body instead of the full response envelope',
+            },
+        ],
+    };
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const credentials = await this.getCredentials('jamesProApi');
+        const baseURL = String(credentials.baseUrl).replace(/\/+$/, '');
+        for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+            try {
+                const resource = this.getNodeParameter('resource', itemIndex);
+                const operation = this.getNodeParameter('operation', itemIndex);
+                const returnBodyOnly = this.getNodeParameter('returnBodyOnly', itemIndex, true);
+                if (resource === 'customRequest') {
+                    const response = await sendJamesProRequest.call(this, itemIndex, {
+                        baseURL,
+                        method: this.getNodeParameter('method', itemIndex),
+                        url: normalizeEndpoint(this.getNodeParameter('endpoint', itemIndex)),
+                        qs: parseJsonParameter.call(this, 'queryJson', itemIndex),
+                        body: this.getNodeParameter('method', itemIndex) === 'GET'
+                            ? undefined
+                            : parseJsonParameter.call(this, 'customBodyJson', itemIndex),
+                    });
+                    returnData.push(...normalizeResponse.call(this, response, returnBodyOnly));
+                    continue;
+                }
+                const resourceConfig = RESOURCE_CONFIGS.find((config) => config.name === resource);
+                if (!resourceConfig) {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unsupported resource: ${resource}`, {
+                        itemIndex,
+                    });
+                }
+                if (operation === 'getAll') {
+                    if (!resourceConfig.listPath) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `${resourceConfig.displayName} does not support Get Many`, { itemIndex });
+                    }
+                    const returnAll = this.getNodeParameter('returnAll', itemIndex, false);
+                    const responses = await getMany.call(this, resourceConfig.listPath, itemIndex, baseURL, returnAll);
+                    for (const response of responses) {
+                        returnData.push(...normalizeResponse.call(this, response, returnBodyOnly));
+                    }
+                    continue;
+                }
+                if (operation === 'get') {
+                    const url = resource === 'me'
+                        ? resourceConfig.itemPath
+                        : `${resourceConfig.itemPath}/${encodeURIComponent(this.getNodeParameter('entityId', itemIndex))}`;
+                    const response = await sendJamesProRequest.call(this, itemIndex, {
+                        baseURL,
+                        method: 'GET',
+                        url,
+                        qs: buildQuery.call(this, itemIndex),
+                    });
+                    returnData.push(...normalizeResponse.call(this, response, returnBodyOnly));
+                    continue;
+                }
+                if (operation === 'create') {
+                    if (!resourceConfig.canCreate) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `${resourceConfig.displayName} does not support Create`, { itemIndex });
+                    }
+                    const response = await sendJamesProRequest.call(this, itemIndex, {
+                        baseURL,
+                        method: 'POST',
+                        url: resourceConfig.itemPath,
+                        body: parseJsonParameter.call(this, 'bodyJson', itemIndex),
+                    });
+                    returnData.push(...normalizeResponse.call(this, response, returnBodyOnly));
+                    continue;
+                }
+                if (operation === 'update') {
+                    if (!resourceConfig.canUpdate) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `${resourceConfig.displayName} does not support Update`, { itemIndex });
+                    }
+                    const url = resource === 'me'
+                        ? resourceConfig.itemPath
+                        : `${resourceConfig.itemPath}/${encodeURIComponent(this.getNodeParameter('entityId', itemIndex))}`;
+                    const response = await sendJamesProRequest.call(this, itemIndex, {
+                        baseURL,
+                        method: 'PUT',
+                        url,
+                        body: parseJsonParameter.call(this, 'bodyJson', itemIndex),
+                    });
+                    returnData.push(...normalizeResponse.call(this, response, returnBodyOnly));
+                    continue;
+                }
+                if (operation === 'delete') {
+                    if (!resourceConfig.canDelete) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `${resourceConfig.displayName} does not support Delete`, { itemIndex });
+                    }
+                    const response = await sendJamesProRequest.call(this, itemIndex, {
+                        baseURL,
+                        method: 'DELETE',
+                        url: `${resourceConfig.itemPath}/${encodeURIComponent(this.getNodeParameter('entityId', itemIndex))}`,
+                        body: {
+                            confirm: this.getNodeParameter('confirmDelete', itemIndex, true),
+                        },
+                    });
+                    returnData.push(...normalizeResponse.call(this, response, returnBodyOnly));
+                    continue;
+                }
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unsupported operation: ${operation}`, {
+                    itemIndex,
+                });
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: {
+                            error: error instanceof Error ? error.message : String(error),
+                        },
+                        pairedItem: {
+                            item: itemIndex,
+                        },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+}
+exports.JamesPro = JamesPro;
+async function getMany(path, itemIndex, baseURL, returnAll) {
+    const responses = [];
+    let page = returnAll ? 1 : this.getNodeParameter('page', itemIndex, 1);
+    do {
+        const qs = buildQuery.call(this, itemIndex);
+        qs.page = page;
+        const limit = this.getNodeParameter('limit', itemIndex, '30');
+        if (limit) {
+            qs.limit = limit;
+        }
+        const response = await sendJamesProRequest.call(this, itemIndex, {
+            baseURL,
+            method: 'GET',
+            url: path,
+            qs,
+        });
+        responses.push(response);
+        if (!returnAll || !response.next) {
+            break;
+        }
+        page += 1;
+    } while (true);
+    return responses;
+}
+async function sendJamesProRequest(itemIndex, options) {
+    const requestOptions = {
+        baseURL: options.baseURL,
+        url: options.url,
+        method: options.method,
+        json: true,
+        headers: {
+            'Content-Type': 'application/json',
+            Accept: 'application/json',
+        },
+        qs: options.qs,
+    };
+    if (options.body && Object.keys(options.body).length > 0) {
+        requestOptions.body = options.body;
+    }
+    try {
+        return (await this.helpers.httpRequestWithAuthentication.call(this, 'jamesProApi', requestOptions));
+    }
+    catch (error) {
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), error, { itemIndex });
+    }
+}
+function buildQuery(itemIndex) {
+    const qs = {};
+    const fields = this.getNodeParameter('fields', itemIndex, '');
+    const include = this.getNodeParameter('include', itemIndex, '');
+    if (fields) {
+        qs.fields = fields;
+    }
+    if (include) {
+        qs.include = include;
+    }
+    const filter = parseJsonParameter.call(this, 'filterJson', itemIndex, true);
+    for (const [key, value] of Object.entries(filter)) {
+        if (value !== undefined) {
+            qs[`filter[${key}]`] = value;
+        }
+    }
+    return qs;
+}
+function normalizeEndpoint(endpoint) {
+    return endpoint.startsWith('/') ? endpoint : `/${endpoint}`;
+}
+function normalizeResponse(response, returnBodyOnly) {
+    const data = returnBodyOnly && 'body' in response ? response.body : response;
+    if (Array.isArray(data)) {
+        return data.map((item) => ({ json: normalizeItem(item) }));
+    }
+    return [{ json: normalizeItem(data) }];
+}
+function normalizeItem(value) {
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        return value;
+    }
+    return {
+        value: value === undefined ? null : value,
+    };
+}
+function parseJsonParameter(name, itemIndex, allowMissing = false) {
+    let value;
+    try {
+        value = this.getNodeParameter(name, itemIndex, '{}');
+    }
+    catch (error) {
+        if (allowMissing) {
+            return {};
+        }
+        throw error;
+    }
+    if (typeof value === 'string') {
+        if (!value.trim()) {
+            return {};
+        }
+        try {
+            value = JSON.parse(value);
+        }
+        catch {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `${name} must contain valid JSON`, {
+                itemIndex,
+            });
+        }
+    }
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `${name} must be a JSON object`, {
+            itemIndex,
+        });
+    }
+    return value;
+}

package/dist/nodes/JamesPro/JamesPro.node.json

@@ -0,0 +1,13 @@
+{
+  "node": "n8n-nodes-james-pro.jamesPro",
+  "nodeVersion": "1.0",
+  "codexVersion": "1.0",
+  "categories": ["Sales"],
+  "resources": {
+    "credentialDocumentation": [
+      {
+        "url": "https://start.jamespro.nl/api"
+      }
+    ]
+  }
+}

package/dist/nodes/JamesPro/jamespro.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" role="img" aria-label="James PRO">
+  <rect width="64" height="64" rx="12" fill="#1f6feb"/>
+  <path fill="#fff" d="M18 15h27v10H29v7h12v9H29c0 5.3-2.1 8-6.3 8-2.1 0-3.9-.5-5.7-1.6v-9.2c1.4 1 2.7 1.5 4 1.5 1.9 0 2.9-1.2 2.9-3.7V25H18V15z"/>
+</svg>

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "n8n-nodes-james-pro",
+  "version": "0.1.0",
+  "description": "n8n community node for the James PRO API.",
+  "license": "MIT",
+  "homepage": "https://github.com/jornboerema/n8n-nodes-james-pro",
+  "author": {
+    "name": "Jorn Boerema"
+  },
+  "keywords": [
+    "n8n-community-node-package",
+    "n8n",
+    "james-pro",
+    "jamespro"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "npm run clean && tsc && npm run copy:assets",
+    "clean": "rimraf dist",
+    "copy:assets": "copyfiles \"nodes/**/*.svg\" \"nodes/**/*.json\" dist",
+    "lint": "eslint \"{credentials,nodes}/**/*.ts\"",
+    "format": "prettier --write \"{credentials,nodes}/**/*.ts\" \"*.json\" \"*.md\"",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist"
+  ],
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "credentials": [
+      "dist/credentials/JamesProApi.credentials.js"
+    ],
+    "nodes": [
+      "dist/nodes/JamesPro/JamesPro.node.js"
+    ]
+  },
+  "dependencies": {
+    "n8n-workflow": "^2.16.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.10",
+    "@typescript-eslint/eslint-plugin": "^8.35.0",
+    "@typescript-eslint/parser": "^8.35.0",
+    "copyfiles": "^2.4.1",
+    "eslint": "^9.30.0",
+    "prettier": "^3.6.2",
+    "rimraf": "^6.0.1",
+    "typescript": "^5.8.3"
+  },
+  "engines": {
+    "node": ">=22.22"
+  }
+}