@joshuanode/n8n-nodes-scalepad 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Joshua Smith
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,218 @@
+# n8n-nodes-scalepad
+
+This is an n8n community node for **ScalePad Core API** and **Lifecycle Manager**. It provides comprehensive integration with ScalePad's operational and financial insights platform for MSPs.
+
+[Installation](#installation) | [Operations](#operations) | [Credentials](#credentials) | [Usage](#usage) | [Resources](#resources)
+
+## Installation
+
+Follow the [installation guide](https://docs.n8n.io/integrations/community-nodes/installation/) in the n8n community nodes documentation.
+
+### Community Nodes (Recommended)
+
+1. Go to **Settings > Community Nodes**
+2. Select **Install**
+3. Enter `n8n-nodes-scalepad` in **Enter npm package name**
+4. Agree to the [risks](https://docs.n8n.io/integrations/community-nodes/risks/) of using community nodes
+5. Select **Install**
+
+After installation, restart n8n to load the node.
+
+### Manual Installation
+
+```bash
+npm install n8n-nodes-scalepad
+```
+
+## Operations
+
+This node provides access to the following ScalePad resources:
+
+### Resources Available
+
+| Resource | Description | Operations |
+|----------|-------------|------------|
+| **Clients** | Client/customer information | Get, Get Many |
+| **Contacts** | Contact details | Get, Get Many |
+| **Contracts** | Contract records | Get, Get Many |
+| **Hardware Assets** | Hardware asset data | Get, Get Many |
+| **Hardware Lifecycle** | Lifecycle tracking, warranties, EOL status | Get, Get Many |
+| **Members** | Team member information | Get, Get Many |
+| **Opportunities** | Sales opportunities | Get, Get Many |
+| **SaaS** | SaaS subscription data | Get, Get Many |
+| **Tickets** | Support ticket records | Get, Get Many |
+
+### Operations
+
+- **Get** - Retrieve a single record by ID
+- **Get Many** - Retrieve multiple records with filtering, sorting, and pagination
+
+### Features
+
+✅ **Automatic Pagination** - Handles up to 200 records per request with cursor-based pagination
+✅ **Advanced Filtering** - Filter with operators (eq, ne, contains, gt, lt)
+✅ **Sorting** - Sort results ascending or descending
+✅ **Rate Limit Handling** - Automatic handling of 50 req/5sec limit
+✅ **Comprehensive Error Messages** - Detailed error descriptions and resolutions
+
+## Credentials
+
+### Authentication: API Key
+
+**Requirements:**
+- ScalePad Partner account
+- Administrator permissions
+
+**Setup Steps:**
+
+1. Sign in to [ScalePad Hub](https://hub.scalepad.com)
+2. Navigate to **API (BETA)** in the top menu
+3. Click **+ Generate** to create a new API key
+4. Enter a descriptive name
+5. Set expiry (default: 2 years)
+6. Copy the API key immediately (won't be shown again)
+
+**Configuration in n8n:**
+
+- **API Key**: Your generated API key
+- **Environment**:
+  - `Production` - https://api.scalepad.com
+  - `Sandbox` - https://api-sandbox.scalepad.com
+
+## Usage
+
+### Example 1: Get All Active Clients
+
+```
+Resource: Client
+Operation: Get Many
+Return All: true
+Additional Fields:
+  Filter:
+    - Field: status
+    - Operator: eq
+    - Value: active
+```
+
+### Example 2: Monitor Hardware Approaching End of Life
+
+```
+Resource: Hardware Lifecycle
+Operation: Get Many
+Return All: true
+Additional Fields:
+  EOL Status: approaching_eol
+```
+
+### Example 3: Get Client's Open Tickets
+
+```
+Resource: Ticket
+Operation: Get Many
+Return All: false
+Limit: 50
+Additional Fields:
+  Client ID: {{$json["client_id"]}}
+  Status: open
+  Priority: high
+```
+
+### Example 4: List Expiring Warranties
+
+```
+Resource: Hardware Lifecycle
+Operation: Get Many
+Return All: true
+Additional Fields:
+  Warranty Status: expiring_soon
+```
+
+## API Limits
+
+### Rate Limits
+
+- **Limit**: 50 requests per 5 seconds
+- **Automatic Handling**: The node handles rate limit errors with descriptive messages
+- **Best Practice**: Use filters to reduce the number of requests needed
+
+### Pagination
+
+- **Maximum**: 200 records per request
+- **Type**: Cursor-based pagination
+- **Auto-pagination**: Enable "Return All" to automatically fetch all pages
+
+### Performance Tips
+
+1. **Use filters** to reduce data transfer
+   ```
+   Additional Fields > Client ID: specific-client-id
+   ```
+
+2. **Limit results** for large datasets
+   ```
+   Return All: false
+   Limit: 100
+   ```
+
+3. **Apply sorting** for ordered results
+   ```
+   Sort Field: created_at
+   Sort Direction: DESC
+   ```
+
+## Error Handling
+
+The node provides comprehensive error handling:
+
+| Error Code | Meaning | Resolution |
+|------------|---------|------------|
+| **401** | Authentication failed | Check API key validity and expiration |
+| **404** | Resource not found | Verify resource ID and access permissions |
+| **429** | Rate limit exceeded | Reduce request frequency or add delays |
+| **500** | Server error | Retry request or contact ScalePad support |
+
+All errors include:
+- HTTP status code
+- Error message
+- Detailed description
+- Suggested resolution
+
+## API Status
+
+**Current Status**: Beta (Read-Only)
+
+The ScalePad Core API is currently in beta with read-only access (GET operations only). Full CRUD operations (POST, PATCH, DELETE) will be available in future releases based on partner feedback.
+
+## Resources
+
+- [ScalePad Core API Documentation](https://developer.scalepad.com/)
+- [ScalePad Community](https://community.scalepad.com/)
+- [n8n Documentation](https://docs.n8n.io/)
+
+## Related Packages
+
+- [n8n-nodes-quoter](https://www.npmjs.com/package/n8n-nodes-quoter) - Quoter API for quote management
+
+## Version History
+
+### 0.0.1
+- Initial release
+- ScalePad Core API support (read-only)
+- Lifecycle Manager integration
+- 9 resources with Get and Get Many operations
+- Automatic pagination
+- Advanced filtering and sorting
+- Comprehensive error handling
+
+## Support
+
+- **GitHub Issues**: [Report a bug](https://github.com/ajoshuasmith/n8n-nodes-scalepad/issues)
+- **ScalePad Community**: [community.scalepad.com](https://community.scalepad.com/)
+
+## License
+
+[MIT](LICENSE)
+
+## Author
+
+ScalePad Community

package/dist/credentials/ScalePadCoreApi.credentials.d.ts

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

package/dist/credentials/ScalePadCoreApi.credentials.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScalePadCoreApi = void 0;
+class ScalePadCoreApi {
+    constructor() {
+        this.name = 'scalePadCoreApi';
+        this.displayName = 'ScalePad Core API';
+        this.documentationUrl = 'https://developer.scalepad.com/';
+        this.properties = [
+            {
+                displayName: 'API Key',
+                name: 'apiKey',
+                type: 'string',
+                typeOptions: {
+                    password: true,
+                },
+                default: '',
+                required: true,
+                description: 'API Key for ScalePad Core API and Lifecycle Manager. Generate from ScalePad Hub > API (BETA).',
+            },
+            {
+                displayName: 'Environment',
+                name: 'environment',
+                type: 'options',
+                options: [
+                    {
+                        name: 'Production',
+                        value: 'production',
+                    },
+                    {
+                        name: 'Sandbox',
+                        value: 'sandbox',
+                    },
+                ],
+                default: 'production',
+                description: 'The environment to connect to',
+            },
+        ];
+        this.authenticate = {
+            type: 'generic',
+            properties: {
+                headers: {
+                    'x-api-key': '={{$credentials.apiKey}}',
+                    'Accept': 'application/json',
+                },
+            },
+        };
+        this.test = {
+            request: {
+                baseURL: '={{$credentials.environment === "production" ? "https://api.scalepad.com" : "https://api-sandbox.scalepad.com"}}',
+                url: '/core/v1/clients',
+                method: 'GET',
+                qs: {
+                    limit: 1,
+                },
+            },
+        };
+    }
+}
+exports.ScalePadCoreApi = ScalePadCoreApi;

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

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

package/dist/nodes/ScalePadCore/ScalePadCore.node.js

@@ -0,0 +1,344 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScalePadCore = void 0;
+const GenericFunctions_1 = require("../shared/GenericFunctions");
+const ClientDescription_1 = require("./descriptions/ClientDescription");
+const ContactDescription_1 = require("./descriptions/ContactDescription");
+const ContractDescription_1 = require("./descriptions/ContractDescription");
+const HardwareAssetDescription_1 = require("./descriptions/HardwareAssetDescription");
+const HardwareLifecycleDescription_1 = require("./descriptions/HardwareLifecycleDescription");
+const MemberDescription_1 = require("./descriptions/MemberDescription");
+const OpportunityDescription_1 = require("./descriptions/OpportunityDescription");
+const SaasDescription_1 = require("./descriptions/SaasDescription");
+const TicketDescription_1 = require("./descriptions/TicketDescription");
+class ScalePadCore {
+    constructor() {
+        this.description = {
+            displayName: 'ScalePad Core',
+            name: 'scalePadCore',
+            icon: 'file:scalepad.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
+            description: 'Interact with ScalePad Core API and Lifecycle Manager',
+            defaults: {
+                name: 'ScalePad Core',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'scalePadCoreApi',
+                    required: true,
+                },
+            ],
+            requestDefaults: {
+                baseURL: 'https://api.scalepad.com',
+                headers: {
+                    Accept: 'application/json',
+                    'Content-Type': 'application/json',
+                },
+            },
+            properties: [
+                {
+                    displayName: 'Resource',
+                    name: 'resource',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Client',
+                            value: 'client',
+                        },
+                        {
+                            name: 'Contact',
+                            value: 'contact',
+                        },
+                        {
+                            name: 'Contract',
+                            value: 'contract',
+                        },
+                        {
+                            name: 'Hardware Asset',
+                            value: 'hardwareAsset',
+                        },
+                        {
+                            name: 'Hardware Lifecycle',
+                            value: 'hardwareLifecycle',
+                        },
+                        {
+                            name: 'Member',
+                            value: 'member',
+                        },
+                        {
+                            name: 'Opportunity',
+                            value: 'opportunity',
+                        },
+                        {
+                            name: 'SaaS',
+                            value: 'saas',
+                        },
+                        {
+                            name: 'Ticket',
+                            value: 'ticket',
+                        },
+                    ],
+                    default: 'client',
+                },
+                ...ClientDescription_1.clientOperations,
+                ...ClientDescription_1.clientFields,
+                ...ContactDescription_1.contactOperations,
+                ...ContactDescription_1.contactFields,
+                ...ContractDescription_1.contractOperations,
+                ...ContractDescription_1.contractFields,
+                ...HardwareAssetDescription_1.hardwareAssetOperations,
+                ...HardwareAssetDescription_1.hardwareAssetFields,
+                ...HardwareLifecycleDescription_1.hardwareLifecycleOperations,
+                ...HardwareLifecycleDescription_1.hardwareLifecycleFields,
+                ...MemberDescription_1.memberOperations,
+                ...MemberDescription_1.memberFields,
+                ...OpportunityDescription_1.opportunityOperations,
+                ...OpportunityDescription_1.opportunityFields,
+                ...SaasDescription_1.saasOperations,
+                ...SaasDescription_1.saasFields,
+                ...TicketDescription_1.ticketOperations,
+                ...TicketDescription_1.ticketFields,
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const resource = this.getNodeParameter('resource', 0);
+        const operation = this.getNodeParameter('operation', 0);
+        for (let i = 0; i < items.length; i++) {
+            try {
+                if (resource === 'client') {
+                    if (operation === 'get') {
+                        const clientId = this.getNodeParameter('clientId', i);
+                        const responseData = await GenericFunctions_1.scalePadCoreApiRequest.call(this, 'GET', `/core/v1/clients/${clientId}`);
+                        returnData.push({ json: responseData });
+                    }
+                    if (operation === 'getAll') {
+                        const returnAll = this.getNodeParameter('returnAll', i);
+                        const additionalFields = this.getNodeParameter('additionalFields', i);
+                        const qs = {};
+                        if (!returnAll) {
+                            qs.limit = this.getNodeParameter('limit', i);
+                        }
+                        // Handle filters
+                        if (additionalFields.filter) {
+                            const filterData = additionalFields.filter;
+                            if (filterData.filters && Array.isArray(filterData.filters)) {
+                                for (const filter of filterData.filters) {
+                                    const field = filter.field;
+                                    const operator = filter.operator;
+                                    const value = filter.value;
+                                    qs[`filter[${field}]`] = `${operator}:${value}`;
+                                }
+                            }
+                        }
+                        // Handle sorting
+                        if (additionalFields.sort) {
+                            const sortData = additionalFields.sort;
+                            if (sortData.sortFields) {
+                                const sortFields = sortData.sortFields;
+                                const field = sortFields.field;
+                                const direction = sortFields.direction;
+                                qs.sort = (0, GenericFunctions_1.buildCoreApiSort)(field, direction);
+                            }
+                        }
+                        let responseData;
+                        if (returnAll) {
+                            responseData = await GenericFunctions_1.scalePadCoreApiRequestAllItems.call(this, 'GET', '/core/v1/clients', {}, qs);
+                        }
+                        else {
+                            const response = await GenericFunctions_1.scalePadCoreApiRequest.call(this, 'GET', '/core/v1/clients', {}, qs);
+                            responseData = response.data || [];
+                        }
+                        responseData.forEach((item) => {
+                            returnData.push({ json: item });
+                        });
+                    }
+                }
+                if (resource === 'contact') {
+                    if (operation === 'get') {
+                        const contactId = this.getNodeParameter('contactId', i);
+                        const responseData = await GenericFunctions_1.scalePadCoreApiRequest.call(this, 'GET', `/core/v1/contacts/${contactId}`);
+                        returnData.push({ json: responseData });
+                    }
+                    if (operation === 'getAll') {
+                        const returnAll = this.getNodeParameter('returnAll', i);
+                        const additionalFields = this.getNodeParameter('additionalFields', i);
+                        const qs = {};
+                        if (!returnAll) {
+                            qs.limit = this.getNodeParameter('limit', i);
+                        }
+                        if (additionalFields.clientId) {
+                            qs['filter[client_id]'] = `eq:${additionalFields.clientId}`;
+                        }
+                        if (additionalFields.email) {
+                            qs['filter[email]'] = `eq:${additionalFields.email}`;
+                        }
+                        let responseData;
+                        if (returnAll) {
+                            responseData = await GenericFunctions_1.scalePadCoreApiRequestAllItems.call(this, 'GET', '/core/v1/contacts', {}, qs);
+                        }
+                        else {
+                            const response = await GenericFunctions_1.scalePadCoreApiRequest.call(this, 'GET', '/core/v1/contacts', {}, qs);
+                            responseData = response.data || [];
+                        }
+                        responseData.forEach((item) => {
+                            returnData.push({ json: item });
+                        });
+                    }
+                }
+                if (resource === 'ticket') {
+                    if (operation === 'get') {
+                        const ticketId = this.getNodeParameter('ticketId', i);
+                        const responseData = await GenericFunctions_1.scalePadCoreApiRequest.call(this, 'GET', `/core/v1/tickets/${ticketId}`);
+                        returnData.push({ json: responseData });
+                    }
+                    if (operation === 'getAll') {
+                        const returnAll = this.getNodeParameter('returnAll', i);
+                        const additionalFields = this.getNodeParameter('additionalFields', i);
+                        const qs = {};
+                        if (!returnAll) {
+                            qs.limit = this.getNodeParameter('limit', i);
+                        }
+                        if (additionalFields.clientId) {
+                            qs['filter[client_id]'] = `eq:${additionalFields.clientId}`;
+                        }
+                        if (additionalFields.status) {
+                            qs['filter[status]'] = `eq:${additionalFields.status}`;
+                        }
+                        if (additionalFields.priority) {
+                            qs['filter[priority]'] = `eq:${additionalFields.priority}`;
+                        }
+                        let responseData;
+                        if (returnAll) {
+                            responseData = await GenericFunctions_1.scalePadCoreApiRequestAllItems.call(this, 'GET', '/core/v1/tickets', {}, qs);
+                        }
+                        else {
+                            const response = await GenericFunctions_1.scalePadCoreApiRequest.call(this, 'GET', '/core/v1/tickets', {}, qs);
+                            responseData = response.data || [];
+                        }
+                        responseData.forEach((item) => {
+                            returnData.push({ json: item });
+                        });
+                    }
+                }
+                if (resource === 'hardwareLifecycle') {
+                    if (operation === 'get') {
+                        const recordId = this.getNodeParameter('recordId', i);
+                        const responseData = await GenericFunctions_1.scalePadCoreApiRequest.call(this, 'GET', `/core/v1/hardware-lifecycle/${recordId}`);
+                        returnData.push({ json: responseData });
+                    }
+                    if (operation === 'getAll') {
+                        const returnAll = this.getNodeParameter('returnAll', i);
+                        const additionalFields = this.getNodeParameter('additionalFields', i);
+                        const qs = {};
+                        if (!returnAll) {
+                            qs.limit = this.getNodeParameter('limit', i);
+                        }
+                        if (additionalFields.clientId) {
+                            qs['filter[client_id]'] = `eq:${additionalFields.clientId}`;
+                        }
+                        if (additionalFields.warrantyStatus) {
+                            qs['filter[warranty_status]'] = `eq:${additionalFields.warrantyStatus}`;
+                        }
+                        if (additionalFields.eolStatus) {
+                            qs['filter[eol_status]'] = `eq:${additionalFields.eolStatus}`;
+                        }
+                        let responseData;
+                        if (returnAll) {
+                            responseData = await GenericFunctions_1.scalePadCoreApiRequestAllItems.call(this, 'GET', '/core/v1/hardware-lifecycle', {}, qs);
+                        }
+                        else {
+                            const response = await GenericFunctions_1.scalePadCoreApiRequest.call(this, 'GET', '/core/v1/hardware-lifecycle', {}, qs);
+                            responseData = response.data || [];
+                        }
+                        responseData.forEach((item) => {
+                            returnData.push({ json: item });
+                        });
+                    }
+                }
+                // Similar implementations for other resources
+                const resourceMap = {
+                    contract: 'contracts',
+                    hardwareAsset: 'hardware-assets',
+                    member: 'members',
+                    opportunity: 'opportunities',
+                    saas: 'saas',
+                };
+                if (Object.keys(resourceMap).includes(resource)) {
+                    const endpoint = resourceMap[resource];
+                    const idParamMap = {
+                        contract: 'contractId',
+                        hardwareAsset: 'assetId',
+                        member: 'memberId',
+                        opportunity: 'opportunityId',
+                        saas: 'saasId',
+                    };
+                    if (operation === 'get') {
+                        const id = this.getNodeParameter(idParamMap[resource], i);
+                        const responseData = await GenericFunctions_1.scalePadCoreApiRequest.call(this, 'GET', `/core/v1/${endpoint}/${id}`);
+                        returnData.push({ json: responseData });
+                    }
+                    if (operation === 'getAll') {
+                        const returnAll = this.getNodeParameter('returnAll', i);
+                        const additionalFields = this.getNodeParameter('additionalFields', i);
+                        const qs = {};
+                        if (!returnAll) {
+                            qs.limit = this.getNodeParameter('limit', i);
+                        }
+                        // Apply common filters
+                        if (additionalFields.clientId) {
+                            qs['filter[client_id]'] = `eq:${additionalFields.clientId}`;
+                        }
+                        if (additionalFields.status) {
+                            qs['filter[status]'] = `eq:${additionalFields.status}`;
+                        }
+                        // Apply resource-specific filters
+                        if (resource === 'hardwareAsset' && additionalFields.assetType) {
+                            qs['filter[asset_type]'] = `eq:${additionalFields.assetType}`;
+                        }
+                        if (resource === 'member' && additionalFields.role) {
+                            qs['filter[role]'] = `eq:${additionalFields.role}`;
+                        }
+                        if (resource === 'opportunity' && additionalFields.stage) {
+                            qs['filter[stage]'] = `eq:${additionalFields.stage}`;
+                        }
+                        let responseData;
+                        if (returnAll) {
+                            responseData = await GenericFunctions_1.scalePadCoreApiRequestAllItems.call(this, 'GET', `/core/v1/${endpoint}`, {}, qs);
+                        }
+                        else {
+                            const response = await GenericFunctions_1.scalePadCoreApiRequest.call(this, 'GET', `/core/v1/${endpoint}`, {}, qs);
+                            responseData = response.data || [];
+                        }
+                        responseData.forEach((item) => {
+                            returnData.push({ json: item });
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: {
+                            error: error.message,
+                        },
+                        pairedItem: {
+                            item: i,
+                        },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+}
+exports.ScalePadCore = ScalePadCore;

package/dist/nodes/ScalePadCore/descriptions/ClientDescription.d.ts

@@ -0,0 +1,3 @@
+import { INodeProperties } from 'n8n-workflow';
+export declare const clientOperations: INodeProperties[];
+export declare const clientFields: INodeProperties[];