n8n-nodes-lemonsqueezy 0.2.0

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

@@ -0,0 +1,230 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LemonSqueezyTrigger = void 0;
+const constants_1 = require("./constants");
+const helpers_1 = require("./helpers");
+class LemonSqueezyTrigger {
+    constructor() {
+        this.description = {
+            displayName: 'Lemon Squeezy Trigger',
+            name: 'lemonSqueezyTrigger',
+            icon: 'file:lemonSqueezy.svg',
+            group: ['trigger'],
+            version: 1,
+            subtitle: '={{$parameter["events"].join(", ")}}',
+            description: 'Receive events from Lemon Squeezy in real-time',
+            defaults: {
+                name: 'Lemon Squeezy Trigger',
+            },
+            inputs: [],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'lemonSqueezyApi',
+                    required: true,
+                },
+            ],
+            webhooks: [
+                {
+                    name: 'default',
+                    httpMethod: 'POST',
+                    responseMode: 'onReceived',
+                    path: 'webhook',
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Store ID',
+                    name: 'storeId',
+                    type: 'string',
+                    required: true,
+                    default: '',
+                    description: 'The ID of the store to receive events from',
+                },
+                {
+                    displayName: 'Events',
+                    name: 'events',
+                    type: 'multiOptions',
+                    required: true,
+                    default: [],
+                    options: constants_1.WEBHOOK_EVENTS,
+                    description: 'The events to listen for',
+                },
+                {
+                    displayName: 'Webhook Secret',
+                    name: 'webhookSecret',
+                    type: 'string',
+                    typeOptions: { password: true },
+                    required: true,
+                    default: '',
+                    description: 'A secret string to verify webhook payloads. Generate a secure random string.',
+                },
+                {
+                    displayName: 'Options',
+                    name: 'options',
+                    type: 'collection',
+                    placeholder: 'Add Option',
+                    default: {},
+                    options: [
+                        {
+                            displayName: 'Test Mode Only',
+                            name: 'testMode',
+                            type: 'boolean',
+                            default: false,
+                            description: 'Whether to only receive test mode events',
+                        },
+                        {
+                            displayName: 'Verify Signature',
+                            name: 'verifySignature',
+                            type: 'boolean',
+                            default: true,
+                            description: 'Whether to verify the webhook signature (recommended)',
+                        },
+                    ],
+                },
+            ],
+        };
+        this.webhookMethods = {
+            default: {
+                async checkExists() {
+                    const webhookUrl = this.getNodeWebhookUrl('default');
+                    const storeId = this.getNodeParameter('storeId');
+                    const webhookData = this.getWorkflowStaticData('node');
+                    // Check if we have stored webhook data
+                    if (webhookData.webhookId) {
+                        try {
+                            // Verify the webhook still exists
+                            await helpers_1.lemonSqueezyApiRequest.call(this, 'GET', `/webhooks/${String(webhookData.webhookId)}`);
+                            return true;
+                        }
+                        catch {
+                            // Webhook doesn't exist anymore
+                            delete webhookData.webhookId;
+                            return false;
+                        }
+                    }
+                    // Check if a webhook with our URL already exists
+                    try {
+                        const response = await helpers_1.lemonSqueezyApiRequest.call(this, 'GET', '/webhooks', undefined, {
+                            'filter[store_id]': storeId,
+                        });
+                        const responseData = response;
+                        const webhooks = responseData.data;
+                        if (Array.isArray(webhooks)) {
+                            const existingWebhook = webhooks.find((webhook) => { var _a; return ((_a = webhook.attributes) === null || _a === void 0 ? void 0 : _a.url) === webhookUrl; });
+                            if (existingWebhook) {
+                                webhookData.webhookId = existingWebhook.id;
+                                return true;
+                            }
+                        }
+                    }
+                    catch {
+                        // Error checking webhooks, assume doesn't exist
+                    }
+                    return false;
+                },
+                async create() {
+                    const webhookUrl = this.getNodeWebhookUrl('default');
+                    const storeId = this.getNodeParameter('storeId');
+                    const events = this.getNodeParameter('events');
+                    const webhookSecret = this.getNodeParameter('webhookSecret');
+                    const options = this.getNodeParameter('options');
+                    const webhookData = this.getWorkflowStaticData('node');
+                    const body = {
+                        data: {
+                            type: 'webhooks',
+                            attributes: {
+                                url: webhookUrl,
+                                events,
+                                secret: webhookSecret,
+                                test_mode: options.testMode || false,
+                            },
+                            relationships: {
+                                store: {
+                                    data: {
+                                        type: 'stores',
+                                        id: storeId,
+                                    },
+                                },
+                            },
+                        },
+                    };
+                    const response = await helpers_1.lemonSqueezyApiRequest.call(this, 'POST', '/webhooks', body);
+                    const responseData = response;
+                    const data = responseData.data;
+                    if (data === null || data === void 0 ? void 0 : data.id) {
+                        webhookData.webhookId = data.id;
+                        return true;
+                    }
+                    return false;
+                },
+                async delete() {
+                    const webhookData = this.getWorkflowStaticData('node');
+                    if (webhookData.webhookId) {
+                        try {
+                            await helpers_1.lemonSqueezyApiRequest.call(this, 'DELETE', `/webhooks/${String(webhookData.webhookId)}`);
+                        }
+                        catch {
+                            // Webhook might already be deleted
+                        }
+                        delete webhookData.webhookId;
+                    }
+                    return true;
+                },
+            },
+        };
+    }
+    async webhook() {
+        const options = this.getNodeParameter('options');
+        const webhookSecret = this.getNodeParameter('webhookSecret');
+        // Verify signature if enabled
+        if (options.verifySignature !== false) {
+            const signature = this.getHeaderData()['x-signature'];
+            if (!signature) {
+                return {
+                    webhookResponse: {
+                        status: 401,
+                        body: { error: 'Missing signature header' },
+                    },
+                };
+            }
+            const bodyData = this.getBodyData();
+            const rawBody = JSON.stringify(bodyData);
+            const isValid = (0, helpers_1.verifyWebhookSignature)(rawBody, signature, webhookSecret);
+            if (!isValid) {
+                return {
+                    webhookResponse: {
+                        status: 401,
+                        body: { error: 'Invalid signature' },
+                    },
+                };
+            }
+        }
+        const body = this.getBodyData();
+        const meta = body.meta;
+        const eventName = meta === null || meta === void 0 ? void 0 : meta.event_name;
+        // Check if we should process this event
+        const subscribedEvents = this.getNodeParameter('events');
+        if (!eventName || !subscribedEvents.includes(eventName)) {
+            // Event not subscribed, acknowledge but don't trigger workflow
+            return {
+                webhookResponse: {
+                    status: 200,
+                    body: { received: true, processed: false },
+                },
+            };
+        }
+        // Return the webhook data
+        return {
+            workflowData: [
+                this.helpers.returnJsonArray({
+                    event: eventName,
+                    meta: body.meta,
+                    data: body.data,
+                    timestamp: new Date().toISOString(),
+                }),
+            ],
+        };
+    }
+}
+exports.LemonSqueezyTrigger = LemonSqueezyTrigger;

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

@@ -0,0 +1,89 @@
+/**
+ * Lemon Squeezy API constants
+ */
+export declare const API_BASE_URL = "https://api.lemonsqueezy.com/v1";
+export declare const DEFAULT_PAGE_SIZE = 100;
+export declare const MAX_RETRIES = 3;
+export declare const RETRY_DELAY_MS = 1000;
+export declare const RATE_LIMIT_DELAY_MS = 60000;
+/**
+ * Resource to API endpoint mapping
+ */
+export declare const RESOURCE_ENDPOINTS: Record<string, string>;
+/**
+ * Resource to ID parameter mapping
+ */
+export declare const RESOURCE_ID_PARAMS: Record<string, string>;
+/**
+ * Webhook event types with descriptions
+ */
+export declare const WEBHOOK_EVENTS: {
+    name: string;
+    value: string;
+    description: string;
+}[];
+/**
+ * Subscription statuses
+ */
+export declare const SUBSCRIPTION_STATUSES: {
+    name: string;
+    value: string;
+}[];
+/**
+ * Order statuses
+ */
+export declare const ORDER_STATUSES: {
+    name: string;
+    value: string;
+}[];
+/**
+ * Customer statuses
+ */
+export declare const CUSTOMER_STATUSES: {
+    name: string;
+    value: string;
+}[];
+/**
+ * License key statuses
+ */
+export declare const LICENSE_KEY_STATUSES: {
+    name: string;
+    value: string;
+}[];
+/**
+ * Discount types
+ */
+export declare const DISCOUNT_AMOUNT_TYPES: {
+    name: string;
+    value: string;
+}[];
+/**
+ * Discount duration types
+ */
+export declare const DISCOUNT_DURATION_TYPES: {
+    name: string;
+    value: string;
+    description: string;
+}[];
+/**
+ * Pause modes for subscriptions
+ */
+export declare const PAUSE_MODES: {
+    name: string;
+    value: string;
+    description: string;
+}[];
+/**
+ * Product statuses
+ */
+export declare const PRODUCT_STATUSES: {
+    name: string;
+    value: string;
+}[];
+/**
+ * Interval types for subscriptions
+ */
+export declare const INTERVAL_TYPES: {
+    name: string;
+    value: string;
+}[];

package/dist/nodes/LemonSqueezy/constants.js

@@ -0,0 +1,207 @@
+"use strict";
+/**
+ * Lemon Squeezy API constants
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INTERVAL_TYPES = exports.PRODUCT_STATUSES = exports.PAUSE_MODES = exports.DISCOUNT_DURATION_TYPES = exports.DISCOUNT_AMOUNT_TYPES = exports.LICENSE_KEY_STATUSES = exports.CUSTOMER_STATUSES = exports.ORDER_STATUSES = exports.SUBSCRIPTION_STATUSES = exports.WEBHOOK_EVENTS = exports.RESOURCE_ID_PARAMS = exports.RESOURCE_ENDPOINTS = exports.RATE_LIMIT_DELAY_MS = exports.RETRY_DELAY_MS = exports.MAX_RETRIES = exports.DEFAULT_PAGE_SIZE = exports.API_BASE_URL = void 0;
+exports.API_BASE_URL = 'https://api.lemonsqueezy.com/v1';
+exports.DEFAULT_PAGE_SIZE = 100;
+exports.MAX_RETRIES = 3;
+exports.RETRY_DELAY_MS = 1000;
+exports.RATE_LIMIT_DELAY_MS = 60000;
+/**
+ * Resource to API endpoint mapping
+ */
+exports.RESOURCE_ENDPOINTS = {
+    product: 'products',
+    order: 'orders',
+    subscription: 'subscriptions',
+    customer: 'customers',
+    licenseKey: 'license-keys',
+    discount: 'discounts',
+    store: 'stores',
+    variant: 'variants',
+    checkout: 'checkouts',
+    webhook: 'webhooks',
+    licenseKeyInstance: 'license-key-instances',
+};
+/**
+ * Resource to ID parameter mapping
+ */
+exports.RESOURCE_ID_PARAMS = {
+    product: 'productId',
+    order: 'orderId',
+    subscription: 'subscriptionId',
+    customer: 'customerId',
+    licenseKey: 'licenseKeyId',
+    discount: 'discountId',
+    store: 'storeId',
+    variant: 'variantId',
+    checkout: 'checkoutId',
+    webhook: 'webhookId',
+    licenseKeyInstance: 'licenseKeyInstanceId',
+};
+/**
+ * Webhook event types with descriptions
+ */
+exports.WEBHOOK_EVENTS = [
+    {
+        name: 'Order Created',
+        value: 'order_created',
+        description: 'Triggered when a new order is created',
+    },
+    {
+        name: 'Order Refunded',
+        value: 'order_refunded',
+        description: 'Triggered when an order is refunded',
+    },
+    {
+        name: 'Subscription Created',
+        value: 'subscription_created',
+        description: 'Triggered when a new subscription is created',
+    },
+    {
+        name: 'Subscription Updated',
+        value: 'subscription_updated',
+        description: 'Triggered when a subscription is updated',
+    },
+    {
+        name: 'Subscription Cancelled',
+        value: 'subscription_cancelled',
+        description: 'Triggered when a subscription is cancelled',
+    },
+    {
+        name: 'Subscription Resumed',
+        value: 'subscription_resumed',
+        description: 'Triggered when a subscription is resumed',
+    },
+    {
+        name: 'Subscription Expired',
+        value: 'subscription_expired',
+        description: 'Triggered when a subscription expires',
+    },
+    {
+        name: 'Subscription Paused',
+        value: 'subscription_paused',
+        description: 'Triggered when a subscription is paused',
+    },
+    {
+        name: 'Subscription Unpaused',
+        value: 'subscription_unpaused',
+        description: 'Triggered when a subscription is unpaused',
+    },
+    {
+        name: 'Subscription Payment Success',
+        value: 'subscription_payment_success',
+        description: 'Triggered when a subscription payment succeeds',
+    },
+    {
+        name: 'Subscription Payment Failed',
+        value: 'subscription_payment_failed',
+        description: 'Triggered when a subscription payment fails',
+    },
+    {
+        name: 'Subscription Payment Recovered',
+        value: 'subscription_payment_recovered',
+        description: 'Triggered when a failed payment is recovered',
+    },
+    {
+        name: 'Subscription Payment Refunded',
+        value: 'subscription_payment_refunded',
+        description: 'Triggered when a subscription payment is refunded',
+    },
+    {
+        name: 'License Key Created',
+        value: 'license_key_created',
+        description: 'Triggered when a license key is created',
+    },
+    {
+        name: 'License Key Updated',
+        value: 'license_key_updated',
+        description: 'Triggered when a license key is updated',
+    },
+];
+/**
+ * Subscription statuses
+ */
+exports.SUBSCRIPTION_STATUSES = [
+    { name: 'On Trial', value: 'on_trial' },
+    { name: 'Active', value: 'active' },
+    { name: 'Paused', value: 'paused' },
+    { name: 'Past Due', value: 'past_due' },
+    { name: 'Unpaid', value: 'unpaid' },
+    { name: 'Cancelled', value: 'cancelled' },
+    { name: 'Expired', value: 'expired' },
+];
+/**
+ * Order statuses
+ */
+exports.ORDER_STATUSES = [
+    { name: 'Pending', value: 'pending' },
+    { name: 'Failed', value: 'failed' },
+    { name: 'Paid', value: 'paid' },
+    { name: 'Refunded', value: 'refunded' },
+];
+/**
+ * Customer statuses
+ */
+exports.CUSTOMER_STATUSES = [
+    { name: 'Subscribed', value: 'subscribed' },
+    { name: 'Unsubscribed', value: 'unsubscribed' },
+    { name: 'Archived', value: 'archived' },
+    { name: 'Requires Verification', value: 'requires_verification' },
+    { name: 'Invalid Email', value: 'invalid_email' },
+    { name: 'Bounced', value: 'bounced' },
+];
+/**
+ * License key statuses
+ */
+exports.LICENSE_KEY_STATUSES = [
+    { name: 'Inactive', value: 'inactive' },
+    { name: 'Active', value: 'active' },
+    { name: 'Expired', value: 'expired' },
+    { name: 'Disabled', value: 'disabled' },
+];
+/**
+ * Discount types
+ */
+exports.DISCOUNT_AMOUNT_TYPES = [
+    { name: 'Percent', value: 'percent' },
+    { name: 'Fixed', value: 'fixed' },
+];
+/**
+ * Discount duration types
+ */
+exports.DISCOUNT_DURATION_TYPES = [
+    { name: 'Once', value: 'once', description: 'Applied only to the first payment' },
+    {
+        name: 'Repeating',
+        value: 'repeating',
+        description: 'Applied for a specified number of months',
+    },
+    { name: 'Forever', value: 'forever', description: 'Applied to all payments' },
+];
+/**
+ * Pause modes for subscriptions
+ */
+exports.PAUSE_MODES = [
+    { name: 'Not Paused', value: '', description: 'Resume or keep subscription active' },
+    { name: 'Void', value: 'void', description: 'Pause without extending billing period' },
+    { name: 'Free', value: 'free', description: 'Pause and give free days when resumed' },
+];
+/**
+ * Product statuses
+ */
+exports.PRODUCT_STATUSES = [
+    { name: 'Draft', value: 'draft' },
+    { name: 'Published', value: 'published' },
+];
+/**
+ * Interval types for subscriptions
+ */
+exports.INTERVAL_TYPES = [
+    { name: 'Day', value: 'day' },
+    { name: 'Week', value: 'week' },
+    { name: 'Month', value: 'month' },
+    { name: 'Year', value: 'year' },
+];

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

@@ -0,0 +1,28 @@
+import type { IExecuteFunctions, IWebhookFunctions, IHookFunctions, IHttpRequestMethods, IDataObject } from 'n8n-workflow';
+/**
+ * Make an authenticated request to the Lemon Squeezy API with retry logic
+ */
+export declare function lemonSqueezyApiRequest(this: IExecuteFunctions | IWebhookFunctions | IHookFunctions, method: IHttpRequestMethods, endpoint: string, body?: IDataObject, qs?: Record<string, string | number>): Promise<IDataObject>;
+/**
+ * Make paginated requests to fetch all items
+ */
+export declare function lemonSqueezyApiRequestAllItems(this: IExecuteFunctions, method: IHttpRequestMethods, endpoint: string, qs?: Record<string, string | number>): Promise<IDataObject[]>;
+/**
+ * Validate required fields before making API request
+ */
+export declare function validateRequiredFields(fields: Record<string, unknown>, requiredFields: string[]): void;
+/**
+ * Build filter query string parameters
+ */
+export declare function buildFilterParams(filters: IDataObject): Record<string, string | number>;
+/**
+ * Build JSON:API request body
+ */
+export declare function buildJsonApiBody(type: string, attributes: IDataObject, relationships?: Record<string, {
+    type: string;
+    id: string;
+}>, id?: string): IDataObject;
+/**
+ * Parse webhook signature for validation
+ */
+export declare function verifyWebhookSignature(payload: string, signature: string, secret: string): boolean;