n8n-nodes-lemonsqueezy 0.2.0

package/dist/nodes/LemonSqueezy/helpers.js

@@ -0,0 +1,241 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lemonSqueezyApiRequest = lemonSqueezyApiRequest;
+exports.lemonSqueezyApiRequestAllItems = lemonSqueezyApiRequestAllItems;
+exports.validateRequiredFields = validateRequiredFields;
+exports.buildFilterParams = buildFilterParams;
+exports.buildJsonApiBody = buildJsonApiBody;
+exports.verifyWebhookSignature = verifyWebhookSignature;
+const crypto = __importStar(require("crypto"));
+const n8n_workflow_1 = require("n8n-workflow");
+const constants_1 = require("./constants");
+/**
+ * Sleep for a specified number of milliseconds
+ */
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Check if error is a rate limit error
+ */
+function isRateLimitError(error) {
+    var _a;
+    if (error && typeof error === 'object') {
+        const err = error;
+        return err.statusCode === 429 || ((_a = err.response) === null || _a === void 0 ? void 0 : _a.statusCode) === 429;
+    }
+    return false;
+}
+/**
+ * Check if error is retryable (5xx errors or network errors)
+ */
+function isRetryableError(error) {
+    var _a;
+    if (error && typeof error === 'object') {
+        const err = error;
+        const statusCode = err.statusCode || ((_a = err.response) === null || _a === void 0 ? void 0 : _a.statusCode);
+        if (statusCode && statusCode >= 500 && statusCode < 600) {
+            return true;
+        }
+        if (err.code === 'ECONNRESET' || err.code === 'ETIMEDOUT' || err.code === 'ECONNREFUSED') {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Make an authenticated request to the Lemon Squeezy API with retry logic
+ */
+async function lemonSqueezyApiRequest(method, endpoint, body, qs = {}) {
+    const options = {
+        method,
+        url: `${constants_1.API_BASE_URL}${endpoint}`,
+        qs,
+        json: true,
+    };
+    if (body) {
+        options.body = body;
+    }
+    let lastError;
+    for (let attempt = 0; attempt < constants_1.MAX_RETRIES; attempt++) {
+        try {
+            return (await this.helpers.requestWithAuthentication.call(this, 'lemonSqueezyApi', options));
+        }
+        catch (error) {
+            lastError = error;
+            if (isRateLimitError(error)) {
+                // Wait for rate limit to reset (usually 60 seconds)
+                await sleep(constants_1.RATE_LIMIT_DELAY_MS);
+                continue;
+            }
+            if (isRetryableError(error) && attempt < constants_1.MAX_RETRIES - 1) {
+                // Exponential backoff for retryable errors
+                await sleep(constants_1.RETRY_DELAY_MS * Math.pow(2, attempt));
+                continue;
+            }
+            // Non-retryable error, throw immediately
+            throw new n8n_workflow_1.NodeApiError(this.getNode(), error, {
+                message: getErrorMessage(error),
+            });
+        }
+    }
+    // All retries exhausted
+    throw new n8n_workflow_1.NodeApiError(this.getNode(), lastError, {
+        message: getErrorMessage(lastError),
+    });
+}
+/**
+ * Make paginated requests to fetch all items
+ */
+async function lemonSqueezyApiRequestAllItems(method, endpoint, qs = {}) {
+    var _a;
+    const returnData = [];
+    let nextPageUrl = `${constants_1.API_BASE_URL}${endpoint}`;
+    qs['page[size]'] = constants_1.DEFAULT_PAGE_SIZE;
+    do {
+        const options = {
+            method,
+            url: nextPageUrl,
+            qs: nextPageUrl.includes('?') ? {} : qs,
+            json: true,
+        };
+        let responseData;
+        try {
+            responseData = (await this.helpers.requestWithAuthentication.call(this, 'lemonSqueezyApi', options));
+        }
+        catch (error) {
+            if (isRateLimitError(error)) {
+                await sleep(constants_1.RATE_LIMIT_DELAY_MS);
+                continue;
+            }
+            throw new n8n_workflow_1.NodeApiError(this.getNode(), error, {
+                message: getErrorMessage(error),
+            });
+        }
+        returnData.push(...responseData.data);
+        nextPageUrl = ((_a = responseData.links) === null || _a === void 0 ? void 0 : _a.next) || null;
+    } while (nextPageUrl);
+    return returnData;
+}
+/**
+ * Extract error message from error object
+ */
+function getErrorMessage(error) {
+    var _a, _b, _c, _d, _e;
+    if (error && typeof error === 'object') {
+        const err = error;
+        // 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 ((_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;
+        }
+        if (err.message) {
+            return err.message;
+        }
+    }
+    return 'An unknown error occurred';
+}
+/**
+ * Validate required fields before making API request
+ */
+function validateRequiredFields(fields, requiredFields) {
+    const missingFields = [];
+    for (const field of requiredFields) {
+        if (fields[field] === undefined || fields[field] === null || fields[field] === '') {
+            missingFields.push(field);
+        }
+    }
+    if (missingFields.length > 0) {
+        throw new Error(`Missing required fields: ${missingFields.join(', ')}`);
+    }
+}
+/**
+ * Build filter query string parameters
+ */
+function buildFilterParams(filters) {
+    const qs = {};
+    for (const [key, value] of Object.entries(filters)) {
+        if (value !== undefined && value !== null && value !== '') {
+            // Convert camelCase to snake_case for API
+            const snakeKey = key.replace(/([A-Z])/g, '_$1').toLowerCase();
+            qs[`filter[${snakeKey}]`] = value;
+        }
+    }
+    return qs;
+}
+/**
+ * Build JSON:API request body
+ */
+function buildJsonApiBody(type, attributes, relationships, id) {
+    const body = {
+        data: {
+            type,
+            attributes,
+        },
+    };
+    if (id) {
+        body.data.id = id;
+    }
+    if (relationships) {
+        const relationshipsObj = {};
+        for (const [key, value] of Object.entries(relationships)) {
+            relationshipsObj[key] = {
+                data: {
+                    type: value.type,
+                    id: value.id,
+                },
+            };
+        }
+        body.data.relationships = relationshipsObj;
+    }
+    return body;
+}
+/**
+ * Parse webhook signature for validation
+ */
+function verifyWebhookSignature(payload, signature, secret) {
+    const hmac = crypto.createHmac('sha256', secret);
+    const digest = hmac.update(payload).digest('hex');
+    try {
+        return crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(digest));
+    }
+    catch {
+        return false;
+    }
+}

package/dist/nodes/LemonSqueezy/lemonSqueezy.svg

@@ -0,0 +1,20 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" fill="none">
+  <defs>
+    <linearGradient id="lemonGradient" x1="0%" y1="0%" x2="100%" y2="100%">
+      <stop offset="0%" style="stop-color:#FFC233"/>
+      <stop offset="100%" style="stop-color:#F5A623"/>
+    </linearGradient>
+  </defs>
+  <!-- Lemon body -->
+  <ellipse cx="32" cy="34" rx="22" ry="18" fill="url(#lemonGradient)"/>
+  <!-- Lemon tip -->
+  <path d="M54 34 Q62 34 58 28 Q56 32 54 34" fill="#F5A623"/>
+  <path d="M10 34 Q2 34 6 28 Q8 32 10 34" fill="#FFC233"/>
+  <!-- Leaf -->
+  <path d="M32 16 Q38 8 44 12 Q38 14 36 18 Q34 14 32 16" fill="#7CB342"/>
+  <path d="M32 16 Q26 8 20 12 Q26 14 28 18 Q30 14 32 16" fill="#8BC34A"/>
+  <!-- Stem -->
+  <rect x="30" y="14" width="4" height="6" rx="2" fill="#5D4037"/>
+  <!-- Highlight -->
+  <ellipse cx="24" cy="30" rx="6" ry="4" fill="rgba(255,255,255,0.3)" transform="rotate(-20 24 30)"/>
+</svg>

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

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

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

@@ -0,0 +1,272 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkoutFields = exports.checkoutOperations = void 0;
+exports.checkoutOperations = {
+    displayName: 'Operation',
+    name: 'operation',
+    type: 'options',
+    noDataExpression: true,
+    displayOptions: {
+        show: { resource: ['checkout'] },
+    },
+    options: [
+        {
+            name: 'Create',
+            value: 'create',
+            action: 'Create a checkout',
+            description: 'Create a new checkout link',
+        },
+        {
+            name: 'Get',
+            value: 'get',
+            action: 'Get a checkout',
+            description: 'Retrieve a single checkout by ID',
+        },
+        {
+            name: 'Get Many',
+            value: 'getAll',
+            action: 'Get many checkouts',
+            description: 'Retrieve multiple checkouts',
+        },
+    ],
+    default: 'create',
+};
+exports.checkoutFields = [
+    // Checkout ID for Get operation
+    {
+        displayName: 'Checkout ID',
+        name: 'checkoutId',
+        type: 'string',
+        required: true,
+        default: '',
+        description: 'The ID of the checkout to retrieve',
+        displayOptions: {
+            show: { resource: ['checkout'], operation: ['get'] },
+        },
+    },
+    // Create Fields
+    {
+        displayName: 'Store ID',
+        name: 'checkoutStoreId',
+        type: 'string',
+        required: true,
+        default: '',
+        description: 'The ID of the store',
+        displayOptions: {
+            show: { resource: ['checkout'], operation: ['create'] },
+        },
+    },
+    {
+        displayName: 'Variant ID',
+        name: 'checkoutVariantId',
+        type: 'string',
+        required: true,
+        default: '',
+        description: 'The ID of the variant to checkout',
+        displayOptions: {
+            show: { resource: ['checkout'], operation: ['create'] },
+        },
+    },
+    {
+        displayName: 'Additional Options',
+        name: 'additionalOptions',
+        type: 'collection',
+        placeholder: 'Add Option',
+        default: {},
+        displayOptions: {
+            show: { resource: ['checkout'], operation: ['create'] },
+        },
+        options: [
+            {
+                displayName: 'Custom Price',
+                name: 'customPrice',
+                type: 'number',
+                default: 0,
+                description: 'Custom price in cents (for pay-what-you-want products)',
+            },
+            {
+                displayName: 'Discount Code',
+                name: 'discountCode',
+                type: 'string',
+                default: '',
+                description: 'Discount code to apply to the checkout',
+            },
+            {
+                displayName: 'Customer Email',
+                name: 'email',
+                type: 'string',
+                default: '',
+                description: 'Pre-fill customer email',
+            },
+            {
+                displayName: 'Customer Name',
+                name: 'name',
+                type: 'string',
+                default: '',
+                description: 'Pre-fill customer name',
+            },
+            {
+                displayName: 'Redirect URL',
+                name: 'redirectUrl',
+                type: 'string',
+                default: '',
+                description: 'URL to redirect after successful purchase',
+            },
+            {
+                displayName: 'Receipt Button Text',
+                name: 'receiptButtonText',
+                type: 'string',
+                default: '',
+                description: 'Custom text for receipt button',
+            },
+            {
+                displayName: 'Receipt Link URL',
+                name: 'receiptLinkUrl',
+                type: 'string',
+                default: '',
+                description: 'Custom URL for receipt button',
+            },
+            {
+                displayName: 'Receipt Thank You Note',
+                name: 'receiptThankYouNote',
+                type: 'string',
+                default: '',
+                description: 'Custom thank you note on receipt',
+            },
+            {
+                displayName: 'Custom Data',
+                name: 'customData',
+                type: 'json',
+                default: '{}',
+                description: 'Custom data to attach to the checkout (will be passed to webhooks)',
+            },
+            {
+                displayName: 'Expires At',
+                name: 'expiresAt',
+                type: 'dateTime',
+                default: '',
+                description: 'When the checkout link expires (ISO 8601 format)',
+            },
+            {
+                displayName: 'Test Mode',
+                name: 'testMode',
+                type: 'boolean',
+                default: false,
+                description: 'Whether this is a test checkout',
+            },
+        ],
+    },
+    // Checkout Options
+    {
+        displayName: 'Checkout Display Options',
+        name: 'checkoutOptions',
+        type: 'collection',
+        placeholder: 'Add Display Option',
+        default: {},
+        displayOptions: {
+            show: { resource: ['checkout'], operation: ['create'] },
+        },
+        options: [
+            {
+                displayName: 'Dark Mode',
+                name: 'dark',
+                type: 'boolean',
+                default: false,
+                description: 'Whether to use dark mode',
+            },
+            {
+                displayName: 'Embed Mode',
+                name: 'embed',
+                type: 'boolean',
+                default: false,
+                description: 'Whether checkout is embedded',
+            },
+            {
+                displayName: 'Show Logo',
+                name: 'logo',
+                type: 'boolean',
+                default: true,
+                description: 'Whether to show the store logo',
+            },
+            {
+                displayName: 'Show Description',
+                name: 'desc',
+                type: 'boolean',
+                default: true,
+                description: 'Whether to show the product description',
+            },
+            {
+                displayName: 'Show Media',
+                name: 'media',
+                type: 'boolean',
+                default: true,
+                description: 'Whether to show product media',
+            },
+            {
+                displayName: 'Show Discount Field',
+                name: 'discount',
+                type: 'boolean',
+                default: true,
+                description: 'Whether to show the discount code field',
+            },
+            {
+                displayName: 'Button Color',
+                name: 'buttonColor',
+                type: 'string',
+                default: '',
+                description: 'Custom button color (hex code)',
+                placeholder: '#7c3aed',
+            },
+        ],
+    },
+    // 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: ['checkout'], operation: ['getAll'] },
+        },
+    },
+    // Limit
+    {
+        displayName: 'Limit',
+        name: 'limit',
+        type: 'number',
+        default: 50,
+        description: 'Max number of results to return',
+        typeOptions: { minValue: 1 },
+        displayOptions: {
+            show: { resource: ['checkout'], operation: ['getAll'], returnAll: [false] },
+        },
+    },
+    // Filters
+    {
+        displayName: 'Filters',
+        name: 'filters',
+        type: 'collection',
+        placeholder: 'Add Filter',
+        default: {},
+        displayOptions: {
+            show: { resource: ['checkout'], operation: ['getAll'] },
+        },
+        options: [
+            {
+                displayName: 'Store ID',
+                name: 'storeId',
+                type: 'string',
+                default: '',
+                description: 'Filter by store ID',
+            },
+            {
+                displayName: 'Variant ID',
+                name: 'variantId',
+                type: 'string',
+                default: '',
+                description: 'Filter by variant ID',
+            },
+        ],
+    },
+];

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

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