n8n-nodes-lemonsqueezy 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jan Marc Coloma
+
+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,216 @@
+# n8n-nodes-lemonsqueezy
+
+[![npm version](https://img.shields.io/npm/v/n8n-nodes-lemonsqueezy.svg)](https://www.npmjs.com/package/n8n-nodes-lemonsqueezy)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+An [n8n](https://n8n.io/) community node for [Lemon Squeezy](https://lemonsqueezy.com) - a platform for selling digital products, subscriptions, and software licenses.
+
+## Features
+
+- **Full CRUD Operations** - Create, read, update, and delete operations for all major resources
+- **Webhook Trigger** - Real-time event notifications for orders, subscriptions, and license keys
+- **License Key Management** - Validate, activate, and deactivate license keys
+- **Checkout Links** - Create dynamic checkout URLs with custom options
+- **Rate Limiting** - Built-in retry logic with exponential backoff
+- **Type Safety** - Full TypeScript support with comprehensive type definitions
+
+## Installation
+
+### Community Nodes (Recommended)
+
+1. Go to **Settings** > **Community Nodes** in your n8n instance
+2. Select **Install**
+3. Enter `n8n-nodes-lemonsqueezy`
+4. Click **Install**
+
+### npm
+
+```bash
+npm install n8n-nodes-lemonsqueezy
+```
+
+## Credentials
+
+To use this node, you need a Lemon Squeezy API key:
+
+1. Log in to your [Lemon Squeezy Dashboard](https://app.lemonsqueezy.com)
+2. Go to **Settings** → **API**
+3. Click **Create API Key**
+4. Copy the generated key and use it in n8n
+
+## Nodes
+
+### Lemon Squeezy
+
+The main node for interacting with the Lemon Squeezy API.
+
+#### Resources & Operations
+
+| Resource | Operations |
+|----------|------------|
+| **Checkout** | Create, Get, Get Many |
+| **Customer** | Create, Update, Delete, Get, Get Many |
+| **Discount** | Create, Delete, Get, Get Many |
+| **License Key** | Get, Get Many, Update, Validate, Activate, Deactivate |
+| **Order** | Get, Get Many, Refund |
+| **Product** | Get, Get Many |
+| **Store** | Get, Get Many |
+| **Subscription** | Get, Get Many, Update, Cancel, Resume |
+| **Variant** | Get, Get Many |
+| **Webhook** | Create, Update, Delete, Get, Get Many |
+
+### Lemon Squeezy Trigger
+
+Webhook trigger node for receiving real-time events.
+
+#### Supported Events
+
+- `order_created` - New order placed
+- `order_refunded` - Order refunded
+- `subscription_created` - New subscription started
+- `subscription_updated` - Subscription modified
+- `subscription_cancelled` - Subscription cancelled
+- `subscription_resumed` - Paused subscription resumed
+- `subscription_paused` - Subscription paused
+- `subscription_expired` - Subscription expired
+- `subscription_payment_success` - Subscription payment succeeded
+- `subscription_payment_failed` - Subscription payment failed
+- `subscription_payment_recovered` - Failed payment recovered
+- `subscription_payment_refunded` - Subscription payment refunded
+- `license_key_created` - License key generated
+- `license_key_updated` - License key modified
+
+## Example Workflows
+
+### 1. New Order Notification to Slack
+
+```
+Lemon Squeezy Trigger (order_created) → Slack (Send Message)
+```
+
+Notify your team instantly when a new order comes in.
+
+### 2. Subscription Churn Prevention
+
+```
+Schedule Trigger → Lemon Squeezy (Get Subscriptions, status=past_due) → Send Email
+```
+
+Automatically reach out to customers with failed payments.
+
+### 3. License Key Validation API
+
+```
+Webhook → Lemon Squeezy (Validate License Key) → Respond to Webhook
+```
+
+Build a license validation endpoint for your software.
+
+### 4. Dynamic Checkout Link Generation
+
+```
+HTTP Request → Lemon Squeezy (Create Checkout) → Return Checkout URL
+```
+
+Create personalized checkout links with pre-filled customer data.
+
+### 5. Customer Sync to CRM
+
+```
+Lemon Squeezy Trigger (order_created) → Lemon Squeezy (Get Customer) → HubSpot (Create Contact)
+```
+
+Automatically sync new customers to your CRM.
+
+## Filtering
+
+Most "Get Many" operations support filtering:
+
+| Filter | Description | Available On |
+|--------|-------------|--------------|
+| `storeId` | Filter by store | All resources |
+| `status` | Filter by status | Orders, Subscriptions, Customers, License Keys |
+| `email` | Filter by email | Orders, Customers |
+| `productId` | Filter by product | Subscriptions, License Keys, Variants |
+| `variantId` | Filter by variant | Subscriptions, Checkouts |
+| `orderId` | Filter by order | Subscriptions, License Keys |
+
+## Error Handling
+
+The node includes built-in error handling:
+
+- **Rate Limiting**: Automatically waits and retries when rate limited (429 errors)
+- **Retry Logic**: Retries failed requests with exponential backoff for 5xx errors
+- **Continue on Fail**: Enable to process remaining items even if some fail
+
+## Troubleshooting
+
+### "Invalid API Key" Error
+
+1. Verify your API key is correct in the credentials
+2. Check if the API key has been revoked in Lemon Squeezy
+3. Ensure the key has appropriate permissions
+
+### "Resource Not Found" (404) Error
+
+1. Verify the resource ID is correct
+2. Check if the resource exists in Lemon Squeezy
+3. Ensure you're using the correct resource type
+
+### Webhook Not Receiving Events
+
+1. Verify the webhook URL is publicly accessible
+2. Check if your n8n instance has HTTPS enabled
+3. Verify the webhook secret matches
+4. Check the webhook events are enabled in Lemon Squeezy
+
+### Rate Limiting Issues
+
+The node handles rate limiting automatically, but if you're hitting limits frequently:
+
+1. Reduce the frequency of API calls
+2. Use "Return All" sparingly for large datasets
+3. Consider caching responses where appropriate
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Build the node
+npm run build
+
+# Run tests
+npm test
+
+# Run linter
+npm run lint
+
+# Format code
+npm run format
+```
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add some amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## Resources
+
+- [Lemon Squeezy API Documentation](https://docs.lemonsqueezy.com/api)
+- [n8n Community Nodes Documentation](https://docs.n8n.io/integrations/community-nodes/)
+- [n8n Community Forum](https://community.n8n.io/)
+
+## License
+
+[MIT](LICENSE)
+
+---
+
+Made with 🍋 by [Jan Marc Coloma](https://github.com/janmaaarc)

package/dist/credentials/LemonSqueezyApi.credentials.d.ts

@@ -0,0 +1,10 @@
+import type { IAuthenticateGeneric, ICredentialTestRequest, ICredentialType, INodeProperties } from 'n8n-workflow';
+export declare class LemonSqueezyApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    icon: "file:lemonSqueezy.svg";
+    documentationUrl: string;
+    properties: INodeProperties[];
+    authenticate: IAuthenticateGeneric;
+    test: ICredentialTestRequest;
+}

package/dist/credentials/LemonSqueezyApi.credentials.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LemonSqueezyApi = void 0;
+class LemonSqueezyApi {
+    constructor() {
+        this.name = 'lemonSqueezyApi';
+        this.displayName = 'Lemon Squeezy API';
+        this.icon = 'file:lemonSqueezy.svg';
+        this.documentationUrl = 'https://docs.lemonsqueezy.com/api';
+        this.properties = [
+            {
+                displayName: 'API Key',
+                name: 'apiKey',
+                type: 'string',
+                typeOptions: { password: true },
+                default: '',
+                required: true,
+                placeholder: 'lsq_xxxxxxxxxxxxxxxxxxxxxxxx',
+                hint: 'Found in Settings → API in your dashboard',
+                description: 'Your Lemon Squeezy API key. <a href="https://app.lemonsqueezy.com/settings/api" target="_blank">Generate one here</a>.',
+            },
+        ];
+        this.authenticate = {
+            type: 'generic',
+            properties: {
+                headers: {
+                    Authorization: '=Bearer {{$credentials.apiKey}}',
+                    Accept: 'application/vnd.api+json',
+                    'Content-Type': 'application/vnd.api+json',
+                },
+            },
+        };
+        this.test = {
+            request: {
+                baseURL: 'https://api.lemonsqueezy.com/v1',
+                url: '/users/me',
+            },
+        };
+    }
+}
+exports.LemonSqueezyApi = LemonSqueezyApi;

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

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

package/dist/nodes/LemonSqueezy/LemonSqueezy.node.js

@@ -0,0 +1,358 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LemonSqueezy = void 0;
+const constants_1 = require("./constants");
+const helpers_1 = require("./helpers");
+const resources_1 = require("./resources");
+async function handleCreate(ctx, resource, itemIndex) {
+    if (resource === 'customer') {
+        const storeId = ctx.getNodeParameter('customerStoreId', itemIndex);
+        const name = ctx.getNodeParameter('customerName', itemIndex);
+        const email = ctx.getNodeParameter('customerEmail', itemIndex);
+        const additionalFields = ctx.getNodeParameter('additionalFields', itemIndex);
+        const body = (0, helpers_1.buildJsonApiBody)('customers', { name, email, ...additionalFields }, { store: { type: 'stores', id: storeId } });
+        return await helpers_1.lemonSqueezyApiRequest.call(ctx, 'POST', '/customers', body);
+    }
+    if (resource === 'discount') {
+        const storeId = ctx.getNodeParameter('discountStoreId', itemIndex);
+        const name = ctx.getNodeParameter('discountName', itemIndex);
+        const code = ctx.getNodeParameter('discountCode', itemIndex);
+        const amount = ctx.getNodeParameter('discountAmount', itemIndex);
+        const amountType = ctx.getNodeParameter('discountAmountType', itemIndex);
+        const additionalOptions = ctx.getNodeParameter('additionalOptions', itemIndex, {});
+        const attributes = {
+            name,
+            code,
+            amount,
+            amount_type: amountType,
+        };
+        if (additionalOptions.duration) {
+            attributes.duration = additionalOptions.duration;
+        }
+        if (additionalOptions.durationInMonths) {
+            attributes.duration_in_months = additionalOptions.durationInMonths;
+        }
+        if (additionalOptions.maxRedemptions) {
+            attributes.max_redemptions = additionalOptions.maxRedemptions;
+            attributes.is_limited_redemptions = true;
+        }
+        if (additionalOptions.startsAt) {
+            attributes.starts_at = additionalOptions.startsAt;
+        }
+        if (additionalOptions.expiresAt) {
+            attributes.expires_at = additionalOptions.expiresAt;
+        }
+        if (additionalOptions.testMode !== undefined) {
+            attributes.test_mode = additionalOptions.testMode;
+        }
+        const body = (0, helpers_1.buildJsonApiBody)('discounts', attributes, {
+            store: { type: 'stores', id: storeId },
+        });
+        return await helpers_1.lemonSqueezyApiRequest.call(ctx, 'POST', '/discounts', body);
+    }
+    if (resource === 'checkout') {
+        const storeId = ctx.getNodeParameter('checkoutStoreId', itemIndex);
+        const variantId = ctx.getNodeParameter('checkoutVariantId', itemIndex);
+        const additionalOptions = ctx.getNodeParameter('additionalOptions', itemIndex, {});
+        const checkoutOptions = ctx.getNodeParameter('checkoutOptions', itemIndex, {});
+        const attributes = {};
+        const checkoutData = {};
+        const productOptions = {};
+        const checkoutOptionsObj = {};
+        if (additionalOptions.customPrice) {
+            attributes.custom_price = additionalOptions.customPrice;
+        }
+        if (additionalOptions.email) {
+            checkoutData.email = additionalOptions.email;
+        }
+        if (additionalOptions.name) {
+            checkoutData.name = additionalOptions.name;
+        }
+        if (additionalOptions.discountCode) {
+            checkoutData.discount_code = additionalOptions.discountCode;
+        }
+        if (additionalOptions.redirectUrl) {
+            productOptions.redirect_url = additionalOptions.redirectUrl;
+        }
+        if (additionalOptions.receiptButtonText) {
+            productOptions.receipt_button_text = additionalOptions.receiptButtonText;
+        }
+        if (additionalOptions.receiptLinkUrl) {
+            productOptions.receipt_link_url = additionalOptions.receiptLinkUrl;
+        }
+        if (additionalOptions.receiptThankYouNote) {
+            productOptions.receipt_thank_you_note = additionalOptions.receiptThankYouNote;
+        }
+        if (additionalOptions.customData) {
+            try {
+                checkoutData.custom = JSON.parse(additionalOptions.customData);
+            }
+            catch {
+                checkoutData.custom = additionalOptions.customData;
+            }
+        }
+        if (additionalOptions.expiresAt) {
+            attributes.expires_at = additionalOptions.expiresAt;
+        }
+        if (additionalOptions.testMode !== undefined) {
+            attributes.test_mode = additionalOptions.testMode;
+        }
+        if (checkoutOptions.dark !== undefined) {
+            checkoutOptionsObj.dark = checkoutOptions.dark;
+        }
+        if (checkoutOptions.embed !== undefined) {
+            checkoutOptionsObj.embed = checkoutOptions.embed;
+        }
+        if (checkoutOptions.logo !== undefined) {
+            checkoutOptionsObj.logo = checkoutOptions.logo;
+        }
+        if (checkoutOptions.desc !== undefined) {
+            checkoutOptionsObj.desc = checkoutOptions.desc;
+        }
+        if (checkoutOptions.media !== undefined) {
+            checkoutOptionsObj.media = checkoutOptions.media;
+        }
+        if (checkoutOptions.discount !== undefined) {
+            checkoutOptionsObj.discount = checkoutOptions.discount;
+        }
+        if (checkoutOptions.buttonColor) {
+            checkoutOptionsObj.button_color = checkoutOptions.buttonColor;
+        }
+        if (Object.keys(checkoutData).length > 0) {
+            attributes.checkout_data = checkoutData;
+        }
+        if (Object.keys(productOptions).length > 0) {
+            attributes.product_options = productOptions;
+        }
+        if (Object.keys(checkoutOptionsObj).length > 0) {
+            attributes.checkout_options = checkoutOptionsObj;
+        }
+        const body = (0, helpers_1.buildJsonApiBody)('checkouts', attributes, {
+            store: { type: 'stores', id: storeId },
+            variant: { type: 'variants', id: variantId },
+        });
+        return await helpers_1.lemonSqueezyApiRequest.call(ctx, 'POST', '/checkouts', body);
+    }
+    if (resource === 'webhook') {
+        const storeId = ctx.getNodeParameter('webhookStoreId', itemIndex);
+        const url = ctx.getNodeParameter('webhookUrl', itemIndex);
+        const events = ctx.getNodeParameter('webhookEvents', itemIndex);
+        const secret = ctx.getNodeParameter('webhookSecret', itemIndex);
+        const additionalOptions = ctx.getNodeParameter('additionalOptions', itemIndex, {});
+        const attributes = { url, events, secret };
+        if (additionalOptions.testMode !== undefined) {
+            attributes.test_mode = additionalOptions.testMode;
+        }
+        const body = (0, helpers_1.buildJsonApiBody)('webhooks', attributes, {
+            store: { type: 'stores', id: storeId },
+        });
+        return await helpers_1.lemonSqueezyApiRequest.call(ctx, 'POST', '/webhooks', body);
+    }
+    throw new Error(`Create operation not supported for resource: ${resource}`);
+}
+async function handleUpdate(ctx, resource, itemIndex) {
+    if (resource === 'subscription') {
+        const subscriptionId = ctx.getNodeParameter('subscriptionId', itemIndex);
+        const updateFields = ctx.getNodeParameter('updateFields', itemIndex);
+        const attributes = {};
+        if (updateFields.variantId) {
+            attributes.variant_id = updateFields.variantId;
+        }
+        if (updateFields.pause !== undefined && updateFields.pause !== '') {
+            attributes.pause = { mode: updateFields.pause };
+        }
+        else if (updateFields.pause === '') {
+            attributes.pause = null;
+        }
+        if (updateFields.cancelled !== undefined) {
+            attributes.cancelled = updateFields.cancelled;
+        }
+        if (updateFields.billingAnchor) {
+            attributes.billing_anchor = updateFields.billingAnchor;
+        }
+        if (updateFields.invoiceImmediately !== undefined) {
+            attributes.invoice_immediately = updateFields.invoiceImmediately;
+        }
+        if (updateFields.disableProrations !== undefined) {
+            attributes.disable_prorations = updateFields.disableProrations;
+        }
+        const body = (0, helpers_1.buildJsonApiBody)('subscriptions', attributes, undefined, subscriptionId);
+        return await helpers_1.lemonSqueezyApiRequest.call(ctx, 'PATCH', `/subscriptions/${subscriptionId}`, body);
+    }
+    if (resource === 'customer') {
+        const customerId = ctx.getNodeParameter('customerId', itemIndex);
+        const updateFields = ctx.getNodeParameter('updateFields', itemIndex);
+        const attributes = {};
+        if (updateFields.name) {
+            attributes.name = updateFields.name;
+        }
+        if (updateFields.email) {
+            attributes.email = updateFields.email;
+        }
+        if (updateFields.city) {
+            attributes.city = updateFields.city;
+        }
+        if (updateFields.country) {
+            attributes.country = updateFields.country;
+        }
+        if (updateFields.region) {
+            attributes.region = updateFields.region;
+        }
+        if (updateFields.status) {
+            attributes.status = updateFields.status;
+        }
+        const body = (0, helpers_1.buildJsonApiBody)('customers', attributes, undefined, customerId);
+        return await helpers_1.lemonSqueezyApiRequest.call(ctx, 'PATCH', `/customers/${customerId}`, body);
+    }
+    if (resource === 'licenseKey') {
+        const licenseKeyId = ctx.getNodeParameter('licenseKeyId', itemIndex);
+        const updateFields = ctx.getNodeParameter('updateFields', itemIndex);
+        const attributes = {};
+        if (updateFields.activationLimit !== undefined) {
+            attributes.activation_limit = updateFields.activationLimit;
+        }
+        if (updateFields.disabled !== undefined) {
+            attributes.disabled = updateFields.disabled;
+        }
+        if (updateFields.expiresAt) {
+            attributes.expires_at = updateFields.expiresAt;
+        }
+        const body = (0, helpers_1.buildJsonApiBody)('license-keys', attributes, undefined, licenseKeyId);
+        return await helpers_1.lemonSqueezyApiRequest.call(ctx, 'PATCH', `/license-keys/${licenseKeyId}`, body);
+    }
+    if (resource === 'webhook') {
+        const webhookId = ctx.getNodeParameter('webhookId', itemIndex);
+        const updateFields = ctx.getNodeParameter('updateFields', itemIndex);
+        const attributes = {};
+        if (updateFields.url) {
+            attributes.url = updateFields.url;
+        }
+        if (updateFields.events) {
+            attributes.events = updateFields.events;
+        }
+        if (updateFields.secret) {
+            attributes.secret = updateFields.secret;
+        }
+        const body = (0, helpers_1.buildJsonApiBody)('webhooks', attributes, undefined, webhookId);
+        return await helpers_1.lemonSqueezyApiRequest.call(ctx, 'PATCH', `/webhooks/${webhookId}`, body);
+    }
+    throw new Error(`Update operation not supported for resource: ${resource}`);
+}
+class LemonSqueezy {
+    constructor() {
+        this.description = {
+            displayName: 'Lemon Squeezy',
+            name: 'lemonSqueezy',
+            icon: 'file:lemonSqueezy.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
+            description: 'Interact with Lemon Squeezy API',
+            defaults: {
+                name: 'Lemon Squeezy',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'lemonSqueezyApi',
+                    required: true,
+                },
+            ],
+            properties: [resources_1.resourceProperty, ...resources_1.allOperations, ...resources_1.allFields],
+        };
+    }
+    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 {
+                let responseData;
+                const endpoint = constants_1.RESOURCE_ENDPOINTS[resource];
+                if (operation === 'get') {
+                    const idParam = constants_1.RESOURCE_ID_PARAMS[resource];
+                    const id = this.getNodeParameter(idParam, i);
+                    responseData = await helpers_1.lemonSqueezyApiRequest.call(this, 'GET', `/${endpoint}/${id}`);
+                }
+                else if (operation === 'getAll') {
+                    const returnAll = this.getNodeParameter('returnAll', i);
+                    const filters = this.getNodeParameter('filters', i, {});
+                    const qs = (0, helpers_1.buildFilterParams)(filters);
+                    if (returnAll) {
+                        responseData = await helpers_1.lemonSqueezyApiRequestAllItems.call(this, 'GET', `/${endpoint}`, qs);
+                    }
+                    else {
+                        const limit = this.getNodeParameter('limit', i);
+                        qs['page[size]'] = limit;
+                        const response = await helpers_1.lemonSqueezyApiRequest.call(this, 'GET', `/${endpoint}`, undefined, qs);
+                        responseData = response.data;
+                    }
+                }
+                else if (operation === 'create') {
+                    responseData = await handleCreate(this, resource, i);
+                }
+                else if (operation === 'update') {
+                    responseData = await handleUpdate(this, resource, i);
+                }
+                else if (operation === 'delete') {
+                    const idParam = constants_1.RESOURCE_ID_PARAMS[resource];
+                    const id = this.getNodeParameter(idParam, i);
+                    responseData = await helpers_1.lemonSqueezyApiRequest.call(this, 'DELETE', `/${endpoint}/${id}`);
+                }
+                else if (operation === 'cancel' && resource === 'subscription') {
+                    const subscriptionId = this.getNodeParameter('subscriptionId', i);
+                    responseData = await helpers_1.lemonSqueezyApiRequest.call(this, 'DELETE', `/subscriptions/${subscriptionId}`);
+                }
+                else if (operation === 'resume' && resource === 'subscription') {
+                    const subscriptionId = this.getNodeParameter('subscriptionId', i);
+                    const body = (0, helpers_1.buildJsonApiBody)('subscriptions', { pause: null }, undefined, subscriptionId);
+                    responseData = await helpers_1.lemonSqueezyApiRequest.call(this, 'PATCH', `/subscriptions/${subscriptionId}`, body);
+                }
+                else if (operation === 'refund' && resource === 'order') {
+                    const orderId = this.getNodeParameter('orderId', i);
+                    responseData = await helpers_1.lemonSqueezyApiRequest.call(this, 'POST', `/orders/${orderId}/refund`);
+                }
+                else if (resource === 'licenseKey') {
+                    if (operation === 'validate') {
+                        const licenseKey = this.getNodeParameter('licenseKey', i);
+                        responseData = await helpers_1.lemonSqueezyApiRequest.call(this, 'POST', '/licenses/validate', {
+                            license_key: licenseKey,
+                        });
+                    }
+                    else if (operation === 'activate') {
+                        const licenseKey = this.getNodeParameter('licenseKey', i);
+                        const instanceName = this.getNodeParameter('instanceName', i);
+                        responseData = await helpers_1.lemonSqueezyApiRequest.call(this, 'POST', '/licenses/activate', {
+                            license_key: licenseKey,
+                            instance_name: instanceName,
+                        });
+                    }
+                    else if (operation === 'deactivate') {
+                        const licenseKey = this.getNodeParameter('licenseKey', i);
+                        const instanceId = this.getNodeParameter('instanceId', i);
+                        responseData = await helpers_1.lemonSqueezyApiRequest.call(this, 'POST', '/licenses/deactivate', {
+                            license_key: licenseKey,
+                            instance_id: instanceId,
+                        });
+                    }
+                }
+                const executionData = this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray(responseData), { itemData: { item: i } });
+                returnData.push(...executionData);
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: { error: error.message },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+}
+exports.LemonSqueezy = LemonSqueezy;

package/dist/nodes/LemonSqueezy/LemonSqueezyTrigger.node.d.ts

@@ -0,0 +1,12 @@
+import type { IWebhookFunctions, IHookFunctions, INodeType, INodeTypeDescription, IWebhookResponseData } from 'n8n-workflow';
+export declare class LemonSqueezyTrigger implements INodeType {
+    description: INodeTypeDescription;
+    webhookMethods: {
+        default: {
+            checkExists(this: IHookFunctions): Promise<boolean>;
+            create(this: IHookFunctions): Promise<boolean>;
+            delete(this: IHookFunctions): Promise<boolean>;
+        };
+    };
+    webhook(this: IWebhookFunctions): Promise<IWebhookResponseData>;
+}