n8n-nodes-lemonsqueezy 0.4.0 → 0.6.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);
@@ -39,6 +51,9 @@ 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;
@@ -56,39 +71,146 @@ const constants_1 = require("./constants");
 // Validation Helpers
 // ============================================================================
 /**
- * Validate email format
+ * 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 = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    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);
 }
 /**
- * Validate URL format
+ * 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 {
-        new URL(url);
+        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;
     }
 }
 /**
- * Validate ISO 8601 date format
+ * 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('-');
 }
 /**
- * Validate that a value is a positive integer
+ * 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;
 }
 /**
- * Validate field with specific type and throw descriptive error
+ * 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') {
@@ -125,7 +247,20 @@ function validateField(fieldName, value, validationType) {
     }
 }
 /**
- * Safely parse JSON with error handling
+ * 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 {
@@ -136,13 +271,31 @@ function safeJsonParse(jsonString, fieldName) {
     }
 }
 /**
- * Sleep for a specified number of milliseconds
+ * 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;
@@ -153,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;
@@ -170,14 +335,43 @@ 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)
+ * - Configurable request timeout (default: 30 seconds)
+ * - 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
+ * @param timeout - Request timeout in milliseconds (default: 30000)
+ * @returns The API response data
+ * @throws NodeApiError if the request fails after all retries or times out
+ *
+ * @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: { ... } }
+ * })
+ *
+ * // Request with custom timeout (60 seconds)
+ * const data = await lemonSqueezyApiRequest.call(this, 'GET', '/v1/orders', undefined, {}, 60000)
  */
-async function lemonSqueezyApiRequest(method, endpoint, body, qs = {}) {
+async function lemonSqueezyApiRequest(method, endpoint, body, qs = {}, timeout = constants_1.DEFAULT_REQUEST_TIMEOUT_MS) {
     const options = {
         method,
         url: `${constants_1.API_BASE_URL}${endpoint}`,
         qs,
         json: true,
+        timeout,
     };
     if (body) {
         options.body = body;
@@ -190,13 +384,17 @@ async function lemonSqueezyApiRequest(method, endpoint, body, qs = {}) {
         catch (error) {
             lastError = error;
             if (isRateLimitError(error)) {
-                // Wait for rate limit to reset (usually 60 seconds)
+                // Log rate limit for visibility
+                // eslint-disable-next-line no-console
+                console.warn(`[LemonSqueezy] Rate limited (429) on ${method} ${endpoint}. Waiting ${constants_1.RATE_LIMIT_DELAY_MS / 1000}s before retry...`);
                 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));
+                const delayMs = constants_1.RETRY_DELAY_MS * Math.pow(2, attempt);
+                // eslint-disable-next-line no-console
+                console.warn(`[LemonSqueezy] Retryable error on ${method} ${endpoint} (attempt ${attempt + 1}/${constants_1.MAX_RETRIES}). Retrying in ${delayMs}ms...`);
+                await sleep(delayMs);
                 continue;
             }
             // Non-retryable error, throw immediately
@@ -211,14 +409,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,
@@ -231,6 +464,8 @@ async function lemonSqueezyApiRequestAllItems(method, endpoint, qs = {}) {
         }
         catch (error) {
             if (isRateLimitError(error)) {
+                // eslint-disable-next-line no-console
+                console.warn(`[LemonSqueezy] Rate limited during pagination (${returnData.length} items fetched). Waiting ${constants_1.RATE_LIMIT_DELAY_MS / 1000}s...`);
                 await sleep(constants_1.RATE_LIMIT_DELAY_MS);
                 continue;
             }
@@ -238,7 +473,12 @@ 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;
@@ -293,7 +533,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 = [];
@@ -307,7 +555,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 = {};
@@ -321,7 +579,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 = {
@@ -348,7 +623,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);
@@ -364,7 +653,20 @@ function verifyWebhookSignature(payload, signature, secret) {
 // Advanced Query Helpers
 // ============================================================================
 /**
- * Build query params with relationship expansion (include)
+ * 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) {
@@ -373,7 +675,27 @@ function buildIncludeParams(includes) {
     return { include: includes.join(',') };
 }
 /**
- * Build advanced filter params with date range support
+ * 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;
@@ -412,7 +734,19 @@ function buildAdvancedFilterParams(filters, options) {
     return qs;
 }
 /**
- * Extract data from JSON:API response with proper typing
+ * 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') {
@@ -421,7 +755,21 @@ function extractResponseData(response) {
     return response.data;
 }
 /**
- * Extract included resources from JSON:API response
+ * 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') {

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

@@ -49,6 +49,7 @@ Object.defineProperty(exports, "usageRecordFields", { enumerable: true, get: fun
 const user_1 = require("./user");
 Object.defineProperty(exports, "userOperations", { enumerable: true, get: function () { return user_1.userOperations; } });
 Object.defineProperty(exports, "userFields", { enumerable: true, get: function () { return user_1.userFields; } });
+const shared_1 = require("./shared");
 exports.resourceProperty = {
     displayName: 'Resource',
     name: 'resource',
@@ -94,18 +95,26 @@ exports.allOperations = [
 ];
 exports.allFields = [
     ...product_1.productFields,
+    shared_1.productAdvancedOptions,
     ...order_1.orderFields,
+    shared_1.orderAdvancedOptions,
     ...orderItem_1.orderItemFields,
     ...subscription_1.subscriptionFields,
+    shared_1.subscriptionAdvancedOptions,
     ...subscriptionInvoice_1.subscriptionInvoiceFields,
     ...customer_1.customerFields,
+    shared_1.customerAdvancedOptions,
     ...licenseKey_1.licenseKeyFields,
+    shared_1.licenseKeyAdvancedOptions,
     ...licenseKeyInstance_1.licenseKeyInstanceFields,
     ...discount_1.discountFields,
+    shared_1.discountAdvancedOptions,
     ...discountRedemption_1.discountRedemptionFields,
     ...store_1.storeFields,
     ...variant_1.variantFields,
+    shared_1.variantAdvancedOptions,
     ...checkout_1.checkoutFields,
+    shared_1.checkoutAdvancedOptions,
     ...webhook_1.webhookFields,
     ...usageRecord_1.usageRecordFields,
     ...user_1.userFields,