n8n-nodes-lemonsqueezy 0.2.0 → 0.4.0

package/README.md

@@ -2,6 +2,7 @@
 
 [![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)
+[![CI](https://github.com/janmaaarc/n8n-nodes-lemonsqueezy/actions/workflows/ci.yml/badge.svg)](https://github.com/janmaaarc/n8n-nodes-lemonsqueezy/actions/workflows/ci.yml)
 
 An [n8n](https://n8n.io/) community node for [Lemon Squeezy](https://lemonsqueezy.com) - a platform for selling digital products, subscriptions, and software licenses.
 
@@ -12,6 +13,8 @@ An [n8n](https://n8n.io/) community node for [Lemon Squeezy](https://lemonsqueez
 - **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
+- **Input Validation** - Email, URL, and date format validation
+- **Detailed Error Messages** - Descriptive error messages with field-level details
 - **Type Safety** - Full TypeScript support with comprehensive type definitions
 
 ## Installation
@@ -51,11 +54,17 @@ 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 Redemption** | Get, Get Many |
 | **License Key** | Get, Get Many, Update, Validate, Activate, Deactivate |
+| **License Key Instance** | Get, Get Many |
 | **Order** | Get, Get Many, Refund |
+| **Order Item** | Get, Get Many |
 | **Product** | Get, Get Many |
 | **Store** | Get, Get Many |
 | **Subscription** | Get, Get Many, Update, Cancel, Resume |
+| **Subscription Invoice** | Get, Get Many |
+| **Usage Record** | Get, Get Many |
+| **User** | Get Current |
 | **Variant** | Get, Get Many |
 | **Webhook** | Create, Update, Delete, Get, Get Many |
 
@@ -129,19 +138,36 @@ 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 |
+| `status` | Filter by status | Orders, Subscriptions, Customers, License Keys, Subscription Invoices |
 | `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 |
+| `productId` | Filter by product | Subscriptions, License Keys, Variants, Order Items |
+| `variantId` | Filter by variant | Subscriptions, Checkouts, Order Items |
+| `orderId` | Filter by order | Subscriptions, License Keys, Order Items, Discount Redemptions |
+| `subscriptionId` | Filter by subscription | Subscription Invoices |
+| `licenseKeyId` | Filter by license key | License Key Instances |
+| `discountId` | Filter by discount | Discount Redemptions |
 
 ## Error Handling
 
-The node includes built-in error handling:
+The node includes built-in error handling with detailed messages:
 
 - **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
+- **Detailed Errors**: Field-level error details for validation failures
+
+### Error Code Reference
+
+| Status Code | Description |
+|-------------|-------------|
+| 400 | Bad Request - Invalid or malformed request |
+| 401 | Unauthorized - Invalid or missing API key |
+| 403 | Forbidden - No permission to access resource |
+| 404 | Not Found - Resource does not exist |
+| 409 | Conflict - Resource already exists |
+| 422 | Unprocessable Entity - Invalid request data |
+| 429 | Rate Limited - Too many requests |
+| 500+ | Server Error - Something went wrong on the server |
 
 ## Troubleshooting
 
@@ -166,11 +192,28 @@ The node includes built-in error handling:
 
 ### Rate Limiting Issues
 
-The node handles rate limiting automatically, but if you're hitting limits frequently:
+The node handles rate limiting automatically with the following defaults:
+
+| Setting | Value | Description |
+|---------|-------|-------------|
+| Max Retries | 3 | Maximum retry attempts for failed requests |
+| Retry Delay | 1 second | Initial delay between retries (exponential backoff) |
+| Rate Limit Wait | 60 seconds | Wait time when rate limited (429 response) |
+
+If you're hitting rate limits frequently:
 
 1. Reduce the frequency of API calls
 2. Use "Return All" sparingly for large datasets
 3. Consider caching responses where appropriate
+4. Space out bulk operations with delays
+
+### Validation Errors
+
+If you receive validation errors:
+
+1. Check email fields contain valid email addresses
+2. Verify URLs are complete (including https://)
+3. Ensure dates are in ISO 8601 format (e.g., 2024-01-15T10:30:00Z)
 
 ## Development
 
@@ -184,11 +227,17 @@ npm run build
 # Run tests
 npm test
 
+# Run tests with coverage
+npm run test:coverage
+
 # Run linter
 npm run lint
 
 # Format code
 npm run format
+
+# Type check
+npm run typecheck
 ```
 
 ## Contributing
@@ -207,6 +256,32 @@ Contributions are welcome! Please feel free to submit a Pull Request.
 - [n8n Community Nodes Documentation](https://docs.n8n.io/integrations/community-nodes/)
 - [n8n Community Forum](https://community.n8n.io/)
 
+## Changelog
+
+### v0.4.0
+
+- Added User resource for fetching authenticated user information (`getCurrent` operation)
+- Expanded test suite to 130 tests with 85%+ statement coverage
+- Added comprehensive tests for credentials, node descriptions, and helpers
+- Fixed TypeScript strict mode warnings in test files
+- Updated coverage thresholds to 70%
+
+### v0.3.0
+
+- Added new resources: Order Items, Subscription Invoices, License Key Instances, Discount Redemptions, Usage Records
+- Added input validation for emails, URLs, and dates
+- Improved error messages with field-level details
+- Added advanced filtering with sorting support
+- Added relationship expansion helpers
+- Added security audit in CI pipeline
+- Added coverage reporting with lcov output
+
+### v0.2.0
+
+- Initial release with full Lemon Squeezy API support
+- Webhook trigger node
+- Rate limiting and retry logic
+
 ## License
 
 [MIT](LICENSE)

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

@@ -338,6 +338,9 @@ class LemonSqueezy {
                         });
                     }
                 }
+                else if (resource === 'user' && operation === 'getCurrent') {
+                    responseData = await helpers_1.lemonSqueezyApiRequest.call(this, 'GET', '/users/me');
+                }
                 const executionData = this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray(responseData), { itemData: { item: i } });
                 returnData.push(...executionData);
             }

package/dist/nodes/LemonSqueezy/constants.js

@@ -15,15 +15,20 @@ exports.RATE_LIMIT_DELAY_MS = 60000;
 exports.RESOURCE_ENDPOINTS = {
     product: 'products',
     order: 'orders',
+    orderItem: 'order-items',
     subscription: 'subscriptions',
+    subscriptionInvoice: 'subscription-invoices',
     customer: 'customers',
     licenseKey: 'license-keys',
+    licenseKeyInstance: 'license-key-instances',
     discount: 'discounts',
+    discountRedemption: 'discount-redemptions',
     store: 'stores',
     variant: 'variants',
     checkout: 'checkouts',
     webhook: 'webhooks',
-    licenseKeyInstance: 'license-key-instances',
+    usageRecord: 'usage-records',
+    user: 'users',
 };
 /**
  * Resource to ID parameter mapping
@@ -31,15 +36,19 @@ exports.RESOURCE_ENDPOINTS = {
 exports.RESOURCE_ID_PARAMS = {
     product: 'productId',
     order: 'orderId',
+    orderItem: 'orderItemId',
     subscription: 'subscriptionId',
+    subscriptionInvoice: 'subscriptionInvoiceId',
     customer: 'customerId',
     licenseKey: 'licenseKeyId',
+    licenseKeyInstance: 'licenseKeyInstanceId',
     discount: 'discountId',
+    discountRedemption: 'discountRedemptionId',
     store: 'storeId',
     variant: 'variantId',
     checkout: 'checkoutId',
     webhook: 'webhookId',
-    licenseKeyInstance: 'licenseKeyInstanceId',
+    usageRecord: 'usageRecordId',
 };
 /**
  * Webhook event types with descriptions

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

@@ -1,4 +1,28 @@
 import type { IExecuteFunctions, IWebhookFunctions, IHookFunctions, IHttpRequestMethods, IDataObject } from 'n8n-workflow';
+/**
+ * Validate email format
+ */
+export declare function isValidEmail(email: string): boolean;
+/**
+ * Validate URL format
+ */
+export declare function isValidUrl(url: string): boolean;
+/**
+ * Validate ISO 8601 date format
+ */
+export declare function isValidIsoDate(dateString: string): boolean;
+/**
+ * Validate that a value is a positive integer
+ */
+export declare function isPositiveInteger(value: unknown): boolean;
+/**
+ * Validate field with specific type and throw descriptive error
+ */
+export declare function validateField(fieldName: string, value: unknown, validationType: 'email' | 'url' | 'date' | 'positiveInteger' | 'required'): void;
+/**
+ * Safely parse JSON with error handling
+ */
+export declare function safeJsonParse<T = unknown>(jsonString: string, fieldName: string): T;
 /**
  * Make an authenticated request to the Lemon Squeezy API with retry logic
  */
@@ -26,3 +50,23 @@ export declare function buildJsonApiBody(type: string, attributes: IDataObject,
  * Parse webhook signature for validation
  */
 export declare function verifyWebhookSignature(payload: string, signature: string, secret: string): boolean;
+/**
+ * Build query params with relationship expansion (include)
+ */
+export declare function buildIncludeParams(includes: string[]): Record<string, string>;
+/**
+ * Build advanced filter params with date range support
+ */
+export declare function buildAdvancedFilterParams(filters: IDataObject, options?: {
+    dateFields?: string[];
+    sortField?: string;
+    sortDirection?: 'asc' | 'desc';
+}): Record<string, string | number>;
+/**
+ * Extract data from JSON:API response with proper typing
+ */
+export declare function extractResponseData<T = IDataObject>(response: IDataObject): T | T[] | undefined;
+/**
+ * Extract included resources from JSON:API response
+ */
+export declare function extractIncludedResources(response: IDataObject): IDataObject[];

package/dist/nodes/LemonSqueezy/helpers.js

@@ -33,15 +33,108 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidEmail = isValidEmail;
+exports.isValidUrl = isValidUrl;
+exports.isValidIsoDate = isValidIsoDate;
+exports.isPositiveInteger = isPositiveInteger;
+exports.validateField = validateField;
+exports.safeJsonParse = safeJsonParse;
 exports.lemonSqueezyApiRequest = lemonSqueezyApiRequest;
 exports.lemonSqueezyApiRequestAllItems = lemonSqueezyApiRequestAllItems;
 exports.validateRequiredFields = validateRequiredFields;
 exports.buildFilterParams = buildFilterParams;
 exports.buildJsonApiBody = buildJsonApiBody;
 exports.verifyWebhookSignature = verifyWebhookSignature;
+exports.buildIncludeParams = buildIncludeParams;
+exports.buildAdvancedFilterParams = buildAdvancedFilterParams;
+exports.extractResponseData = extractResponseData;
+exports.extractIncludedResources = extractIncludedResources;
 const crypto = __importStar(require("crypto"));
 const n8n_workflow_1 = require("n8n-workflow");
 const constants_1 = require("./constants");
+// ============================================================================
+// Validation Helpers
+// ============================================================================
+/**
+ * Validate email format
+ */
+function isValidEmail(email) {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return emailRegex.test(email);
+}
+/**
+ * Validate URL format
+ */
+function isValidUrl(url) {
+    try {
+        new URL(url);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Validate ISO 8601 date format
+ */
+function isValidIsoDate(dateString) {
+    const date = new Date(dateString);
+    return !isNaN(date.getTime()) && dateString.includes('-');
+}
+/**
+ * Validate that a value is a positive integer
+ */
+function isPositiveInteger(value) {
+    return typeof value === 'number' && Number.isInteger(value) && value > 0;
+}
+/**
+ * Validate field with specific type and throw descriptive error
+ */
+function validateField(fieldName, value, validationType) {
+    if (validationType === 'required') {
+        if (value === undefined || value === null || value === '') {
+            throw new Error(`${fieldName} is required`);
+        }
+        return;
+    }
+    // Skip validation if value is empty (use 'required' for mandatory fields)
+    if (value === undefined || value === null || value === '') {
+        return;
+    }
+    switch (validationType) {
+        case 'email':
+            if (typeof value !== 'string' || !isValidEmail(value)) {
+                throw new Error(`${fieldName} must be a valid email address`);
+            }
+            break;
+        case 'url':
+            if (typeof value !== 'string' || !isValidUrl(value)) {
+                throw new Error(`${fieldName} must be a valid URL`);
+            }
+            break;
+        case 'date':
+            if (typeof value !== 'string' || !isValidIsoDate(value)) {
+                throw new Error(`${fieldName} must be a valid ISO 8601 date`);
+            }
+            break;
+        case 'positiveInteger':
+            if (!isPositiveInteger(value)) {
+                throw new Error(`${fieldName} must be a positive integer`);
+            }
+            break;
+    }
+}
+/**
+ * Safely parse JSON with error handling
+ */
+function safeJsonParse(jsonString, fieldName) {
+    try {
+        return JSON.parse(jsonString);
+    }
+    catch {
+        throw new Error(`${fieldName} contains invalid JSON`);
+    }
+}
 /**
  * Sleep for a specified number of milliseconds
  */
@@ -151,20 +244,48 @@ async function lemonSqueezyApiRequestAllItems(method, endpoint, qs = {}) {
     return returnData;
 }
 /**
- * Extract error message from error object
+ * Lemon Squeezy API error codes and their meanings
+ */
+const ERROR_MESSAGES = {
+    400: 'Bad Request: The request was invalid or malformed',
+    401: 'Unauthorized: Invalid or missing API key',
+    403: 'Forbidden: You do not have permission to access this resource',
+    404: 'Not Found: The requested resource does not exist',
+    409: 'Conflict: The resource already exists or there is a conflict',
+    422: 'Unprocessable Entity: The request data is invalid',
+    429: 'Rate Limited: Too many requests. Please wait before retrying',
+    500: 'Internal Server Error: Something went wrong on the server',
+    502: 'Bad Gateway: The server is temporarily unavailable',
+    503: 'Service Unavailable: The API is temporarily unavailable',
+};
+/**
+ * Extract detailed error message from error object
  */
 function getErrorMessage(error) {
     var _a, _b, _c, _d, _e;
     if (error && typeof error === 'object') {
         const err = error;
+        const statusCode = err.statusCode || ((_a = err.response) === null || _a === void 0 ? void 0 : _a.statusCode);
         // Check for JSON:API error format
-        if ((_c = (_b = (_a = err.response) === null || _a === void 0 ? void 0 : _a.body) === null || _b === void 0 ? void 0 : _b.errors) === null || _c === void 0 ? void 0 : _c[0]) {
-            const apiError = err.response.body.errors[0];
-            return apiError.detail || apiError.title || 'Unknown API error';
+        if (((_c = (_b = err.response) === null || _b === void 0 ? void 0 : _b.body) === null || _c === void 0 ? void 0 : _c.errors) && err.response.body.errors.length > 0) {
+            const apiErrors = err.response.body.errors;
+            const errorMessages = apiErrors.map((e) => {
+                var _a;
+                let msg = e.detail || e.title || 'Unknown error';
+                if ((_a = e.source) === null || _a === void 0 ? void 0 : _a.pointer) {
+                    msg += ` (field: ${e.source.pointer.replace('/data/attributes/', '')})`;
+                }
+                return msg;
+            });
+            return errorMessages.join('; ');
         }
         if ((_e = (_d = err.response) === null || _d === void 0 ? void 0 : _d.body) === null || _e === void 0 ? void 0 : _e.message) {
             return err.response.body.message;
         }
+        // Use status code mapping
+        if (statusCode && ERROR_MESSAGES[statusCode]) {
+            return ERROR_MESSAGES[statusCode];
+        }
         if (err.message) {
             return err.message;
         }
@@ -239,3 +360,72 @@ function verifyWebhookSignature(payload, signature, secret) {
         return false;
     }
 }
+// ============================================================================
+// Advanced Query Helpers
+// ============================================================================
+/**
+ * Build query params with relationship expansion (include)
+ */
+function buildIncludeParams(includes) {
+    if (includes.length === 0) {
+        return {};
+    }
+    return { include: includes.join(',') };
+}
+/**
+ * Build advanced filter params with date range support
+ */
+function buildAdvancedFilterParams(filters, options) {
+    var _a;
+    const qs = {};
+    for (const [key, value] of Object.entries(filters)) {
+        if (value === undefined || value === null || value === '') {
+            continue;
+        }
+        // Convert camelCase to snake_case for API
+        const snakeKey = key.replace(/([A-Z])/g, '_$1').toLowerCase();
+        // Handle date range filters
+        if ((_a = options === null || options === void 0 ? void 0 : options.dateFields) === null || _a === void 0 ? void 0 : _a.includes(key)) {
+            if (typeof value === 'object' && value !== null) {
+                const dateRange = value;
+                if (dateRange.from) {
+                    qs[`filter[${snakeKey}_after]`] = dateRange.from;
+                }
+                if (dateRange.to) {
+                    qs[`filter[${snakeKey}_before]`] = dateRange.to;
+                }
+            }
+            else {
+                qs[`filter[${snakeKey}]`] = value;
+            }
+        }
+        else {
+            qs[`filter[${snakeKey}]`] = value;
+        }
+    }
+    // Add sorting
+    if (options === null || options === void 0 ? void 0 : options.sortField) {
+        const sortPrefix = options.sortDirection === 'desc' ? '-' : '';
+        const snakeSortField = options.sortField.replace(/([A-Z])/g, '_$1').toLowerCase();
+        qs.sort = `${sortPrefix}${snakeSortField}`;
+    }
+    return qs;
+}
+/**
+ * Extract data from JSON:API response with proper typing
+ */
+function extractResponseData(response) {
+    if (!response || typeof response !== 'object') {
+        return undefined;
+    }
+    return response.data;
+}
+/**
+ * Extract included resources from JSON:API response
+ */
+function extractIncludedResources(response) {
+    if (!response || typeof response !== 'object') {
+        return [];
+    }
+    return response.included || [];
+}

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

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

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

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discountRedemptionFields = exports.discountRedemptionOperations = void 0;
+exports.discountRedemptionOperations = [
+    {
+        displayName: 'Operation',
+        name: 'operation',
+        type: 'options',
+        noDataExpression: true,
+        displayOptions: {
+            show: {
+                resource: ['discountRedemption'],
+            },
+        },
+        options: [
+            {
+                name: 'Get',
+                value: 'get',
+                description: 'Get a discount redemption by ID',
+                action: 'Get a discount redemption',
+            },
+            {
+                name: 'Get Many',
+                value: 'getAll',
+                description: 'Get many discount redemptions',
+                action: 'Get many discount redemptions',
+            },
+        ],
+        default: 'getAll',
+    },
+];
+exports.discountRedemptionFields = [
+    // Get
+    {
+        displayName: 'Discount Redemption ID',
+        name: 'discountRedemptionId',
+        type: 'string',
+        required: true,
+        default: '',
+        displayOptions: {
+            show: {
+                resource: ['discountRedemption'],
+                operation: ['get'],
+            },
+        },
+        description: 'The ID of the discount redemption to retrieve',
+    },
+    // Get All
+    {
+        displayName: 'Return All',
+        name: 'returnAll',
+        type: 'boolean',
+        default: false,
+        displayOptions: {
+            show: {
+                resource: ['discountRedemption'],
+                operation: ['getAll'],
+            },
+        },
+        description: 'Whether to return all results or only up to a given limit',
+    },
+    {
+        displayName: 'Limit',
+        name: 'limit',
+        type: 'number',
+        default: 50,
+        typeOptions: {
+            minValue: 1,
+            maxValue: 100,
+        },
+        displayOptions: {
+            show: {
+                resource: ['discountRedemption'],
+                operation: ['getAll'],
+                returnAll: [false],
+            },
+        },
+        description: 'Max number of results to return',
+    },
+    {
+        displayName: 'Filters',
+        name: 'filters',
+        type: 'collection',
+        placeholder: 'Add Filter',
+        default: {},
+        displayOptions: {
+            show: {
+                resource: ['discountRedemption'],
+                operation: ['getAll'],
+            },
+        },
+        options: [
+            {
+                displayName: 'Discount ID',
+                name: 'discountId',
+                type: 'string',
+                default: '',
+                description: 'Filter by discount ID',
+            },
+            {
+                displayName: 'Order ID',
+                name: 'orderId',
+                type: 'string',
+                default: '',
+                description: 'Filter by order ID',
+            },
+        ],
+    },
+];

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

@@ -1,15 +1,21 @@
 import type { INodeProperties } from 'n8n-workflow';
 import { productOperations, productFields } from './product';
 import { orderOperations, orderFields } from './order';
+import { orderItemOperations, orderItemFields } from './orderItem';
 import { subscriptionOperations, subscriptionFields } from './subscription';
+import { subscriptionInvoiceOperations, subscriptionInvoiceFields } from './subscriptionInvoice';
 import { customerOperations, customerFields } from './customer';
 import { licenseKeyOperations, licenseKeyFields } from './licenseKey';
+import { licenseKeyInstanceOperations, licenseKeyInstanceFields } from './licenseKeyInstance';
 import { discountOperations, discountFields } from './discount';
+import { discountRedemptionOperations, discountRedemptionFields } from './discountRedemption';
 import { storeOperations, storeFields } from './store';
 import { variantOperations, variantFields } from './variant';
 import { checkoutOperations, checkoutFields } from './checkout';
 import { webhookOperations, webhookFields } from './webhook';
+import { usageRecordOperations, usageRecordFields } from './usageRecord';
+import { userOperations, userFields } from './user';
 export declare const resourceProperty: INodeProperties;
 export declare const allOperations: INodeProperties[];
 export declare const allFields: INodeProperties[];
-export { productOperations, productFields, orderOperations, orderFields, subscriptionOperations, subscriptionFields, customerOperations, customerFields, licenseKeyOperations, licenseKeyFields, discountOperations, discountFields, storeOperations, storeFields, variantOperations, variantFields, checkoutOperations, checkoutFields, webhookOperations, webhookFields, };
+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, };

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

@@ -1,24 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.webhookFields = exports.webhookOperations = exports.checkoutFields = exports.checkoutOperations = exports.variantFields = exports.variantOperations = exports.storeFields = exports.storeOperations = exports.discountFields = exports.discountOperations = exports.licenseKeyFields = exports.licenseKeyOperations = exports.customerFields = exports.customerOperations = exports.subscriptionFields = exports.subscriptionOperations = exports.orderFields = exports.orderOperations = exports.productFields = exports.productOperations = exports.allFields = exports.allOperations = exports.resourceProperty = void 0;
+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; } });
 const order_1 = require("./order");
 Object.defineProperty(exports, "orderOperations", { enumerable: true, get: function () { return order_1.orderOperations; } });
 Object.defineProperty(exports, "orderFields", { enumerable: true, get: function () { return order_1.orderFields; } });
+const orderItem_1 = require("./orderItem");
+Object.defineProperty(exports, "orderItemOperations", { enumerable: true, get: function () { return orderItem_1.orderItemOperations; } });
+Object.defineProperty(exports, "orderItemFields", { enumerable: true, get: function () { return orderItem_1.orderItemFields; } });
 const subscription_1 = require("./subscription");
 Object.defineProperty(exports, "subscriptionOperations", { enumerable: true, get: function () { return subscription_1.subscriptionOperations; } });
 Object.defineProperty(exports, "subscriptionFields", { enumerable: true, get: function () { return subscription_1.subscriptionFields; } });
+const subscriptionInvoice_1 = require("./subscriptionInvoice");
+Object.defineProperty(exports, "subscriptionInvoiceOperations", { enumerable: true, get: function () { return subscriptionInvoice_1.subscriptionInvoiceOperations; } });
+Object.defineProperty(exports, "subscriptionInvoiceFields", { enumerable: true, get: function () { return subscriptionInvoice_1.subscriptionInvoiceFields; } });
 const customer_1 = require("./customer");
 Object.defineProperty(exports, "customerOperations", { enumerable: true, get: function () { return customer_1.customerOperations; } });
 Object.defineProperty(exports, "customerFields", { enumerable: true, get: function () { return customer_1.customerFields; } });
 const licenseKey_1 = require("./licenseKey");
 Object.defineProperty(exports, "licenseKeyOperations", { enumerable: true, get: function () { return licenseKey_1.licenseKeyOperations; } });
 Object.defineProperty(exports, "licenseKeyFields", { enumerable: true, get: function () { return licenseKey_1.licenseKeyFields; } });
+const licenseKeyInstance_1 = require("./licenseKeyInstance");
+Object.defineProperty(exports, "licenseKeyInstanceOperations", { enumerable: true, get: function () { return licenseKeyInstance_1.licenseKeyInstanceOperations; } });
+Object.defineProperty(exports, "licenseKeyInstanceFields", { enumerable: true, get: function () { return licenseKeyInstance_1.licenseKeyInstanceFields; } });
 const discount_1 = require("./discount");
 Object.defineProperty(exports, "discountOperations", { enumerable: true, get: function () { return discount_1.discountOperations; } });
 Object.defineProperty(exports, "discountFields", { enumerable: true, get: function () { return discount_1.discountFields; } });
+const discountRedemption_1 = require("./discountRedemption");
+Object.defineProperty(exports, "discountRedemptionOperations", { enumerable: true, get: function () { return discountRedemption_1.discountRedemptionOperations; } });
+Object.defineProperty(exports, "discountRedemptionFields", { enumerable: true, get: function () { return discountRedemption_1.discountRedemptionFields; } });
 const store_1 = require("./store");
 Object.defineProperty(exports, "storeOperations", { enumerable: true, get: function () { return store_1.storeOperations; } });
 Object.defineProperty(exports, "storeFields", { enumerable: true, get: function () { return store_1.storeFields; } });
@@ -31,6 +43,12 @@ Object.defineProperty(exports, "checkoutFields", { enumerable: true, get: functi
 const webhook_1 = require("./webhook");
 Object.defineProperty(exports, "webhookOperations", { enumerable: true, get: function () { return webhook_1.webhookOperations; } });
 Object.defineProperty(exports, "webhookFields", { enumerable: true, get: function () { return webhook_1.webhookFields; } });
+const usageRecord_1 = require("./usageRecord");
+Object.defineProperty(exports, "usageRecordOperations", { enumerable: true, get: function () { return usageRecord_1.usageRecordOperations; } });
+Object.defineProperty(exports, "usageRecordFields", { enumerable: true, get: function () { return usageRecord_1.usageRecordFields; } });
+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; } });
 exports.resourceProperty = {
     displayName: 'Resource',
     name: 'resource',
@@ -40,11 +58,17 @@ exports.resourceProperty = {
         { name: 'Checkout', value: 'checkout' },
         { name: 'Customer', value: 'customer' },
         { name: 'Discount', value: 'discount' },
+        { name: 'Discount Redemption', value: 'discountRedemption' },
         { name: 'License Key', value: 'licenseKey' },
+        { name: 'License Key Instance', value: 'licenseKeyInstance' },
         { name: 'Order', value: 'order' },
+        { name: 'Order Item', value: 'orderItem' },
         { name: 'Product', value: 'product' },
         { name: 'Store', value: 'store' },
         { name: 'Subscription', value: 'subscription' },
+        { name: 'Subscription Invoice', value: 'subscriptionInvoice' },
+        { name: 'Usage Record', value: 'usageRecord' },
+        { name: 'User', value: 'user' },
         { name: 'Variant', value: 'variant' },
         { name: 'Webhook', value: 'webhook' },
     ],
@@ -53,24 +77,36 @@ exports.resourceProperty = {
 exports.allOperations = [
     product_1.productOperations,
     order_1.orderOperations,
+    ...orderItem_1.orderItemOperations,
     subscription_1.subscriptionOperations,
+    ...subscriptionInvoice_1.subscriptionInvoiceOperations,
     customer_1.customerOperations,
     licenseKey_1.licenseKeyOperations,
+    ...licenseKeyInstance_1.licenseKeyInstanceOperations,
     discount_1.discountOperations,
+    ...discountRedemption_1.discountRedemptionOperations,
     store_1.storeOperations,
     variant_1.variantOperations,
     checkout_1.checkoutOperations,
     webhook_1.webhookOperations,
+    ...usageRecord_1.usageRecordOperations,
+    ...user_1.userOperations,
 ];
 exports.allFields = [
     ...product_1.productFields,
     ...order_1.orderFields,
+    ...orderItem_1.orderItemFields,
     ...subscription_1.subscriptionFields,
+    ...subscriptionInvoice_1.subscriptionInvoiceFields,
     ...customer_1.customerFields,
     ...licenseKey_1.licenseKeyFields,
+    ...licenseKeyInstance_1.licenseKeyInstanceFields,
     ...discount_1.discountFields,
+    ...discountRedemption_1.discountRedemptionFields,
     ...store_1.storeFields,
     ...variant_1.variantFields,
     ...checkout_1.checkoutFields,
     ...webhook_1.webhookFields,
+    ...usageRecord_1.usageRecordFields,
+    ...user_1.userFields,
 ];

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

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

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

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.licenseKeyInstanceFields = exports.licenseKeyInstanceOperations = void 0;
+exports.licenseKeyInstanceOperations = [
+    {
+        displayName: 'Operation',
+        name: 'operation',
+        type: 'options',
+        noDataExpression: true,
+        displayOptions: {
+            show: {
+                resource: ['licenseKeyInstance'],
+            },
+        },
+        options: [
+            {
+                name: 'Get',
+                value: 'get',
+                description: 'Get a license key instance by ID',
+                action: 'Get a license key instance',
+            },
+            {
+                name: 'Get Many',
+                value: 'getAll',
+                description: 'Get many license key instances',
+                action: 'Get many license key instances',
+            },
+        ],
+        default: 'getAll',
+    },
+];
+exports.licenseKeyInstanceFields = [
+    // Get
+    {
+        displayName: 'License Key Instance ID',
+        name: 'licenseKeyInstanceId',
+        type: 'string',
+        required: true,
+        default: '',
+        displayOptions: {
+            show: {
+                resource: ['licenseKeyInstance'],
+                operation: ['get'],
+            },
+        },
+        description: 'The ID of the license key instance to retrieve',
+    },
+    // Get All
+    {
+        displayName: 'Return All',
+        name: 'returnAll',
+        type: 'boolean',
+        default: false,
+        displayOptions: {
+            show: {
+                resource: ['licenseKeyInstance'],
+                operation: ['getAll'],
+            },
+        },
+        description: 'Whether to return all results or only up to a given limit',
+    },
+    {
+        displayName: 'Limit',
+        name: 'limit',
+        type: 'number',
+        default: 50,
+        typeOptions: {
+            minValue: 1,
+            maxValue: 100,
+        },
+        displayOptions: {
+            show: {
+                resource: ['licenseKeyInstance'],
+                operation: ['getAll'],
+                returnAll: [false],
+            },
+        },
+        description: 'Max number of results to return',
+    },
+    {
+        displayName: 'Filters',
+        name: 'filters',
+        type: 'collection',
+        placeholder: 'Add Filter',
+        default: {},
+        displayOptions: {
+            show: {
+                resource: ['licenseKeyInstance'],
+                operation: ['getAll'],
+            },
+        },
+        options: [
+            {
+                displayName: 'License Key ID',
+                name: 'licenseKeyId',
+                type: 'string',
+                default: '',
+                description: 'Filter by license key ID',
+            },
+        ],
+    },
+];

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

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

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

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.orderItemFields = exports.orderItemOperations = void 0;
+exports.orderItemOperations = [
+    {
+        displayName: 'Operation',
+        name: 'operation',
+        type: 'options',
+        noDataExpression: true,
+        displayOptions: {
+            show: {
+                resource: ['orderItem'],
+            },
+        },
+        options: [
+            {
+                name: 'Get',
+                value: 'get',
+                description: 'Get an order item by ID',
+                action: 'Get an order item',
+            },
+            {
+                name: 'Get Many',
+                value: 'getAll',
+                description: 'Get many order items',
+                action: 'Get many order items',
+            },
+        ],
+        default: 'getAll',
+    },
+];
+exports.orderItemFields = [
+    // Get
+    {
+        displayName: 'Order Item ID',
+        name: 'orderItemId',
+        type: 'string',
+        required: true,
+        default: '',
+        displayOptions: {
+            show: {
+                resource: ['orderItem'],
+                operation: ['get'],
+            },
+        },
+        description: 'The ID of the order item to retrieve',
+    },
+    // Get All
+    {
+        displayName: 'Return All',
+        name: 'returnAll',
+        type: 'boolean',
+        default: false,
+        displayOptions: {
+            show: {
+                resource: ['orderItem'],
+                operation: ['getAll'],
+            },
+        },
+        description: 'Whether to return all results or only up to a given limit',
+    },
+    {
+        displayName: 'Limit',
+        name: 'limit',
+        type: 'number',
+        default: 50,
+        typeOptions: {
+            minValue: 1,
+            maxValue: 100,
+        },
+        displayOptions: {
+            show: {
+                resource: ['orderItem'],
+                operation: ['getAll'],
+                returnAll: [false],
+            },
+        },
+        description: 'Max number of results to return',
+    },
+    {
+        displayName: 'Filters',
+        name: 'filters',
+        type: 'collection',
+        placeholder: 'Add Filter',
+        default: {},
+        displayOptions: {
+            show: {
+                resource: ['orderItem'],
+                operation: ['getAll'],
+            },
+        },
+        options: [
+            {
+                displayName: 'Order ID',
+                name: 'orderId',
+                type: 'string',
+                default: '',
+                description: 'Filter by order ID',
+            },
+            {
+                displayName: 'Product ID',
+                name: 'productId',
+                type: 'string',
+                default: '',
+                description: 'Filter by product ID',
+            },
+            {
+                displayName: 'Variant ID',
+                name: 'variantId',
+                type: 'string',
+                default: '',
+                description: 'Filter by variant ID',
+            },
+        ],
+    },
+];

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

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

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

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subscriptionInvoiceFields = exports.subscriptionInvoiceOperations = void 0;
+exports.subscriptionInvoiceOperations = [
+    {
+        displayName: 'Operation',
+        name: 'operation',
+        type: 'options',
+        noDataExpression: true,
+        displayOptions: {
+            show: {
+                resource: ['subscriptionInvoice'],
+            },
+        },
+        options: [
+            {
+                name: 'Get',
+                value: 'get',
+                description: 'Get a subscription invoice by ID',
+                action: 'Get a subscription invoice',
+            },
+            {
+                name: 'Get Many',
+                value: 'getAll',
+                description: 'Get many subscription invoices',
+                action: 'Get many subscription invoices',
+            },
+        ],
+        default: 'getAll',
+    },
+];
+exports.subscriptionInvoiceFields = [
+    // Get
+    {
+        displayName: 'Subscription Invoice ID',
+        name: 'subscriptionInvoiceId',
+        type: 'string',
+        required: true,
+        default: '',
+        displayOptions: {
+            show: {
+                resource: ['subscriptionInvoice'],
+                operation: ['get'],
+            },
+        },
+        description: 'The ID of the subscription invoice to retrieve',
+    },
+    // Get All
+    {
+        displayName: 'Return All',
+        name: 'returnAll',
+        type: 'boolean',
+        default: false,
+        displayOptions: {
+            show: {
+                resource: ['subscriptionInvoice'],
+                operation: ['getAll'],
+            },
+        },
+        description: 'Whether to return all results or only up to a given limit',
+    },
+    {
+        displayName: 'Limit',
+        name: 'limit',
+        type: 'number',
+        default: 50,
+        typeOptions: {
+            minValue: 1,
+            maxValue: 100,
+        },
+        displayOptions: {
+            show: {
+                resource: ['subscriptionInvoice'],
+                operation: ['getAll'],
+                returnAll: [false],
+            },
+        },
+        description: 'Max number of results to return',
+    },
+    {
+        displayName: 'Filters',
+        name: 'filters',
+        type: 'collection',
+        placeholder: 'Add Filter',
+        default: {},
+        displayOptions: {
+            show: {
+                resource: ['subscriptionInvoice'],
+                operation: ['getAll'],
+            },
+        },
+        options: [
+            {
+                displayName: 'Store ID',
+                name: 'storeId',
+                type: 'string',
+                default: '',
+                description: 'Filter by store ID',
+            },
+            {
+                displayName: 'Subscription ID',
+                name: 'subscriptionId',
+                type: 'string',
+                default: '',
+                description: 'Filter by subscription ID',
+            },
+            {
+                displayName: 'Status',
+                name: 'status',
+                type: 'options',
+                default: '',
+                options: [
+                    { name: 'Pending', value: 'pending' },
+                    { name: 'Paid', value: 'paid' },
+                    { name: 'Void', value: 'void' },
+                    { name: 'Refunded', value: 'refunded' },
+                ],
+                description: 'Filter by invoice status',
+            },
+            {
+                displayName: 'Refunded',
+                name: 'refunded',
+                type: 'boolean',
+                default: false,
+                description: 'Whether to filter by refunded invoices',
+            },
+        ],
+    },
+];

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

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

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

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usageRecordFields = exports.usageRecordOperations = void 0;
+exports.usageRecordOperations = [
+    {
+        displayName: 'Operation',
+        name: 'operation',
+        type: 'options',
+        noDataExpression: true,
+        displayOptions: {
+            show: {
+                resource: ['usageRecord'],
+            },
+        },
+        options: [
+            {
+                name: 'Get',
+                value: 'get',
+                description: 'Get a usage record by ID',
+                action: 'Get a usage record',
+            },
+            {
+                name: 'Get Many',
+                value: 'getAll',
+                description: 'Get many usage records',
+                action: 'Get many usage records',
+            },
+        ],
+        default: 'getAll',
+    },
+];
+exports.usageRecordFields = [
+    // Get
+    {
+        displayName: 'Usage Record ID',
+        name: 'usageRecordId',
+        type: 'string',
+        required: true,
+        default: '',
+        displayOptions: {
+            show: {
+                resource: ['usageRecord'],
+                operation: ['get'],
+            },
+        },
+        description: 'The ID of the usage record to retrieve',
+    },
+    // Get All
+    {
+        displayName: 'Return All',
+        name: 'returnAll',
+        type: 'boolean',
+        default: false,
+        displayOptions: {
+            show: {
+                resource: ['usageRecord'],
+                operation: ['getAll'],
+            },
+        },
+        description: 'Whether to return all results or only up to a given limit',
+    },
+    {
+        displayName: 'Limit',
+        name: 'limit',
+        type: 'number',
+        default: 50,
+        typeOptions: {
+            minValue: 1,
+            maxValue: 100,
+        },
+        displayOptions: {
+            show: {
+                resource: ['usageRecord'],
+                operation: ['getAll'],
+                returnAll: [false],
+            },
+        },
+        description: 'Max number of results to return',
+    },
+    {
+        displayName: 'Filters',
+        name: 'filters',
+        type: 'collection',
+        placeholder: 'Add Filter',
+        default: {},
+        displayOptions: {
+            show: {
+                resource: ['usageRecord'],
+                operation: ['getAll'],
+            },
+        },
+        options: [
+            {
+                displayName: 'Subscription Item ID',
+                name: 'subscriptionItemId',
+                type: 'string',
+                default: '',
+                description: 'Filter by subscription item ID',
+            },
+        ],
+    },
+];

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

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

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.userFields = exports.userOperations = void 0;
+exports.userOperations = [
+    {
+        displayName: 'Operation',
+        name: 'operation',
+        type: 'options',
+        noDataExpression: true,
+        displayOptions: {
+            show: {
+                resource: ['user'],
+            },
+        },
+        options: [
+            {
+                name: 'Get Current',
+                value: 'getCurrent',
+                description: 'Get the currently authenticated user',
+                action: 'Get current user',
+            },
+        ],
+        default: 'getCurrent',
+    },
+];
+exports.userFields = [];

package/package.json

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