n8n-nodes-lemonsqueezy 0.7.2 → 0.9.0

package/README.md

@@ -55,8 +55,9 @@ The main node for interacting with the Lemon Squeezy API.
 |----------|------------|
 | **Checkout** | Create, Get, Get Many |
 | **Customer** | Create, Update, Delete, Get, Get Many |
-| **Discount** | Create, Delete, Get, Get Many |
+| **Discount** | Create, Update, Delete, Get, Get Many |
 | **Discount Redemption** | Get, Get Many |
+| **File** | Get, Get Many |
 | **License Key** | Get, Get Many, Update, Validate, Activate, Deactivate |
 | **License Key Instance** | Get, Get Many |
 | **Order** | Get, Get Many, Refund |
@@ -64,7 +65,7 @@ The main node for interacting with the Lemon Squeezy API.
 | **Product** | Get, Get Many |
 | **Store** | Get, Get Many |
 | **Subscription** | Get, Get Many, Update, Cancel, Resume |
-| **Subscription Invoice** | Get, Get Many |
+| **Subscription Invoice** | Get, Get Many, Generate, Refund |
 | **Usage Record** | Create, Get, Get Many |
 | **User** | Get Current |
 | **Variant** | Get, Get Many |
@@ -303,6 +304,34 @@ Contributions are welcome! Please feel free to submit a Pull Request.
 
 ## Changelog
 
+### v0.9.0
+
+**New Features:**
+- Added **Subscription Invoice Generate operation** for generating invoices on subscriptions with outstanding balances
+- Added **Subscription Invoice Refund operation** for issuing full or partial refunds
+- Added custom data payload size validation (max 10KB) for checkout creation
+- Added Retry-After header extraction for smarter rate limit handling
+- Added resource validation guard to catch unknown resources early
+
+**Improvements:**
+- Added JSDoc documentation to all resource files
+- Improved field descriptions with units (cents), ranges (0-100), and examples
+- Added maxValue (100) to all limit fields for API compliance
+- 189 tests with comprehensive coverage
+
+### v0.8.0
+
+**New Features:**
+- Added **File resource** for accessing product files (digital downloads)
+- Added **Discount Update operation** for modifying existing discount codes
+- Added discount amount validation (0-100 for percent, positive integer for fixed)
+- Webhook URLs now require HTTPS (Lemon Squeezy requirement)
+
+**Improvements:**
+- Enhanced field descriptions with examples and placeholders
+- Added API limit hints (max 100 per page) to limit fields
+- 178 tests with comprehensive coverage
+
 ### v0.7.2
 
 **n8n Community Package Compliance:**

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

@@ -22,6 +22,8 @@ async function handleCreate(ctx, resource, itemIndex) {
         const amount = ctx.getNodeParameter('discountAmount', itemIndex);
         const amountType = ctx.getNodeParameter('discountAmountType', itemIndex);
         const additionalOptions = ctx.getNodeParameter('additionalOptions', itemIndex, {});
+        // Validate discount amount based on type
+        (0, helpers_1.validateDiscountAmount)(amount, amountType);
         const attributes = {
             name,
             code,
@@ -93,6 +95,8 @@ async function handleCreate(ctx, resource, itemIndex) {
         }
         if (additionalOptions.customData !== undefined && additionalOptions.customData !== null) {
             const customDataValue = additionalOptions.customData;
+            // Validate payload size before processing (max 10KB)
+            (0, helpers_1.validateCustomDataSize)(customDataValue);
             if (typeof customDataValue === 'string') {
                 try {
                     const parsed = JSON.parse(customDataValue);
@@ -169,8 +173,8 @@ async function handleCreate(ctx, resource, itemIndex) {
         const events = ctx.getNodeParameter('webhookEvents', itemIndex);
         const secret = ctx.getNodeParameter('webhookSecret', itemIndex);
         const additionalOptions = ctx.getNodeParameter('additionalOptions', itemIndex, {});
-        // Validate URL before API call
-        (0, helpers_1.validateField)('url', url, 'url');
+        // Validate URL before API call - Lemon Squeezy requires HTTPS for webhooks
+        (0, helpers_1.validateField)('url', url, 'httpsUrl');
         // Validate webhook secret minimum length for security (32+ chars recommended)
         if (secret.length < 32) {
             throw new Error('Webhook secret must be at least 32 characters for security. Generate one using: openssl rand -hex 32');
@@ -263,8 +267,8 @@ async function handleUpdate(ctx, resource, itemIndex) {
         const updateFields = ctx.getNodeParameter('updateFields', itemIndex);
         const attributes = {};
         if (updateFields.url) {
-            // Validate URL before API call
-            (0, helpers_1.validateField)('url', updateFields.url, 'url');
+            // Validate URL before API call - Lemon Squeezy requires HTTPS for webhooks
+            (0, helpers_1.validateField)('url', updateFields.url, 'httpsUrl');
             attributes.url = updateFields.url;
         }
         if (updateFields.events) {
@@ -280,6 +284,44 @@ async function handleUpdate(ctx, resource, itemIndex) {
         const body = (0, helpers_1.buildJsonApiBody)('webhooks', attributes, undefined, webhookId);
         return await helpers_1.lemonSqueezyApiRequest.call(ctx, 'PATCH', `/webhooks/${webhookId}`, body);
     }
+    if (resource === 'discount') {
+        const discountId = ctx.getNodeParameter('discountId', itemIndex);
+        const updateFields = ctx.getNodeParameter('updateFields', itemIndex);
+        const attributes = {};
+        if (updateFields.name) {
+            attributes.name = updateFields.name;
+        }
+        if (updateFields.code) {
+            attributes.code = updateFields.code;
+        }
+        if (updateFields.amount !== undefined) {
+            // Validate discount amount if both amount and type are being updated
+            const amountType = updateFields.amountType || 'percent';
+            (0, helpers_1.validateDiscountAmount)(updateFields.amount, amountType);
+            attributes.amount = updateFields.amount;
+        }
+        if (updateFields.amountType) {
+            attributes.amount_type = updateFields.amountType;
+        }
+        if (updateFields.duration) {
+            attributes.duration = updateFields.duration;
+        }
+        if (updateFields.durationInMonths !== undefined) {
+            attributes.duration_in_months = updateFields.durationInMonths;
+        }
+        if (updateFields.maxRedemptions !== undefined) {
+            attributes.max_redemptions = updateFields.maxRedemptions;
+            attributes.is_limited_redemptions = updateFields.maxRedemptions > 0;
+        }
+        if (updateFields.startsAt) {
+            attributes.starts_at = updateFields.startsAt;
+        }
+        if (updateFields.expiresAt) {
+            attributes.expires_at = updateFields.expiresAt;
+        }
+        const body = (0, helpers_1.buildJsonApiBody)('discounts', attributes, undefined, discountId);
+        return await helpers_1.lemonSqueezyApiRequest.call(ctx, 'PATCH', `/discounts/${discountId}`, body);
+    }
     throw new Error(`Update operation not supported for resource: ${resource}`);
 }
 class LemonSqueezy {
@@ -316,6 +358,10 @@ class LemonSqueezy {
             try {
                 let responseData;
                 const endpoint = constants_1.RESOURCE_ENDPOINTS[resource];
+                // Validate that the resource exists in our endpoints mapping
+                if (!endpoint && !['user'].includes(resource)) {
+                    throw new Error(`Unknown resource: ${resource}`);
+                }
                 if (operation === 'get') {
                     const idParam = constants_1.RESOURCE_ID_PARAMS[resource];
                     const id = this.getNodeParameter(idParam, i);
@@ -404,6 +450,21 @@ class LemonSqueezy {
                 else if (resource === 'user' && operation === 'getCurrent') {
                     responseData = await helpers_1.lemonSqueezyApiRequest.call(this, 'GET', '/users/me');
                 }
+                else if (resource === 'subscriptionInvoice') {
+                    if (operation === 'generate') {
+                        const subscriptionId = this.getNodeParameter('generateSubscriptionId', i);
+                        const body = (0, helpers_1.buildJsonApiBody)('subscription-invoices', {}, { subscription: { type: 'subscriptions', id: subscriptionId } });
+                        responseData = await helpers_1.lemonSqueezyApiRequest.call(this, 'POST', '/subscription-invoices', body);
+                    }
+                    else if (operation === 'refund') {
+                        const invoiceId = this.getNodeParameter('subscriptionInvoiceId', i);
+                        const refundAmount = this.getNodeParameter('refundAmount', i, 0);
+                        const body = refundAmount > 0
+                            ? { data: { type: 'subscription-invoices', attributes: { amount: refundAmount } } }
+                            : {};
+                        responseData = await helpers_1.lemonSqueezyApiRequest.call(this, 'POST', `/subscription-invoices/${invoiceId}/refund`, body);
+                    }
+                }
                 const executionData = this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray(responseData), { itemData: { item: i } });
                 returnData.push(...executionData);
             }

package/dist/nodes/LemonSqueezy/constants.js

@@ -31,6 +31,7 @@ exports.RESOURCE_ENDPOINTS = {
     webhook: 'webhooks',
     usageRecord: 'usage-records',
     user: 'users',
+    file: 'files',
 };
 /**
  * Resource to ID parameter mapping
@@ -51,6 +52,7 @@ exports.RESOURCE_ID_PARAMS = {
     checkout: 'checkoutId',
     webhook: 'webhookId',
     usageRecord: 'usageRecordId',
+    file: 'fileId',
 };
 /**
  * Webhook event types with descriptions

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

@@ -41,6 +41,7 @@ export declare function isValidEmail(email: string): boolean;
  * This prevents Server-Side Request Forgery (SSRF) attacks.
  *
  * @param url - The URL to validate
+ * @param requireHttps - If true, only HTTPS URLs are allowed (default: false)
  * @returns True if the URL is valid and safe, false otherwise
  *
  * @example
@@ -48,8 +49,9 @@ export declare function isValidEmail(email: string): boolean;
  * isValidUrl('http://localhost:3000') // false (internal)
  * isValidUrl('ftp://files.example.com') // false (non-http protocol)
  * isValidUrl('http://169.254.169.254') // false (AWS metadata)
+ * isValidUrl('http://example.com', true) // false (HTTPS required)
  */
-export declare function isValidUrl(url: string): boolean;
+export declare function isValidUrl(url: string, requireHttps?: boolean): boolean;
 /**
  * Validates ISO 8601 date format.
  *
@@ -88,6 +90,7 @@ export declare function isPositiveInteger(value: unknown): boolean;
  * - 'required': Ensures value is not empty/null/undefined
  * - 'email': RFC 5322 compliant email validation
  * - 'url': Safe URL validation with SSRF protection
+ * - 'httpsUrl': Safe URL validation requiring HTTPS (for webhooks)
  * - 'date': ISO 8601 date format validation
  * - 'positiveInteger': Positive integer validation
  *
@@ -99,8 +102,9 @@ export declare function isPositiveInteger(value: unknown): boolean;
  * @example
  * validateField('email', 'user@example.com', 'email') // passes
  * validateField('email', 'invalid', 'email') // throws "email must be a valid email address"
+ * validateField('webhookUrl', 'http://example.com', 'httpsUrl') // throws "webhookUrl must be a valid HTTPS URL"
  */
-export declare function validateField(fieldName: string, value: unknown, validationType: 'email' | 'url' | 'date' | 'positiveInteger' | 'required'): void;
+export declare function validateField(fieldName: string, value: unknown, validationType: 'email' | 'url' | 'httpsUrl' | 'date' | 'positiveInteger' | 'required'): void;
 /**
  * Safely parses a JSON string with descriptive error handling.
  *
@@ -118,6 +122,51 @@ export declare function validateField(fieldName: string, value: unknown, validat
  * // Throws: "config contains invalid JSON"
  */
 export declare function safeJsonParse<T = unknown>(jsonString: string, fieldName: string): T;
+/**
+ * Validates discount amount based on the amount type.
+ *
+ * - For 'percent' type: amount must be between 0 and 100 (inclusive)
+ * - For 'fixed' type: amount must be a positive integer (in cents)
+ *
+ * @param amount - The discount amount to validate
+ * @param amountType - The type of discount ('percent' or 'fixed')
+ * @throws Error if the amount is invalid for the given type
+ *
+ * @example
+ * validateDiscountAmount(50, 'percent') // passes (50%)
+ * validateDiscountAmount(150, 'percent') // throws "Percent discount must be between 0 and 100"
+ * validateDiscountAmount(1000, 'fixed') // passes ($10.00 in cents)
+ * validateDiscountAmount(-100, 'fixed') // throws "Fixed discount amount must be a positive integer"
+ */
+export declare function validateDiscountAmount(amount: number, amountType: string): void;
+/**
+ * Validates that a custom data payload doesn't exceed the maximum size.
+ *
+ * This prevents memory issues and potential abuse from extremely large payloads.
+ *
+ * @param data - The custom data object or string to validate
+ * @param maxSizeBytes - Maximum allowed size in bytes (default: 10KB)
+ * @throws Error if the payload exceeds the maximum size
+ *
+ * @example
+ * validateCustomDataSize({ key: 'value' }) // passes
+ * validateCustomDataSize(veryLargeObject) // throws if > 10KB
+ */
+export declare function validateCustomDataSize(data: unknown, maxSizeBytes?: number): void;
+/**
+ * Extracts the Retry-After header value from an error response.
+ *
+ * The Retry-After header indicates how long to wait before retrying
+ * a rate-limited or temporarily unavailable request.
+ *
+ * @param error - The error object that may contain Retry-After header
+ * @returns Number of seconds to wait, or undefined if not present
+ *
+ * @example
+ * getRetryAfterSeconds({ response: { headers: { 'retry-after': '60' } } }) // 60
+ * getRetryAfterSeconds({ response: { headers: {} } }) // undefined
+ */
+export declare function getRetryAfterSeconds(error: unknown): number | undefined;
 /**
  * Checks if an error is a rate limit error (HTTP 429).
  *

package/dist/nodes/LemonSqueezy/helpers.js

@@ -51,6 +51,9 @@ exports.isValidIsoDate = isValidIsoDate;
 exports.isPositiveInteger = isPositiveInteger;
 exports.validateField = validateField;
 exports.safeJsonParse = safeJsonParse;
+exports.validateDiscountAmount = validateDiscountAmount;
+exports.validateCustomDataSize = validateCustomDataSize;
+exports.getRetryAfterSeconds = getRetryAfterSeconds;
 exports.isRateLimitError = isRateLimitError;
 exports.isRetryableError = isRetryableError;
 exports.lemonSqueezyApiRequest = lemonSqueezyApiRequest;
@@ -101,6 +104,7 @@ function isValidEmail(email) {
  * This prevents Server-Side Request Forgery (SSRF) attacks.
  *
  * @param url - The URL to validate
+ * @param requireHttps - If true, only HTTPS URLs are allowed (default: false)
  * @returns True if the URL is valid and safe, false otherwise
  *
  * @example
@@ -108,10 +112,15 @@ function isValidEmail(email) {
  * isValidUrl('http://localhost:3000') // false (internal)
  * isValidUrl('ftp://files.example.com') // false (non-http protocol)
  * isValidUrl('http://169.254.169.254') // false (AWS metadata)
+ * isValidUrl('http://example.com', true) // false (HTTPS required)
  */
-function isValidUrl(url) {
+function isValidUrl(url, requireHttps = false) {
     try {
         const parsedUrl = new URL(url);
+        // If HTTPS is required, reject HTTP URLs
+        if (requireHttps && parsedUrl.protocol !== 'https:') {
+            return false;
+        }
         // Only allow http and https protocols (security: prevent file://, javascript:, etc.)
         if (!['http:', 'https:'].includes(parsedUrl.protocol)) {
             return false;
@@ -199,6 +208,7 @@ function isPositiveInteger(value) {
  * - 'required': Ensures value is not empty/null/undefined
  * - 'email': RFC 5322 compliant email validation
  * - 'url': Safe URL validation with SSRF protection
+ * - 'httpsUrl': Safe URL validation requiring HTTPS (for webhooks)
  * - 'date': ISO 8601 date format validation
  * - 'positiveInteger': Positive integer validation
  *
@@ -210,6 +220,7 @@ function isPositiveInteger(value) {
  * @example
  * validateField('email', 'user@example.com', 'email') // passes
  * validateField('email', 'invalid', 'email') // throws "email must be a valid email address"
+ * validateField('webhookUrl', 'http://example.com', 'httpsUrl') // throws "webhookUrl must be a valid HTTPS URL"
  */
 function validateField(fieldName, value, validationType) {
     if (validationType === 'required') {
@@ -233,6 +244,11 @@ function validateField(fieldName, value, validationType) {
                 throw new Error(`${fieldName} must be a valid URL`);
             }
             break;
+        case 'httpsUrl':
+            if (typeof value !== 'string' || !isValidUrl(value, true)) {
+                throw new Error(`${fieldName} must be a valid HTTPS URL (Lemon Squeezy requires HTTPS for webhooks)`);
+            }
+            break;
         case 'date':
             if (typeof value !== 'string' || !isValidIsoDate(value)) {
                 throw new Error(`${fieldName} must be a valid ISO 8601 date`);
@@ -269,6 +285,85 @@ function safeJsonParse(jsonString, fieldName) {
         throw new Error(`${fieldName} contains invalid JSON`);
     }
 }
+/**
+ * Validates discount amount based on the amount type.
+ *
+ * - For 'percent' type: amount must be between 0 and 100 (inclusive)
+ * - For 'fixed' type: amount must be a positive integer (in cents)
+ *
+ * @param amount - The discount amount to validate
+ * @param amountType - The type of discount ('percent' or 'fixed')
+ * @throws Error if the amount is invalid for the given type
+ *
+ * @example
+ * validateDiscountAmount(50, 'percent') // passes (50%)
+ * validateDiscountAmount(150, 'percent') // throws "Percent discount must be between 0 and 100"
+ * validateDiscountAmount(1000, 'fixed') // passes ($10.00 in cents)
+ * validateDiscountAmount(-100, 'fixed') // throws "Fixed discount amount must be a positive integer"
+ */
+function validateDiscountAmount(amount, amountType) {
+    if (amountType === 'percent') {
+        if (amount < 0 || amount > 100) {
+            throw new Error('Percent discount must be between 0 and 100');
+        }
+    }
+    else if (amountType === 'fixed') {
+        if (!Number.isInteger(amount) || amount < 0) {
+            throw new Error('Fixed discount amount must be a positive integer (in cents)');
+        }
+    }
+}
+/** Maximum payload size for custom data (10KB) */
+const MAX_CUSTOM_DATA_SIZE_BYTES = 10 * 1024;
+/**
+ * Validates that a custom data payload doesn't exceed the maximum size.
+ *
+ * This prevents memory issues and potential abuse from extremely large payloads.
+ *
+ * @param data - The custom data object or string to validate
+ * @param maxSizeBytes - Maximum allowed size in bytes (default: 10KB)
+ * @throws Error if the payload exceeds the maximum size
+ *
+ * @example
+ * validateCustomDataSize({ key: 'value' }) // passes
+ * validateCustomDataSize(veryLargeObject) // throws if > 10KB
+ */
+function validateCustomDataSize(data, maxSizeBytes = MAX_CUSTOM_DATA_SIZE_BYTES) {
+    const jsonString = typeof data === 'string' ? data : JSON.stringify(data);
+    const sizeBytes = Buffer.byteLength(jsonString, 'utf8');
+    if (sizeBytes > maxSizeBytes) {
+        const sizeKb = Math.round(sizeBytes / 1024);
+        const maxKb = Math.round(maxSizeBytes / 1024);
+        throw new Error(`Custom data exceeds maximum size (${sizeKb}KB > ${maxKb}KB). Reduce the payload size.`);
+    }
+}
+/**
+ * Extracts the Retry-After header value from an error response.
+ *
+ * The Retry-After header indicates how long to wait before retrying
+ * a rate-limited or temporarily unavailable request.
+ *
+ * @param error - The error object that may contain Retry-After header
+ * @returns Number of seconds to wait, or undefined if not present
+ *
+ * @example
+ * getRetryAfterSeconds({ response: { headers: { 'retry-after': '60' } } }) // 60
+ * getRetryAfterSeconds({ response: { headers: {} } }) // undefined
+ */
+function getRetryAfterSeconds(error) {
+    var _a, _b;
+    if (error && typeof error === 'object') {
+        const err = error;
+        const retryAfter = (_b = (_a = err.response) === null || _a === void 0 ? void 0 : _a.headers) === null || _b === void 0 ? void 0 : _b['retry-after'];
+        if (retryAfter) {
+            const seconds = parseInt(retryAfter, 10);
+            if (!isNaN(seconds) && seconds > 0) {
+                return seconds;
+            }
+        }
+    }
+    return undefined;
+}
 /**
  * Checks if an error is a rate limit error (HTTP 429).
  *

package/dist/nodes/LemonSqueezy/resources/customer.d.ts

@@ -1,3 +1,17 @@
+/**
+ * Customer Resource
+ *
+ * Provides operations for managing customers in Lemon Squeezy.
+ *
+ * Available operations:
+ * - Create: Create a new customer
+ * - Delete: Archive a customer
+ * - Get: Retrieve a single customer by ID
+ * - Get Many: Retrieve multiple customers with filtering
+ * - Update: Update customer information
+ *
+ * @see https://docs.lemonsqueezy.com/api/customers
+ */
 import type { INodeProperties } from 'n8n-workflow';
 export declare const customerOperations: INodeProperties;
 export declare const customerFields: INodeProperties[];

package/dist/nodes/LemonSqueezy/resources/customer.js

@@ -52,7 +52,8 @@ exports.customerFields = [
         type: 'string',
         required: true,
         default: '',
-        description: 'The ID of the customer',
+        placeholder: 'e.g., 12345',
+        description: 'The ID of the customer (numeric string)',
         displayOptions: {
             show: { resource: ['customer'], operation: ['get', 'update', 'delete'] },
         },
@@ -64,7 +65,8 @@ exports.customerFields = [
         type: 'string',
         required: true,
         default: '',
-        description: 'The ID of the store this customer belongs to',
+        placeholder: 'e.g., 12345',
+        description: 'The ID of the store this customer belongs to. Find this in your <a href="https://app.lemonsqueezy.com/settings/stores" target="_blank">Lemon Squeezy Dashboard</a>.',
         displayOptions: {
             show: { resource: ['customer'], operation: ['create'] },
         },
@@ -198,8 +200,8 @@ exports.customerFields = [
         name: 'limit',
         type: 'number',
         default: 50,
-        description: 'Max number of results to return',
-        typeOptions: { minValue: 1 },
+        description: 'Max number of results to return (API maximum is 100 per page)',
+        typeOptions: { minValue: 1, maxValue: 100 },
         displayOptions: {
             show: { resource: ['customer'], operation: ['getAll'], returnAll: [false] },
         },

package/dist/nodes/LemonSqueezy/resources/discount.d.ts

@@ -1,3 +1,17 @@
+/**
+ * Discount Resource
+ *
+ * Provides operations for managing discount codes in Lemon Squeezy.
+ *
+ * Available operations:
+ * - Create: Create a new discount code
+ * - Delete: Delete an existing discount code
+ * - Get: Retrieve a single discount by ID
+ * - Get Many: Retrieve multiple discounts with filtering
+ * - Update: Update an existing discount code
+ *
+ * @see https://docs.lemonsqueezy.com/api/discounts
+ */
 import type { INodeProperties } from 'n8n-workflow';
 export declare const discountOperations: INodeProperties;
 export declare const discountFields: INodeProperties[];

package/dist/nodes/LemonSqueezy/resources/discount.js

@@ -35,20 +35,27 @@ exports.discountOperations = {
             action: 'Get many discounts',
             description: 'Retrieve multiple discounts',
         },
+        {
+            name: 'Update',
+            value: 'update',
+            action: 'Update a discount',
+            description: 'Update an existing discount code',
+        },
     ],
     default: 'getAll',
 };
 exports.discountFields = [
-    // Discount ID for Get/Delete operations
+    // Discount ID for Get/Update/Delete operations
     {
         displayName: 'Discount ID',
         name: 'discountId',
         type: 'string',
         required: true,
         default: '',
-        description: 'The ID of the discount',
+        placeholder: 'e.g., 12345',
+        description: 'The ID of the discount (numeric string)',
         displayOptions: {
-            show: { resource: ['discount'], operation: ['get', 'delete'] },
+            show: { resource: ['discount'], operation: ['get', 'update', 'delete'] },
         },
     },
     // Create Fields
@@ -91,7 +98,7 @@ exports.discountFields = [
         type: 'number',
         required: true,
         default: 0,
-        description: 'Discount amount (percentage 0-100 or fixed amount in cents)',
+        description: 'Discount amount. For percent type: 0-100 (e.g., 25 = 25% off). For fixed type: amount in cents (e.g., 1000 = $10.00 off).',
         displayOptions: {
             show: { resource: ['discount'], operation: ['create'] },
         },
@@ -164,6 +171,86 @@ exports.discountFields = [
             },
         ],
     },
+    // Update Fields
+    {
+        displayName: 'Update Fields',
+        name: 'updateFields',
+        type: 'collection',
+        placeholder: 'Add Field',
+        default: {},
+        displayOptions: {
+            show: { resource: ['discount'], operation: ['update'] },
+        },
+        options: [
+            {
+                displayName: 'Name',
+                name: 'name',
+                type: 'string',
+                default: '',
+                description: 'Internal name for the discount (not visible to customers)',
+            },
+            {
+                displayName: 'Code',
+                name: 'code',
+                type: 'string',
+                default: '',
+                description: 'The discount code customers will use at checkout',
+            },
+            {
+                displayName: 'Amount',
+                name: 'amount',
+                type: 'number',
+                default: 0,
+                description: 'Discount amount (percentage 0-100 for percent type, or fixed amount in cents for fixed type)',
+            },
+            {
+                displayName: 'Amount Type',
+                name: 'amountType',
+                type: 'options',
+                options: constants_1.DISCOUNT_AMOUNT_TYPES,
+                default: 'percent',
+                description: 'Whether the discount is a percentage or fixed amount',
+            },
+            {
+                displayName: 'Duration',
+                name: 'duration',
+                type: 'options',
+                options: constants_1.DISCOUNT_DURATION_TYPES,
+                default: 'once',
+                description: 'How long the discount should apply for subscriptions',
+            },
+            {
+                displayName: 'Duration In Months',
+                name: 'durationInMonths',
+                type: 'number',
+                default: 1,
+                description: 'Number of months the discount applies (only for "repeating" duration)',
+                typeOptions: { minValue: 1 },
+            },
+            {
+                displayName: 'Max Redemptions',
+                name: 'maxRedemptions',
+                type: 'number',
+                default: 0,
+                description: 'Maximum number of times this discount can be used (0 for unlimited)',
+                typeOptions: { minValue: 0 },
+            },
+            {
+                displayName: 'Starts At',
+                name: 'startsAt',
+                type: 'dateTime',
+                default: '',
+                description: 'When the discount becomes active (ISO 8601 format, e.g., 2024-01-15T10:30:00Z)',
+            },
+            {
+                displayName: 'Expires At',
+                name: 'expiresAt',
+                type: 'dateTime',
+                default: '',
+                description: 'When the discount expires (ISO 8601 format, e.g., 2024-12-31T23:59:59Z)',
+            },
+        ],
+    },
     // Return All
     {
         displayName: 'Return All',
@@ -181,8 +268,8 @@ exports.discountFields = [
         name: 'limit',
         type: 'number',
         default: 50,
-        description: 'Max number of results to return',
-        typeOptions: { minValue: 1 },
+        description: 'Max number of results to return (API maximum is 100 per page)',
+        typeOptions: { minValue: 1, maxValue: 100 },
         displayOptions: {
             show: { resource: ['discount'], operation: ['getAll'], returnAll: [false] },
         },

package/dist/nodes/LemonSqueezy/resources/file.d.ts

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

package/dist/nodes/LemonSqueezy/resources/file.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fileFields = exports.fileOperations = void 0;
+exports.fileOperations = {
+    displayName: 'Operation',
+    name: 'operation',
+    type: 'options',
+    noDataExpression: true,
+    displayOptions: {
+        show: { resource: ['file'] },
+    },
+    options: [
+        {
+            name: 'Get',
+            value: 'get',
+            action: 'Get a file',
+            description: 'Retrieve a single file by ID',
+        },
+        {
+            name: 'Get Many',
+            value: 'getAll',
+            action: 'Get many files',
+            description: 'Retrieve multiple files',
+        },
+    ],
+    default: 'getAll',
+};
+exports.fileFields = [
+    // File ID for Get operation
+    {
+        displayName: 'File ID',
+        name: 'fileId',
+        type: 'string',
+        required: true,
+        default: '',
+        placeholder: 'e.g., 12345',
+        description: 'The ID of the file (numeric string)',
+        displayOptions: {
+            show: { resource: ['file'], operation: ['get'] },
+        },
+    },
+    // Return All
+    {
+        displayName: 'Return All',
+        name: 'returnAll',
+        type: 'boolean',
+        default: false,
+        description: 'Whether to return all results or only up to a given limit',
+        displayOptions: {
+            show: { resource: ['file'], operation: ['getAll'] },
+        },
+    },
+    // Limit
+    {
+        displayName: 'Limit',
+        name: 'limit',
+        type: 'number',
+        default: 50,
+        description: 'Max number of results to return (API maximum is 100 per page)',
+        typeOptions: { minValue: 1, maxValue: 100 },
+        displayOptions: {
+            show: { resource: ['file'], operation: ['getAll'], returnAll: [false] },
+        },
+    },
+    // Filters
+    {
+        displayName: 'Filters',
+        name: 'filters',
+        type: 'collection',
+        placeholder: 'Add Filter',
+        default: {},
+        displayOptions: {
+            show: { resource: ['file'], operation: ['getAll'] },
+        },
+        options: [
+            {
+                displayName: 'Variant ID',
+                name: 'variantId',
+                type: 'string',
+                default: '',
+                placeholder: 'e.g., 12345',
+                description: 'Filter files by variant ID',
+            },
+        ],
+    },
+];

package/dist/nodes/LemonSqueezy/resources/index.d.ts

@@ -15,7 +15,8 @@ import { checkoutOperations, checkoutFields } from './checkout';
 import { webhookOperations, webhookFields } from './webhook';
 import { usageRecordOperations, usageRecordFields } from './usageRecord';
 import { userOperations, userFields } from './user';
+import { fileOperations, fileFields } from './file';
 export declare const resourceProperty: INodeProperties;
 export declare const allOperations: INodeProperties[];
 export declare const allFields: INodeProperties[];
-export { productOperations, productFields, orderOperations, orderFields, orderItemOperations, orderItemFields, subscriptionOperations, subscriptionFields, subscriptionInvoiceOperations, subscriptionInvoiceFields, customerOperations, customerFields, licenseKeyOperations, licenseKeyFields, licenseKeyInstanceOperations, licenseKeyInstanceFields, discountOperations, discountFields, discountRedemptionOperations, discountRedemptionFields, storeOperations, storeFields, variantOperations, variantFields, checkoutOperations, checkoutFields, webhookOperations, webhookFields, usageRecordOperations, usageRecordFields, userOperations, userFields, };
+export { productOperations, productFields, orderOperations, orderFields, orderItemOperations, orderItemFields, subscriptionOperations, subscriptionFields, subscriptionInvoiceOperations, subscriptionInvoiceFields, customerOperations, customerFields, licenseKeyOperations, licenseKeyFields, licenseKeyInstanceOperations, licenseKeyInstanceFields, discountOperations, discountFields, discountRedemptionOperations, discountRedemptionFields, storeOperations, storeFields, variantOperations, variantFields, checkoutOperations, checkoutFields, webhookOperations, webhookFields, usageRecordOperations, usageRecordFields, userOperations, userFields, fileOperations, fileFields, };

package/dist/nodes/LemonSqueezy/resources/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.userFields = exports.userOperations = exports.usageRecordFields = exports.usageRecordOperations = exports.webhookFields = exports.webhookOperations = exports.checkoutFields = exports.checkoutOperations = exports.variantFields = exports.variantOperations = exports.storeFields = exports.storeOperations = exports.discountRedemptionFields = exports.discountRedemptionOperations = exports.discountFields = exports.discountOperations = exports.licenseKeyInstanceFields = exports.licenseKeyInstanceOperations = exports.licenseKeyFields = exports.licenseKeyOperations = exports.customerFields = exports.customerOperations = exports.subscriptionInvoiceFields = exports.subscriptionInvoiceOperations = exports.subscriptionFields = exports.subscriptionOperations = exports.orderItemFields = exports.orderItemOperations = exports.orderFields = exports.orderOperations = exports.productFields = exports.productOperations = exports.allFields = exports.allOperations = exports.resourceProperty = void 0;
+exports.fileFields = exports.fileOperations = exports.userFields = exports.userOperations = exports.usageRecordFields = exports.usageRecordOperations = exports.webhookFields = exports.webhookOperations = exports.checkoutFields = exports.checkoutOperations = exports.variantFields = exports.variantOperations = exports.storeFields = exports.storeOperations = exports.discountRedemptionFields = exports.discountRedemptionOperations = exports.discountFields = exports.discountOperations = exports.licenseKeyInstanceFields = exports.licenseKeyInstanceOperations = exports.licenseKeyFields = exports.licenseKeyOperations = exports.customerFields = exports.customerOperations = exports.subscriptionInvoiceFields = exports.subscriptionInvoiceOperations = exports.subscriptionFields = exports.subscriptionOperations = exports.orderItemFields = exports.orderItemOperations = exports.orderFields = exports.orderOperations = exports.productFields = exports.productOperations = exports.allFields = exports.allOperations = exports.resourceProperty = void 0;
 const product_1 = require("./product");
 Object.defineProperty(exports, "productOperations", { enumerable: true, get: function () { return product_1.productOperations; } });
 Object.defineProperty(exports, "productFields", { enumerable: true, get: function () { return product_1.productFields; } });
@@ -49,6 +49,9 @@ Object.defineProperty(exports, "usageRecordFields", { enumerable: true, get: fun
 const user_1 = require("./user");
 Object.defineProperty(exports, "userOperations", { enumerable: true, get: function () { return user_1.userOperations; } });
 Object.defineProperty(exports, "userFields", { enumerable: true, get: function () { return user_1.userFields; } });
+const file_1 = require("./file");
+Object.defineProperty(exports, "fileOperations", { enumerable: true, get: function () { return file_1.fileOperations; } });
+Object.defineProperty(exports, "fileFields", { enumerable: true, get: function () { return file_1.fileFields; } });
 const shared_1 = require("./shared");
 exports.resourceProperty = {
     displayName: 'Resource',
@@ -60,6 +63,7 @@ exports.resourceProperty = {
         { name: 'Customer', value: 'customer' },
         { name: 'Discount', value: 'discount' },
         { name: 'Discount Redemption', value: 'discountRedemption' },
+        { name: 'File', value: 'file' },
         { name: 'License Key', value: 'licenseKey' },
         { name: 'License Key Instance', value: 'licenseKeyInstance' },
         { name: 'Order', value: 'order' },
@@ -92,6 +96,7 @@ exports.allOperations = [
     webhook_1.webhookOperations,
     ...usageRecord_1.usageRecordOperations,
     ...user_1.userOperations,
+    file_1.fileOperations,
 ];
 exports.allFields = [
     ...product_1.productFields,
@@ -118,4 +123,5 @@ exports.allFields = [
     ...webhook_1.webhookFields,
     ...usageRecord_1.usageRecordFields,
     ...user_1.userFields,
+    ...file_1.fileFields,
 ];

package/dist/nodes/LemonSqueezy/resources/order.d.ts

@@ -1,3 +1,16 @@
+/**
+ * Order Resource
+ *
+ * Provides operations for managing orders in Lemon Squeezy.
+ * Orders are created when customers complete purchases.
+ *
+ * Available operations:
+ * - Get: Retrieve a single order by ID
+ * - Get Many: Retrieve multiple orders with filtering
+ * - Refund: Issue a full refund for an order
+ *
+ * @see https://docs.lemonsqueezy.com/api/orders
+ */
 import type { INodeProperties } from 'n8n-workflow';
 export declare const orderOperations: INodeProperties;
 export declare const orderFields: INodeProperties[];

package/dist/nodes/LemonSqueezy/resources/order.js

@@ -62,8 +62,8 @@ exports.orderFields = [
         name: 'limit',
         type: 'number',
         default: 50,
-        description: 'Max number of results to return',
-        typeOptions: { minValue: 1 },
+        description: 'Max number of results to return (API maximum is 100 per page)',
+        typeOptions: { minValue: 1, maxValue: 100 },
         displayOptions: {
             show: { resource: ['order'], operation: ['getAll'], returnAll: [false] },
         },

package/dist/nodes/LemonSqueezy/resources/product.d.ts

@@ -1,3 +1,16 @@
+/**
+ * Product Resource
+ *
+ * Provides read-only operations for products in Lemon Squeezy.
+ * Products are managed in the Lemon Squeezy dashboard and cannot be
+ * created, updated, or deleted via the API.
+ *
+ * Available operations:
+ * - Get: Retrieve a single product by ID
+ * - Get Many: Retrieve multiple products with filtering
+ *
+ * @see https://docs.lemonsqueezy.com/api/products
+ */
 import type { INodeProperties } from 'n8n-workflow';
 export declare const productOperations: INodeProperties;
 export declare const productFields: INodeProperties[];

package/dist/nodes/LemonSqueezy/resources/product.js

@@ -56,8 +56,8 @@ exports.productFields = [
         name: 'limit',
         type: 'number',
         default: 50,
-        description: 'Max number of results to return',
-        typeOptions: { minValue: 1 },
+        description: 'Max number of results to return (API maximum is 100 per page)',
+        typeOptions: { minValue: 1, maxValue: 100 },
         displayOptions: {
             show: { resource: ['product'], operation: ['getAll'], returnAll: [false] },
         },

package/dist/nodes/LemonSqueezy/resources/subscriptionInvoice.d.ts

@@ -1,3 +1,16 @@
+/**
+ * Subscription Invoice Resource
+ *
+ * Provides operations for managing subscription invoices in Lemon Squeezy.
+ *
+ * Available operations:
+ * - Get: Retrieve a single subscription invoice by ID
+ * - Get Many: Retrieve multiple subscription invoices with filtering
+ * - Generate: Generate a new invoice for an outstanding balance
+ * - Refund: Issue a refund for a subscription invoice
+ *
+ * @see https://docs.lemonsqueezy.com/api/subscription-invoices
+ */
 import type { INodeProperties } from 'n8n-workflow';
 export declare const subscriptionInvoiceOperations: INodeProperties[];
 export declare const subscriptionInvoiceFields: INodeProperties[];

package/dist/nodes/LemonSqueezy/resources/subscriptionInvoice.js

@@ -13,6 +13,12 @@ exports.subscriptionInvoiceOperations = [
             },
         },
         options: [
+            {
+                name: 'Generate',
+                value: 'generate',
+                description: 'Generate an invoice for outstanding subscription balance',
+                action: 'Generate a subscription invoice',
+            },
             {
                 name: 'Get',
                 value: 'get',
@@ -25,12 +31,18 @@ exports.subscriptionInvoiceOperations = [
                 description: 'Get many subscription invoices',
                 action: 'Get many subscription invoices',
             },
+            {
+                name: 'Refund',
+                value: 'refund',
+                description: 'Issue a refund for a subscription invoice',
+                action: 'Refund a subscription invoice',
+            },
         ],
         default: 'getAll',
     },
 ];
 exports.subscriptionInvoiceFields = [
-    // Get
+    // Subscription Invoice ID for Get and Refund operations
     {
         displayName: 'Subscription Invoice ID',
         name: 'subscriptionInvoiceId',
@@ -40,10 +52,43 @@ exports.subscriptionInvoiceFields = [
         displayOptions: {
             show: {
                 resource: ['subscriptionInvoice'],
-                operation: ['get'],
+                operation: ['get', 'refund'],
+            },
+        },
+        description: 'The ID of the subscription invoice (e.g., "123456")',
+    },
+    // Subscription ID for Generate operation
+    {
+        displayName: 'Subscription ID',
+        name: 'generateSubscriptionId',
+        type: 'string',
+        required: true,
+        default: '',
+        displayOptions: {
+            show: {
+                resource: ['subscriptionInvoice'],
+                operation: ['generate'],
+            },
+        },
+        description: 'The ID of the subscription to generate an invoice for. Only works if the subscription has an outstanding balance.',
+    },
+    // Refund Options
+    {
+        displayName: 'Refund Amount',
+        name: 'refundAmount',
+        type: 'number',
+        required: false,
+        default: 0,
+        displayOptions: {
+            show: {
+                resource: ['subscriptionInvoice'],
+                operation: ['refund'],
             },
         },
-        description: 'The ID of the subscription invoice to retrieve',
+        description: 'Amount to refund in cents (e.g., 1000 = $10.00). Leave at 0 for full refund. Must not exceed the original invoice amount.',
+        typeOptions: {
+            minValue: 0,
+        },
     },
     // Get All
     {

package/dist/nodes/LemonSqueezy/resources/webhook.d.ts

@@ -1,3 +1,22 @@
+/**
+ * Webhook Resource
+ *
+ * Provides operations for managing webhooks in Lemon Squeezy.
+ * Webhooks allow your application to receive real-time notifications
+ * about events in your store.
+ *
+ * Available operations:
+ * - Create: Create a new webhook endpoint
+ * - Delete: Delete an existing webhook
+ * - Get: Retrieve a single webhook by ID
+ * - Get Many: Retrieve multiple webhooks with filtering
+ * - Update: Update webhook URL, events, or secret
+ *
+ * Security: Webhook secrets must be at least 32 characters.
+ * Generate one using: openssl rand -hex 32
+ *
+ * @see https://docs.lemonsqueezy.com/api/webhooks
+ */
 import type { INodeProperties } from 'n8n-workflow';
 export declare const webhookOperations: INodeProperties;
 export declare const webhookFields: INodeProperties[];

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

@@ -325,6 +325,22 @@ export interface LicenseKeyInstanceAttributes extends BaseAttributes {
     identifier: string;
     name: string;
 }
+/**
+ * File attributes
+ */
+export interface FileAttributes extends BaseAttributes {
+    variant_id: number;
+    identifier: string;
+    name: string;
+    extension: string;
+    download_url: string;
+    size: number;
+    size_formatted: string;
+    version: string;
+    sort: number;
+    status: 'draft' | 'published';
+    test_mode: boolean;
+}
 /**
  * Resource types
  */
@@ -339,6 +355,7 @@ export type Discount = JsonApiResource<'discounts', DiscountAttributes>;
 export type Checkout = JsonApiResource<'checkouts', CheckoutAttributes>;
 export type Webhook = JsonApiResource<'webhooks', WebhookAttributes>;
 export type LicenseKeyInstance = JsonApiResource<'license-key-instances', LicenseKeyInstanceAttributes>;
+export type File = JsonApiResource<'files', FileAttributes>;
 /**
  * Webhook event types
  */
@@ -413,7 +430,7 @@ export interface PaginationOptions {
 /**
  * Resource name to endpoint mapping
  */
-export type ResourceName = 'product' | 'order' | 'subscription' | 'customer' | 'licenseKey' | 'discount' | 'store' | 'variant' | 'checkout' | 'webhook' | 'licenseKeyInstance';
+export type ResourceName = 'product' | 'order' | 'subscription' | 'customer' | 'licenseKey' | 'discount' | 'store' | 'variant' | 'checkout' | 'webhook' | 'licenseKeyInstance' | 'file';
 /**
  * Operation types
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-lemonsqueezy",
-  "version": "0.7.2",
+  "version": "0.9.0",
   "description": "n8n community node for Lemon Squeezy - digital products and subscriptions platform",
   "keywords": [
     "n8n-community-node-package",