n8n-nodes-lemonsqueezy 0.2.0 → 0.5.0

package/dist/nodes/LemonSqueezy/helpers.js

@@ -1,4 +1,16 @@
 "use strict";
+/**
+ * Lemon Squeezy API Helper Functions
+ *
+ * This module provides utility functions for:
+ * - Input validation (email, URL, date, etc.)
+ * - API request handling with retry logic
+ * - Webhook signature verification
+ * - JSON:API body construction
+ * - Query parameter building
+ *
+ * @module helpers
+ */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -33,23 +45,257 @@ 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.sleep = sleep;
+exports.isRateLimitError = isRateLimitError;
+exports.isRetryableError = isRetryableError;
 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
+// ============================================================================
+/**
+ * Validates email format using RFC 5322 compliant regex.
+ *
+ * The validation checks for:
+ * - Valid local part characters (alphanumeric and special chars)
+ * - Single @ symbol
+ * - Valid domain with proper TLD (at least one dot)
+ *
+ * @param email - The email address to validate
+ * @returns True if the email format is valid, false otherwise
+ *
+ * @example
+ * isValidEmail('user@example.com') // true
+ * isValidEmail('invalid') // false
+ * isValidEmail('user@localhost') // false (no TLD)
+ */
+function isValidEmail(email) {
+    const emailRegex = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+$/;
+    return emailRegex.test(email);
+}
+/**
+ * Validates URL format and ensures it's a safe external URL.
+ *
+ * Security features:
+ * - Only allows http:// and https:// protocols
+ * - Blocks localhost and loopback addresses (127.0.0.1, ::1, [::1])
+ * - Blocks private network ranges (10.x, 172.16-31.x, 192.168.x)
+ * - Blocks link-local addresses (169.254.x - AWS metadata endpoint)
+ *
+ * This prevents Server-Side Request Forgery (SSRF) attacks.
+ *
+ * @param url - The URL to validate
+ * @returns True if the URL is valid and safe, false otherwise
+ *
+ * @example
+ * isValidUrl('https://example.com') // true
+ * isValidUrl('http://localhost:3000') // false (internal)
+ * isValidUrl('ftp://files.example.com') // false (non-http protocol)
+ * isValidUrl('http://169.254.169.254') // false (AWS metadata)
+ */
+function isValidUrl(url) {
+    try {
+        const parsedUrl = new URL(url);
+        // Only allow http and https protocols (security: prevent file://, javascript:, etc.)
+        if (!['http:', 'https:'].includes(parsedUrl.protocol)) {
+            return false;
+        }
+        // Block internal/private network URLs for SSRF protection
+        const hostname = parsedUrl.hostname.toLowerCase();
+        const blockedPatterns = [
+            'localhost', // Loopback hostname
+            '127.0.0.1', // IPv4 loopback
+            '0.0.0.0', // All interfaces
+            '::1', // IPv6 loopback
+            '[::1]', // IPv6 loopback (bracketed form)
+            '10.', // Private Class A (10.0.0.0/8)
+            '172.16.', // Private Class B start (172.16.0.0/12)
+            '172.17.',
+            '172.18.',
+            '172.19.',
+            '172.20.',
+            '172.21.',
+            '172.22.',
+            '172.23.',
+            '172.24.',
+            '172.25.',
+            '172.26.',
+            '172.27.',
+            '172.28.',
+            '172.29.',
+            '172.30.',
+            '172.31.', // Private Class B end
+            '192.168.', // Private Class C (192.168.0.0/16)
+            '169.254.', // Link-local / APIPA (includes AWS metadata endpoint)
+        ];
+        for (const pattern of blockedPatterns) {
+            if (hostname === pattern || hostname.startsWith(pattern)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    catch {
+        // URL parsing failed - invalid URL
+        return false;
+    }
+}
+/**
+ * Validates ISO 8601 date format.
+ *
+ * Accepts dates in formats like:
+ * - 2024-01-15
+ * - 2024-01-15T10:30:00Z
+ * - 2024-01-15T10:30:00.000Z
+ *
+ * @param dateString - The date string to validate
+ * @returns True if the date is valid ISO 8601 format, false otherwise
+ *
+ * @example
+ * isValidIsoDate('2024-01-15T10:30:00Z') // true
+ * isValidIsoDate('invalid') // false
+ * isValidIsoDate('01/15/2024') // false (no dash separator)
+ */
+function isValidIsoDate(dateString) {
+    const date = new Date(dateString);
+    return !isNaN(date.getTime()) && dateString.includes('-');
+}
 /**
- * Sleep for a specified number of milliseconds
+ * Validates that a value is a positive integer (greater than 0).
+ *
+ * @param value - The value to validate
+ * @returns True if the value is a positive integer, false otherwise
+ *
+ * @example
+ * isPositiveInteger(5) // true
+ * isPositiveInteger(0) // false
+ * isPositiveInteger(-1) // false
+ * isPositiveInteger(3.14) // false
+ * isPositiveInteger('5') // false (string, not number)
+ */
+function isPositiveInteger(value) {
+    return typeof value === 'number' && Number.isInteger(value) && value > 0;
+}
+/**
+ * Validates a field value and throws a descriptive error if invalid.
+ *
+ * Supports multiple validation types:
+ * - 'required': Ensures value is not empty/null/undefined
+ * - 'email': RFC 5322 compliant email validation
+ * - 'url': Safe URL validation with SSRF protection
+ * - 'date': ISO 8601 date format validation
+ * - 'positiveInteger': Positive integer validation
+ *
+ * @param fieldName - The name of the field (used in error messages)
+ * @param value - The value to validate
+ * @param validationType - The type of validation to perform
+ * @throws Error with descriptive message if validation fails
+ *
+ * @example
+ * validateField('email', 'user@example.com', 'email') // passes
+ * validateField('email', 'invalid', 'email') // throws "email must be a valid email address"
+ */
+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 parses a JSON string with descriptive error handling.
+ *
+ * @template T - The expected type of the parsed JSON
+ * @param jsonString - The JSON string to parse
+ * @param fieldName - The name of the field (used in error messages)
+ * @returns The parsed JSON object
+ * @throws Error if the JSON is invalid
+ *
+ * @example
+ * const data = safeJsonParse<{name: string}>('{"name": "test"}', 'config')
+ * // Returns: {name: "test"}
+ *
+ * safeJsonParse('invalid json', 'config')
+ * // Throws: "config contains invalid JSON"
+ */
+function safeJsonParse(jsonString, fieldName) {
+    try {
+        return JSON.parse(jsonString);
+    }
+    catch {
+        throw new Error(`${fieldName} contains invalid JSON`);
+    }
+}
+/**
+ * Pauses execution for a specified duration.
+ *
+ * Used for implementing retry delays and rate limit backoff.
+ *
+ * @param ms - The number of milliseconds to sleep
+ * @returns A promise that resolves after the specified duration
+ *
+ * @example
+ * await sleep(1000) // Wait 1 second
  */
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
 /**
- * Check if error is a rate limit error
+ * Checks if an error is a rate limit error (HTTP 429).
+ *
+ * Handles both direct statusCode and nested response.statusCode patterns.
+ *
+ * @param error - The error object to check
+ * @returns True if the error is a rate limit error, false otherwise
+ *
+ * @example
+ * isRateLimitError({ statusCode: 429 }) // true
+ * isRateLimitError({ response: { statusCode: 429 } }) // true
+ * isRateLimitError({ statusCode: 500 }) // false
  */
 function isRateLimitError(error) {
     var _a;
@@ -60,7 +306,19 @@ function isRateLimitError(error) {
     return false;
 }
 /**
- * Check if error is retryable (5xx errors or network errors)
+ * Checks if an error is retryable (5xx server errors or network errors).
+ *
+ * Retryable conditions:
+ * - HTTP 5xx status codes (500-599)
+ * - Network errors: ECONNRESET, ETIMEDOUT, ECONNREFUSED
+ *
+ * @param error - The error object to check
+ * @returns True if the error is retryable, false otherwise
+ *
+ * @example
+ * isRetryableError({ statusCode: 503 }) // true (server error)
+ * isRetryableError({ code: 'ECONNRESET' }) // true (network error)
+ * isRetryableError({ statusCode: 404 }) // false (client error)
  */
 function isRetryableError(error) {
     var _a;
@@ -77,7 +335,30 @@ function isRetryableError(error) {
     return false;
 }
 /**
- * Make an authenticated request to the Lemon Squeezy API with retry logic
+ * Makes an authenticated request to the Lemon Squeezy API with retry logic.
+ *
+ * Features:
+ * - Automatic authentication using stored credentials
+ * - Rate limit handling with automatic retry after delay
+ * - Exponential backoff for server errors (5xx)
+ * - Detailed error messages using NodeApiError
+ *
+ * @param this - The n8n execution context
+ * @param method - HTTP method (GET, POST, PATCH, DELETE)
+ * @param endpoint - API endpoint path (e.g., '/v1/products')
+ * @param body - Optional request body for POST/PATCH requests
+ * @param qs - Optional query string parameters
+ * @returns The API response data
+ * @throws NodeApiError if the request fails after all retries
+ *
+ * @example
+ * // GET request
+ * const product = await lemonSqueezyApiRequest.call(this, 'GET', '/v1/products/123')
+ *
+ * // POST request with body
+ * const checkout = await lemonSqueezyApiRequest.call(this, 'POST', '/v1/checkouts', {
+ *   data: { type: 'checkouts', attributes: { ... } }
+ * })
  */
 async function lemonSqueezyApiRequest(method, endpoint, body, qs = {}) {
     const options = {
@@ -118,14 +399,49 @@ async function lemonSqueezyApiRequest(method, endpoint, body, qs = {}) {
     });
 }
 /**
- * Make paginated requests to fetch all items
+ * Makes paginated requests to fetch all items from a Lemon Squeezy API endpoint.
+ *
+ * Automatically handles pagination by following 'next' links until all items
+ * are retrieved. Includes rate limit handling for long-running fetches.
+ *
+ * Features:
+ * - Optional maxItems limit to prevent memory issues with large datasets
+ * - Optional timeout to prevent long-running requests
+ * - Rate limit handling with automatic retry
+ *
+ * @param this - The n8n execution context
+ * @param method - HTTP method (typically 'GET')
+ * @param endpoint - API endpoint path (e.g., '/v1/products')
+ * @param qs - Optional query string parameters (filters, sorting, etc.)
+ * @param paginationOptions - Optional pagination configuration
+ * @returns Array of all items from all pages (up to maxItems if specified)
+ * @throws NodeApiError if any request fails or timeout is exceeded
+ *
+ * @example
+ * // Fetch all products with filtering
+ * const products = await lemonSqueezyApiRequestAllItems.call(
+ *   this, 'GET', '/v1/products', { 'filter[store_id]': 123 }
+ * )
+ *
+ * // Fetch with limits
+ * const products = await lemonSqueezyApiRequestAllItems.call(
+ *   this, 'GET', '/v1/products', {}, { maxItems: 1000, timeout: 60000 }
+ * )
  */
-async function lemonSqueezyApiRequestAllItems(method, endpoint, qs = {}) {
+async function lemonSqueezyApiRequestAllItems(method, endpoint, qs = {}, paginationOptions = {}) {
     var _a;
     const returnData = [];
     let nextPageUrl = `${constants_1.API_BASE_URL}${endpoint}`;
-    qs['page[size]'] = constants_1.DEFAULT_PAGE_SIZE;
+    const { maxItems, timeout = 300000, pageSize = constants_1.DEFAULT_PAGE_SIZE } = paginationOptions;
+    const startTime = Date.now();
+    qs['page[size]'] = pageSize;
     do {
+        // Check timeout
+        if (Date.now() - startTime > timeout) {
+            throw new n8n_workflow_1.NodeApiError(this.getNode(), {}, {
+                message: `Pagination timeout exceeded (${timeout}ms). Retrieved ${returnData.length} items before timeout.`,
+            });
+        }
         const options = {
             method,
             url: nextPageUrl,
@@ -145,26 +461,59 @@ async function lemonSqueezyApiRequestAllItems(method, endpoint, qs = {}) {
                 message: getErrorMessage(error),
             });
         }
-        returnData.push(...responseData.data);
+        const pageData = responseData.data;
+        returnData.push(...pageData);
+        // Check maxItems limit
+        if (maxItems && returnData.length >= maxItems) {
+            return returnData.slice(0, maxItems);
+        }
         nextPageUrl = ((_a = responseData.links) === null || _a === void 0 ? void 0 : _a.next) || null;
     } while (nextPageUrl);
     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;
         }
@@ -172,7 +521,15 @@ function getErrorMessage(error) {
     return 'An unknown error occurred';
 }
 /**
- * Validate required fields before making API request
+ * Validates that all required fields are present and non-empty.
+ *
+ * @param fields - Object containing field values to validate
+ * @param requiredFields - Array of field names that are required
+ * @throws Error listing all missing fields if any are empty
+ *
+ * @example
+ * validateRequiredFields({ name: 'Test', email: '' }, ['name', 'email'])
+ * // Throws: "Missing required fields: email"
  */
 function validateRequiredFields(fields, requiredFields) {
     const missingFields = [];
@@ -186,7 +543,17 @@ function validateRequiredFields(fields, requiredFields) {
     }
 }
 /**
- * Build filter query string parameters
+ * Builds filter query string parameters for Lemon Squeezy API.
+ *
+ * Converts camelCase field names to snake_case and wraps them in
+ * filter[] syntax as required by the API.
+ *
+ * @param filters - Object containing filter key-value pairs
+ * @returns Query string parameters object for API request
+ *
+ * @example
+ * buildFilterParams({ storeId: 123, status: 'active' })
+ * // Returns: { 'filter[store_id]': 123, 'filter[status]': 'active' }
  */
 function buildFilterParams(filters) {
     const qs = {};
@@ -200,7 +567,24 @@ function buildFilterParams(filters) {
     return qs;
 }
 /**
- * Build JSON:API request body
+ * Builds a JSON:API compliant request body for create/update operations.
+ *
+ * Constructs the proper structure expected by Lemon Squeezy API:
+ * - data.type: Resource type (e.g., 'checkouts', 'customers')
+ * - data.attributes: Resource attributes
+ * - data.relationships: Optional related resource references
+ * - data.id: Optional resource ID (for updates)
+ *
+ * @param type - The JSON:API resource type
+ * @param attributes - Resource attributes to include
+ * @param relationships - Optional relationships to other resources
+ * @param id - Optional resource ID (required for updates)
+ * @returns Properly structured JSON:API request body
+ *
+ * @example
+ * buildJsonApiBody('customers', { name: 'John', email: 'john@example.com' },
+ *   { store: { type: 'stores', id: '123' } })
+ * // Returns: { data: { type: 'customers', attributes: {...}, relationships: {...} } }
  */
 function buildJsonApiBody(type, attributes, relationships, id) {
     const body = {
@@ -227,7 +611,21 @@ function buildJsonApiBody(type, attributes, relationships, id) {
     return body;
 }
 /**
- * Parse webhook signature for validation
+ * Verifies a webhook signature using HMAC-SHA256.
+ *
+ * Uses timing-safe comparison to prevent timing attacks.
+ *
+ * @param payload - The raw webhook payload string
+ * @param signature - The signature from X-Signature header
+ * @param secret - The webhook signing secret
+ * @returns True if signature is valid, false otherwise
+ *
+ * @example
+ * const isValid = verifyWebhookSignature(
+ *   '{"data": {...}}',
+ *   'abc123signature',
+ *   'webhook_secret_key'
+ * )
  */
 function verifyWebhookSignature(payload, signature, secret) {
     const hmac = crypto.createHmac('sha256', secret);
@@ -239,3 +637,131 @@ function verifyWebhookSignature(payload, signature, secret) {
         return false;
     }
 }
+// ============================================================================
+// Advanced Query Helpers
+// ============================================================================
+/**
+ * Builds query parameters for including related resources in API responses.
+ *
+ * Uses the JSON:API include parameter to fetch related resources in a single
+ * request, reducing the number of API calls needed.
+ *
+ * @param includes - Array of relationship names to include
+ * @returns Query string parameters object with 'include' key
+ *
+ * @example
+ * buildIncludeParams(['store', 'customer', 'order-items'])
+ * // Returns: { include: 'store,customer,order-items' }
+ *
+ * buildIncludeParams([])
+ * // Returns: {}
+ */
+function buildIncludeParams(includes) {
+    if (includes.length === 0) {
+        return {};
+    }
+    return { include: includes.join(',') };
+}
+/**
+ * Builds advanced filter parameters with support for date ranges and sorting.
+ *
+ * Features:
+ * - Converts camelCase to snake_case for API compatibility
+ * - Handles date range filters with _after/_before suffixes
+ * - Adds sorting with ascending/descending direction
+ *
+ * @param filters - Object containing filter key-value pairs
+ * @param options - Optional configuration for date fields and sorting
+ * @param options.dateFields - Array of field names that are date ranges
+ * @param options.sortField - Field name to sort by
+ * @param options.sortDirection - Sort direction ('asc' or 'desc')
+ * @returns Query string parameters object for API request
+ *
+ * @example
+ * buildAdvancedFilterParams(
+ *   { status: 'active', createdAt: { from: '2024-01-01', to: '2024-12-31' } },
+ *   { dateFields: ['createdAt'], sortField: 'created_at', sortDirection: 'desc' }
+ * )
+ * // Returns: { 'filter[status]': 'active', 'filter[created_at_after]': '2024-01-01',
+ * //           'filter[created_at_before]': '2024-12-31', sort: '-created_at' }
+ */
+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;
+}
+/**
+ * Extracts the 'data' field from a JSON:API response with proper typing.
+ *
+ * JSON:API responses wrap the actual resource data in a 'data' field.
+ * This helper extracts it while preserving type information.
+ *
+ * @template T - The expected type of the extracted data
+ * @param response - The full JSON:API response object
+ * @returns The extracted data, or undefined if not present
+ *
+ * @example
+ * const response = { data: { id: '1', type: 'products', attributes: {...} } }
+ * const product = extractResponseData<Product>(response)
+ * // Returns: { id: '1', type: 'products', attributes: {...} }
+ */
+function extractResponseData(response) {
+    if (!response || typeof response !== 'object') {
+        return undefined;
+    }
+    return response.data;
+}
+/**
+ * Extracts included related resources from a JSON:API response.
+ *
+ * When using the 'include' query parameter, related resources are returned
+ * in the 'included' array of the response. This helper extracts them.
+ *
+ * @param response - The full JSON:API response object
+ * @returns Array of included resources, or empty array if none
+ *
+ * @example
+ * const response = {
+ *   data: {...},
+ *   included: [{ id: '1', type: 'stores', attributes: {...} }]
+ * }
+ * const stores = extractIncludedResources(response)
+ * // Returns: [{ id: '1', type: 'stores', attributes: {...} }]
+ */
+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[];