@rudderstack/integrations-lib 0.2.59 → 0.2.60

package/build/utils/index.d.ts

@@ -2,6 +2,7 @@ export * from './batch-processing';
 export * from './json-schema-generator';
 export * from './misc';
 export * from './request';
+export * from './sanitizer';
 export * from './tests';
 export * from './zod';
 //# sourceMappingURL=index.d.ts.map

package/build/utils/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,yBAAyB,CAAC;AACxC,cAAc,QAAQ,CAAC;AACvB,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC;AACxB,cAAc,OAAO,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,yBAAyB,CAAC;AACxC,cAAc,QAAQ,CAAC;AACvB,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,OAAO,CAAC"}

package/build/utils/index.js

@@ -18,6 +18,7 @@ __exportStar(require("./batch-processing"), exports);
 __exportStar(require("./json-schema-generator"), exports);
 __exportStar(require("./misc"), exports);
 __exportStar(require("./request"), exports);
+__exportStar(require("./sanitizer"), exports);
 __exportStar(require("./tests"), exports);
 __exportStar(require("./zod"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHFEQUFtQztBQUNuQywwREFBd0M7QUFDeEMseUNBQXVCO0FBQ3ZCLDRDQUEwQjtBQUMxQiwwQ0FBd0I7QUFDeEIsd0NBQXNCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9iYXRjaC1wcm9jZXNzaW5nJztcbmV4cG9ydCAqIGZyb20gJy4vanNvbi1zY2hlbWEtZ2VuZXJhdG9yJztcbmV4cG9ydCAqIGZyb20gJy4vbWlzYyc7XG5leHBvcnQgKiBmcm9tICcuL3JlcXVlc3QnO1xuZXhwb3J0ICogZnJvbSAnLi90ZXN0cyc7XG5leHBvcnQgKiBmcm9tICcuL3pvZCc7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHFEQUFtQztBQUNuQywwREFBd0M7QUFDeEMseUNBQXVCO0FBQ3ZCLDRDQUEwQjtBQUMxQiw4Q0FBNEI7QUFDNUIsMENBQXdCO0FBQ3hCLHdDQUFzQiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYmF0Y2gtcHJvY2Vzc2luZyc7XG5leHBvcnQgKiBmcm9tICcuL2pzb24tc2NoZW1hLWdlbmVyYXRvcic7XG5leHBvcnQgKiBmcm9tICcuL21pc2MnO1xuZXhwb3J0ICogZnJvbSAnLi9yZXF1ZXN0JztcbmV4cG9ydCAqIGZyb20gJy4vc2FuaXRpemVyJztcbmV4cG9ydCAqIGZyb20gJy4vdGVzdHMnO1xuZXhwb3J0ICogZnJvbSAnLi96b2QnO1xuIl19

package/build/utils/sanitizer.d.ts

@@ -0,0 +1,152 @@
+/**
+ * Response Sanitization Utility
+ *
+ * Provides comprehensive sanitization for API responses to prevent XSS attacks
+ * and other security vulnerabilities.
+ *
+ * Key Features:
+ * - HTML entity escaping (always enabled, uses validator library)
+ * - Control character removal (configurable)
+ * - String length truncation (configurable)
+ * - Deep object traversal (configurable depth)
+ * - Type preservation (numbers, booleans, null remain unchanged)
+ * - Non-destructive (returns new objects without mutating originals)
+ *
+ * @packageDocumentation
+ */
+/**
+ * Regular expression to match dangerous control characters
+ *
+ * Matches ASCII control characters (0x00-0x1F and 0x7F) EXCEPT:
+ * - \x09 (tab)
+ * - \x0A (newline)
+ * - \x0D (carriage return)
+ *
+ * Range breakdown:
+ * - \x00-\x08: NULL to BACKSPACE
+ * - \x0B: Vertical Tab (skips \x09 tab and \x0A newline)
+ * - \x0C: Form Feed (skips \x0D carriage return)
+ * - \x0E-\x1F: Shift Out to Unit Separator
+ * - \x7F: DELETE
+ *
+ * These characters can cause issues in logs, APIs, and downstream systems.
+ */
+export declare const CONTROL_CHARS_REGEX: RegExp;
+/**
+ * Configuration for response sanitization
+ *
+ * This configuration controls how the sanitization utility processes data:
+ * - HTML escaping is ALWAYS enabled (cannot be disabled for security)
+ * - Control character removal is configurable
+ * - String length limits are configurable
+ * - Object depth limits are configurable
+ */
+export interface SanitizationConfig {
+    /**
+     * Remove dangerous control characters (0x00-0x1F, 0x7F)
+     * Preserves safe formatting characters: \n (newline), \r (carriage return), \t (tab)
+     * @default true
+     */
+    removeControlChars: boolean;
+    /**
+     * Maximum string length before truncation (in characters)
+     * Prevents DOS attacks by limiting string size
+     * Set to 0 to disable truncation
+     * @default 10240
+     */
+    maxStringLength: number;
+    /**
+     * Maximum object depth to traverse
+     * Prevents stack overflow from deeply nested objects
+     * Objects deeper than this will be replaced with '[Max depth exceeded]'
+     * @default 50
+     */
+    maxDepth: number;
+}
+/**
+ * Default sanitization configuration
+ * Suitable for general-purpose API responses
+ *
+ * For specific use cases, create custom configs:
+ * - Processor responses: { maxStringLength: 50000, maxDepth: 50, removeControlChars: true }
+ * - Delivery responses: { maxStringLength: 20000, maxDepth: 30, removeControlChars: true }
+ */
+export declare const DEFAULT_SANITIZATION_CONFIG: SanitizationConfig;
+/**
+ * Deep sanitize an object, array, or primitive value
+ *
+ * This function recursively processes data structures:
+ * - Arrays: Sanitizes each element
+ * - Objects: Sanitizes both keys and values
+ * - Strings: Applies HTML escaping and other string sanitization
+ * - Primitives: Returns as-is (numbers, booleans, null, undefined)
+ *
+ * @param data - The data to sanitize (any type)
+ * @param config - Sanitization configuration (defaults to DEFAULT_SANITIZATION_CONFIG)
+ * @param depth - Current recursion depth (internal use, starts at 0)
+ * @returns Sanitized copy of the data
+ *
+ * @example Sanitize an object
+ * ```typescript
+ * const data = {
+ *   user: '<script>xss</script>',
+ *   count: 42,
+ *   active: true
+ * };
+ * const clean = sanitize(data);
+ * // Returns: { user: '&lt;script&gt;xss&lt;&#x2F;script&gt;', count: 42, active: true }
+ * ```
+ *
+ * @example Sanitize an array
+ * ```typescript
+ * const data = ['<b>item1</b>', '<i>item2</i>'];
+ * const clean = sanitize(data);
+ * // Returns: ['&lt;b&gt;item1&lt;&#x2F;b&gt;', '&lt;i&gt;item2&lt;&#x2F;i&gt;']
+ * ```
+ */
+export declare function sanitize<T>(data: T, config?: SanitizationConfig, depth?: number): T;
+/**
+ * Sanitize any response data to prevent XSS attacks and security vulnerabilities
+ *
+ * This is a convenience function that merges custom config with defaults.
+ * For direct control, use the `sanitize` function directly.
+ *
+ * This function:
+ * - Escapes HTML entities in all strings (ALWAYS, cannot be disabled)
+ * - Removes dangerous control characters (configurable)
+ * - Truncates overly long strings (configurable)
+ * - Handles nested objects/arrays recursively
+ * - Preserves data types (numbers, booleans, null)
+ *
+ * @param data - The data to sanitize (objects, arrays, primitives)
+ * @param config - Optional partial configuration (merged with defaults)
+ * @returns Sanitized copy of the data with same type
+ *
+ * @example Basic usage with defaults
+ * ```typescript
+ * const unsafe = { message: '<script>alert("xss")</script>' };
+ * const safe = sanitizeResponse(unsafe);
+ * // Result: { message: '&lt;script&gt;alert(&quot;xss&quot;)&lt;&#x2F;script&gt;' }
+ * ```
+ *
+ * @example Custom configuration for large payloads
+ * ```typescript
+ * const response = sanitizeResponse(processorData, {
+ *   maxStringLength: 50000,
+ *   maxDepth: 50,
+ *   removeControlChars: true
+ * });
+ * ```
+ *
+ * @example In a Koa controller
+ * ```typescript
+ * export class Controller {
+ *   async transform(ctx: Context) {
+ *     const result = await transformData(ctx.request.body);
+ *     ctx.body = sanitizeResponse(result);
+ *   }
+ * }
+ * ```
+ */
+export declare function sanitizeResponse<T>(data: T, config?: Partial<SanitizationConfig>): T;
+//# sourceMappingURL=sanitizer.d.ts.map

package/build/utils/sanitizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitizer.d.ts","sourceRoot":"","sources":["../../src/utils/sanitizer.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AAEH;;;;;;;;;;;;;;;;GAgBG;AAEH,eAAO,MAAM,mBAAmB,QAAsC,CAAC;AAEvE;;;;;;;;GAQG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;;OAIG;IACH,kBAAkB,EAAE,OAAO,CAAC;IAE5B;;;;;OAKG;IACH,eAAe,EAAE,MAAM,CAAC;IAExB;;;;;OAKG;IACH,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,2BAA2B,EAAE,kBAIzC,CAAC;AA2CF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EACxB,IAAI,EAAE,CAAC,EACP,MAAM,GAAE,kBAAgD,EACxD,KAAK,GAAE,MAAU,GAChB,CAAC,CAyCH;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAKpF"}

package/build/utils/sanitizer.js

@@ -0,0 +1,208 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_SANITIZATION_CONFIG = exports.CONTROL_CHARS_REGEX = void 0;
+exports.sanitize = sanitize;
+exports.sanitizeResponse = sanitizeResponse;
+const validator_1 = __importDefault(require("validator"));
+/**
+ * Response Sanitization Utility
+ *
+ * Provides comprehensive sanitization for API responses to prevent XSS attacks
+ * and other security vulnerabilities.
+ *
+ * Key Features:
+ * - HTML entity escaping (always enabled, uses validator library)
+ * - Control character removal (configurable)
+ * - String length truncation (configurable)
+ * - Deep object traversal (configurable depth)
+ * - Type preservation (numbers, booleans, null remain unchanged)
+ * - Non-destructive (returns new objects without mutating originals)
+ *
+ * @packageDocumentation
+ */
+/**
+ * Regular expression to match dangerous control characters
+ *
+ * Matches ASCII control characters (0x00-0x1F and 0x7F) EXCEPT:
+ * - \x09 (tab)
+ * - \x0A (newline)
+ * - \x0D (carriage return)
+ *
+ * Range breakdown:
+ * - \x00-\x08: NULL to BACKSPACE
+ * - \x0B: Vertical Tab (skips \x09 tab and \x0A newline)
+ * - \x0C: Form Feed (skips \x0D carriage return)
+ * - \x0E-\x1F: Shift Out to Unit Separator
+ * - \x7F: DELETE
+ *
+ * These characters can cause issues in logs, APIs, and downstream systems.
+ */
+// eslint-disable-next-line no-control-regex
+exports.CONTROL_CHARS_REGEX = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g;
+/**
+ * Default sanitization configuration
+ * Suitable for general-purpose API responses
+ *
+ * For specific use cases, create custom configs:
+ * - Processor responses: { maxStringLength: 50000, maxDepth: 50, removeControlChars: true }
+ * - Delivery responses: { maxStringLength: 20000, maxDepth: 30, removeControlChars: true }
+ */
+exports.DEFAULT_SANITIZATION_CONFIG = {
+    removeControlChars: true,
+    maxStringLength: 10240, // 10KB per string
+    maxDepth: 50,
+};
+/**
+ * Sanitize a single string value
+ *
+ * Processing order:
+ * 1. Remove control characters (if enabled)
+ * 2. Escape HTML entities (always applied)
+ * 3. Truncate if exceeds max length (if enabled)
+ *
+ * @param value - The string to sanitize
+ * @param config - Sanitization configuration
+ * @returns Sanitized string with HTML entities escaped
+ * @private
+ */
+function sanitizeString(value, config) {
+    if (typeof value !== 'string') {
+        return value;
+    }
+    let sanitized = value;
+    // Step 1: Remove control characters (except newline \n, carriage return \r, and tab \t)
+    // Control characters (0x00-0x1F, 0x7F) can break logs and cause security issues
+    // We preserve \n (0x0A), \r (0x0D), \t (0x09) for legitimate formatting
+    if (config.removeControlChars) {
+        sanitized = sanitized.replace(exports.CONTROL_CHARS_REGEX, '');
+    }
+    // Step 2: Escape HTML entities to prevent XSS attacks
+    // This is ALWAYS applied regardless of config
+    // Uses validator.escape() which converts: < > " ' & / to HTML entities
+    sanitized = validator_1.default.escape(sanitized);
+    // Step 3: Truncate long strings to prevent DOS attacks
+    // Adds '... [truncated]' suffix to indicate truncation
+    if (config.maxStringLength > 0 && sanitized.length > config.maxStringLength) {
+        sanitized = `${sanitized.substring(0, config.maxStringLength)}... [truncated]`;
+    }
+    return sanitized;
+}
+/**
+ * Deep sanitize an object, array, or primitive value
+ *
+ * This function recursively processes data structures:
+ * - Arrays: Sanitizes each element
+ * - Objects: Sanitizes both keys and values
+ * - Strings: Applies HTML escaping and other string sanitization
+ * - Primitives: Returns as-is (numbers, booleans, null, undefined)
+ *
+ * @param data - The data to sanitize (any type)
+ * @param config - Sanitization configuration (defaults to DEFAULT_SANITIZATION_CONFIG)
+ * @param depth - Current recursion depth (internal use, starts at 0)
+ * @returns Sanitized copy of the data
+ *
+ * @example Sanitize an object
+ * ```typescript
+ * const data = {
+ *   user: '<script>xss</script>',
+ *   count: 42,
+ *   active: true
+ * };
+ * const clean = sanitize(data);
+ * // Returns: { user: '&lt;script&gt;xss&lt;&#x2F;script&gt;', count: 42, active: true }
+ * ```
+ *
+ * @example Sanitize an array
+ * ```typescript
+ * const data = ['<b>item1</b>', '<i>item2</i>'];
+ * const clean = sanitize(data);
+ * // Returns: ['&lt;b&gt;item1&lt;&#x2F;b&gt;', '&lt;i&gt;item2&lt;&#x2F;i&gt;']
+ * ```
+ */
+function sanitize(data, config = exports.DEFAULT_SANITIZATION_CONFIG, depth = 0) {
+    // Handle null and undefined - return as-is
+    if (data === null || data === undefined) {
+        return data;
+    }
+    // Prevent infinite recursion by checking depth limit
+    // Replaces deeply nested data with a warning string
+    if (depth > config.maxDepth) {
+        return '[Max depth exceeded]';
+    }
+    // Handle arrays - recursively sanitize each element
+    if (Array.isArray(data)) {
+        return data.map((item) => sanitize(item, config, depth + 1));
+    }
+    // Handle strings - apply string-level sanitization
+    if (typeof data === 'string') {
+        return sanitizeString(data, config);
+    }
+    // Handle objects - sanitize both keys and values
+    if (typeof data === 'object') {
+        const sanitized = {};
+        // eslint-disable-next-line no-restricted-syntax
+        for (const [key, value] of Object.entries(data)) {
+            // Sanitize the key itself to prevent malicious property names
+            const sanitizedKey = sanitizeString(key, config);
+            // Recursively sanitize the value, incrementing depth
+            sanitized[sanitizedKey] = sanitize(value, config, depth + 1);
+        }
+        return sanitized;
+    }
+    // Return primitives as-is (numbers, booleans, bigints, symbols)
+    // These types don't need sanitization
+    return data;
+}
+/**
+ * Sanitize any response data to prevent XSS attacks and security vulnerabilities
+ *
+ * This is a convenience function that merges custom config with defaults.
+ * For direct control, use the `sanitize` function directly.
+ *
+ * This function:
+ * - Escapes HTML entities in all strings (ALWAYS, cannot be disabled)
+ * - Removes dangerous control characters (configurable)
+ * - Truncates overly long strings (configurable)
+ * - Handles nested objects/arrays recursively
+ * - Preserves data types (numbers, booleans, null)
+ *
+ * @param data - The data to sanitize (objects, arrays, primitives)
+ * @param config - Optional partial configuration (merged with defaults)
+ * @returns Sanitized copy of the data with same type
+ *
+ * @example Basic usage with defaults
+ * ```typescript
+ * const unsafe = { message: '<script>alert("xss")</script>' };
+ * const safe = sanitizeResponse(unsafe);
+ * // Result: { message: '&lt;script&gt;alert(&quot;xss&quot;)&lt;&#x2F;script&gt;' }
+ * ```
+ *
+ * @example Custom configuration for large payloads
+ * ```typescript
+ * const response = sanitizeResponse(processorData, {
+ *   maxStringLength: 50000,
+ *   maxDepth: 50,
+ *   removeControlChars: true
+ * });
+ * ```
+ *
+ * @example In a Koa controller
+ * ```typescript
+ * export class Controller {
+ *   async transform(ctx: Context) {
+ *     const result = await transformData(ctx.request.body);
+ *     ctx.body = sanitizeResponse(result);
+ *   }
+ * }
+ * ```
+ */
+function sanitizeResponse(data, config) {
+    return sanitize(data, {
+        ...exports.DEFAULT_SANITIZATION_CONFIG,
+        ...config,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sanitizer.js","sourceRoot":"","sources":["../../src/utils/sanitizer.ts"],"names":[],"mappings":"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","sourcesContent":["import validator from 'validator';\n\n/**\n * Response Sanitization Utility\n *\n * Provides comprehensive sanitization for API responses to prevent XSS attacks\n * and other security vulnerabilities.\n *\n * Key Features:\n * - HTML entity escaping (always enabled, uses validator library)\n * - Control character removal (configurable)\n * - String length truncation (configurable)\n * - Deep object traversal (configurable depth)\n * - Type preservation (numbers, booleans, null remain unchanged)\n * - Non-destructive (returns new objects without mutating originals)\n *\n * @packageDocumentation\n */\n\n/**\n * Regular expression to match dangerous control characters\n *\n * Matches ASCII control characters (0x00-0x1F and 0x7F) EXCEPT:\n * - \\x09 (tab)\n * - \\x0A (newline)\n * - \\x0D (carriage return)\n *\n * Range breakdown:\n * - \\x00-\\x08: NULL to BACKSPACE\n * - \\x0B: Vertical Tab (skips \\x09 tab and \\x0A newline)\n * - \\x0C: Form Feed (skips \\x0D carriage return)\n * - \\x0E-\\x1F: Shift Out to Unit Separator\n * - \\x7F: DELETE\n *\n * These characters can cause issues in logs, APIs, and downstream systems.\n */\n// eslint-disable-next-line no-control-regex\nexport const CONTROL_CHARS_REGEX = /[\\x00-\\x08\\x0B\\x0C\\x0E-\\x1F\\x7F]/g;\n\n/**\n * Configuration for response sanitization\n *\n * This configuration controls how the sanitization utility processes data:\n * - HTML escaping is ALWAYS enabled (cannot be disabled for security)\n * - Control character removal is configurable\n * - String length limits are configurable\n * - Object depth limits are configurable\n */\nexport interface SanitizationConfig {\n  /**\n   * Remove dangerous control characters (0x00-0x1F, 0x7F)\n   * Preserves safe formatting characters: \\n (newline), \\r (carriage return), \\t (tab)\n   * @default true\n   */\n  removeControlChars: boolean;\n\n  /**\n   * Maximum string length before truncation (in characters)\n   * Prevents DOS attacks by limiting string size\n   * Set to 0 to disable truncation\n   * @default 10240\n   */\n  maxStringLength: number;\n\n  /**\n   * Maximum object depth to traverse\n   * Prevents stack overflow from deeply nested objects\n   * Objects deeper than this will be replaced with '[Max depth exceeded]'\n   * @default 50\n   */\n  maxDepth: number;\n}\n\n/**\n * Default sanitization configuration\n * Suitable for general-purpose API responses\n *\n * For specific use cases, create custom configs:\n * - Processor responses: { maxStringLength: 50000, maxDepth: 50, removeControlChars: true }\n * - Delivery responses: { maxStringLength: 20000, maxDepth: 30, removeControlChars: true }\n */\nexport const DEFAULT_SANITIZATION_CONFIG: SanitizationConfig = {\n  removeControlChars: true,\n  maxStringLength: 10240, // 10KB per string\n  maxDepth: 50,\n};\n\n/**\n * Sanitize a single string value\n *\n * Processing order:\n * 1. Remove control characters (if enabled)\n * 2. Escape HTML entities (always applied)\n * 3. Truncate if exceeds max length (if enabled)\n *\n * @param value - The string to sanitize\n * @param config - Sanitization configuration\n * @returns Sanitized string with HTML entities escaped\n * @private\n */\nfunction sanitizeString(value: string, config: SanitizationConfig): string {\n  if (typeof value !== 'string') {\n    return value;\n  }\n\n  let sanitized = value;\n\n  // Step 1: Remove control characters (except newline \\n, carriage return \\r, and tab \\t)\n  // Control characters (0x00-0x1F, 0x7F) can break logs and cause security issues\n  // We preserve \\n (0x0A), \\r (0x0D), \\t (0x09) for legitimate formatting\n  if (config.removeControlChars) {\n    sanitized = sanitized.replace(CONTROL_CHARS_REGEX, '');\n  }\n\n  // Step 2: Escape HTML entities to prevent XSS attacks\n  // This is ALWAYS applied regardless of config\n  // Uses validator.escape() which converts: < > \" ' & / to HTML entities\n  sanitized = validator.escape(sanitized);\n\n  // Step 3: Truncate long strings to prevent DOS attacks\n  // Adds '... [truncated]' suffix to indicate truncation\n  if (config.maxStringLength > 0 && sanitized.length > config.maxStringLength) {\n    sanitized = `${sanitized.substring(0, config.maxStringLength)}... [truncated]`;\n  }\n\n  return sanitized;\n}\n\n/**\n * Deep sanitize an object, array, or primitive value\n *\n * This function recursively processes data structures:\n * - Arrays: Sanitizes each element\n * - Objects: Sanitizes both keys and values\n * - Strings: Applies HTML escaping and other string sanitization\n * - Primitives: Returns as-is (numbers, booleans, null, undefined)\n *\n * @param data - The data to sanitize (any type)\n * @param config - Sanitization configuration (defaults to DEFAULT_SANITIZATION_CONFIG)\n * @param depth - Current recursion depth (internal use, starts at 0)\n * @returns Sanitized copy of the data\n *\n * @example Sanitize an object\n * ```typescript\n * const data = {\n *   user: '<script>xss</script>',\n *   count: 42,\n *   active: true\n * };\n * const clean = sanitize(data);\n * // Returns: { user: '&lt;script&gt;xss&lt;&#x2F;script&gt;', count: 42, active: true }\n * ```\n *\n * @example Sanitize an array\n * ```typescript\n * const data = ['<b>item1</b>', '<i>item2</i>'];\n * const clean = sanitize(data);\n * // Returns: ['&lt;b&gt;item1&lt;&#x2F;b&gt;', '&lt;i&gt;item2&lt;&#x2F;i&gt;']\n * ```\n */\nexport function sanitize<T>(\n  data: T,\n  config: SanitizationConfig = DEFAULT_SANITIZATION_CONFIG,\n  depth: number = 0,\n): T {\n  // Handle null and undefined - return as-is\n  if (data === null || data === undefined) {\n    return data;\n  }\n\n  // Prevent infinite recursion by checking depth limit\n  // Replaces deeply nested data with a warning string\n  if (depth > config.maxDepth) {\n    return '[Max depth exceeded]' as T;\n  }\n\n  // Handle arrays - recursively sanitize each element\n  if (Array.isArray(data)) {\n    return data.map((item) => sanitize(item, config, depth + 1)) as T;\n  }\n\n  // Handle strings - apply string-level sanitization\n  if (typeof data === 'string') {\n    return sanitizeString(data, config) as T;\n  }\n\n  // Handle objects - sanitize both keys and values\n  if (typeof data === 'object') {\n    const sanitized: Record<string, unknown> = {};\n\n    // eslint-disable-next-line no-restricted-syntax\n    for (const [key, value] of Object.entries(data)) {\n      // Sanitize the key itself to prevent malicious property names\n      const sanitizedKey = sanitizeString(key, config);\n\n      // Recursively sanitize the value, incrementing depth\n      sanitized[sanitizedKey] = sanitize(value, config, depth + 1);\n    }\n\n    return sanitized as T;\n  }\n\n  // Return primitives as-is (numbers, booleans, bigints, symbols)\n  // These types don't need sanitization\n  return data;\n}\n\n/**\n * Sanitize any response data to prevent XSS attacks and security vulnerabilities\n *\n * This is a convenience function that merges custom config with defaults.\n * For direct control, use the `sanitize` function directly.\n *\n * This function:\n * - Escapes HTML entities in all strings (ALWAYS, cannot be disabled)\n * - Removes dangerous control characters (configurable)\n * - Truncates overly long strings (configurable)\n * - Handles nested objects/arrays recursively\n * - Preserves data types (numbers, booleans, null)\n *\n * @param data - The data to sanitize (objects, arrays, primitives)\n * @param config - Optional partial configuration (merged with defaults)\n * @returns Sanitized copy of the data with same type\n *\n * @example Basic usage with defaults\n * ```typescript\n * const unsafe = { message: '<script>alert(\"xss\")</script>' };\n * const safe = sanitizeResponse(unsafe);\n * // Result: { message: '&lt;script&gt;alert(&quot;xss&quot;)&lt;&#x2F;script&gt;' }\n * ```\n *\n * @example Custom configuration for large payloads\n * ```typescript\n * const response = sanitizeResponse(processorData, {\n *   maxStringLength: 50000,\n *   maxDepth: 50,\n *   removeControlChars: true\n * });\n * ```\n *\n * @example In a Koa controller\n * ```typescript\n * export class Controller {\n *   async transform(ctx: Context) {\n *     const result = await transformData(ctx.request.body);\n *     ctx.body = sanitizeResponse(result);\n *   }\n * }\n * ```\n */\nexport function sanitizeResponse<T>(data: T, config?: Partial<SanitizationConfig>): T {\n  return sanitize(data, {\n    ...DEFAULT_SANITIZATION_CONFIG,\n    ...config,\n  });\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rudderstack/integrations-lib",
-  "version": "0.2.59",
+  "version": "0.2.60",
   "description": "",
   "main": "build/index.js",
   "module": "build/index.js",
@@ -55,11 +55,13 @@
     "sqlstring": "^2.3.3",
     "tslib": "^2.4.0",
     "uuid": "^11.0.5",
+    "validator": "^13.15.26",
     "winston": "^3.11.0",
     "zod": "^3.24.2"
   },
   "devDependencies": {
     "@commitlint/config-conventional": "^18.5.0",
+    "@linear/sdk": "^68.0.0",
     "@types/get-value": "^3.0.3",
     "@types/jest": "^29.5.4",
     "@types/lodash": "^4.14.195",
@@ -67,6 +69,7 @@
     "@types/set-value": "^4.0.1",
     "@types/sha256": "^0.2.0",
     "@types/sqlstring": "^2.3.2",
+    "@types/validator": "^13.15.10",
     "@typescript-eslint/eslint-plugin": "^6.20.0",
     "@typescript-eslint/parser": "^6.20.0",
     "axios-mock-adapter": "^2.1.0",