timonel 2.10.2 → 2.11.0

package/dist/lib/utils/helmYamlSerializer.js

@@ -1,14 +1,17 @@
 import * as jsYaml from 'js-yaml';
-const HELM_EXPRESSION_PATTERNS = [
-    /\{\{\s*[^}]+\s*\}\}/g,
-    /\{\{\s*include\s+[^}]+\s*\}\}/g,
-    /\{\{\s*if\s+[^}]+\s*\}\}/g,
-    /\{\{\s*else\s*\}\}/g,
-    /\{\{\s*end\s*\}\}/g,
-    /\{\{\s*range\s+[^}]+\s*\}\}/g,
-    /\{\{\s*with\s+[^}]+\s*\}\}/g,
-    /\{\{\s*\$[^}]+\s*\}\}/g,
-    /\{\{\s*[^}]*\|\s*[^}]+\s*\}\}/g,
+const _HELM_EXPRESSION_PATTERNS = [
+    /\{\{-?\s*define\s+[^}]+\s*-?\}\}[\s\S]*?\{\{-?\s*end\s*-?\}\}/g,
+    /\{\{[^}]*\{\{[^}]*\}\}[^}]*\}\}/g,
+    /\{\{\/\*[\s\S]*?\*\/\}\}/g,
+    /\{\{-?[\s\S]*?-?\}\}/g,
+];
+const COMPILED_PATTERNS = [
+    { regex: /\{\{-?\s*define\s+[^}]+\s*-?\}\}[\s\S]*?\{\{-?\s*end\s*-?\}\}/g, type: 'block' },
+    { regex: /\{\{[^}]*\{\{[^}]*\}\}[^}]*\}\}/g, type: 'nested' },
+    { regex: /\{\{\/\*[\s\S]*?\*\/\}\}/g, type: 'comment' },
+    { regex: /\{\{-?[\s\S]*?-?\}\}/g, type: 'action-trimmed' },
+    { regex: /\{\{`[\s\S]*?`\}\}/g, type: 'raw' },
+    { regex: /\{\{\s*include\s+"[^"]+"\s+[^}]+\s*\}\}/g, type: 'include-context' },
 ];
 function createHelmExpression(value) {
     return {
@@ -22,24 +25,42 @@ function isHelmExpression(value) {
         '__helmExpression' in value &&
         value.__helmExpression === true);
 }
-function containsHelmExpression(str) {
-    return HELM_EXPRESSION_PATTERNS.some((pattern) => pattern.test(str));
+function detectHelmExpressions(str) {
+    const matches = [];
+    for (const { regex, type } of COMPILED_PATTERNS) {
+        regex.lastIndex = 0;
+        let result;
+        while ((result = regex.exec(str)) !== null) {
+            matches.push({
+                type,
+                expression: result[0],
+                start: result.index,
+                end: result.index + result[0].length,
+            });
+            if (result.index === regex.lastIndex)
+                regex.lastIndex++;
+        }
+    }
+    return matches.sort((a, b) => a.start - b.start);
 }
-function preprocessHelmExpressions(obj) {
+function preprocessHelmExpressions(obj, depth = 0) {
+    if (depth > 100) {
+        throw new Error('Maximum recursion depth exceeded during Helm preprocessing');
+    }
     if (typeof obj === 'string') {
-        if (containsHelmExpression(obj)) {
+        if (detectHelmExpressions(obj).length > 0) {
             return createHelmExpression(obj);
         }
         return obj;
     }
     if (Array.isArray(obj)) {
-        return obj.map(preprocessHelmExpressions);
+        return obj.map((item) => preprocessHelmExpressions(item, depth + 1));
     }
-    if (obj && typeof obj === 'object') {
+    if (typeof obj === 'object' && obj !== null) {
         const result = {};
         for (const [key, value] of Object.entries(obj)) {
             Object.defineProperty(result, key, {
-                value: preprocessHelmExpressions(value),
+                value: preprocessHelmExpressions(value, depth + 1),
                 writable: true,
                 enumerable: true,
                 configurable: true,
@@ -55,26 +76,28 @@ function helmAwareReplacer(key, value) {
     }
     return value;
 }
+function postProcessHelmExpressions(yaml) {
+    let processed = yaml;
+    processed = processed.replace(/'(\{\{[^}]*\}\})'/g, '$1');
+    processed = processed.replace(/"(\{\{[^}]*\}\})"/g, '$1');
+    processed = processed.replace(/'(\{\{[^}]*\\"[^}]*\}\})'/g, '$1');
+    processed = processed.replace(/"(\{\{[^}]*\\"[^}]*\}\})"/g, '$1');
+    processed = processed.replace(/\\(\{\{[^}]+\}\})/g, '$1');
+    return processed;
+}
 export function dumpHelmAwareYaml(obj, options = {}) {
     const preprocessed = preprocessHelmExpressions(obj);
-    const helmOptions = {
+    const dumpOptions = {
         forceQuotes: false,
         lineWidth: options.lineWidth ?? 0,
         flowLevel: options.flowLevel ?? -1,
         replacer: helmAwareReplacer,
         ...options,
     };
-    let yamlOutput = jsYaml.dump(preprocessed, helmOptions);
+    let yamlOutput = jsYaml.dump(preprocessed, dumpOptions);
     yamlOutput = postProcessHelmExpressions(yamlOutput);
     return yamlOutput;
 }
-function postProcessHelmExpressions(yaml) {
-    let processed = yaml;
-    processed = processed.replace(/'(\{\{[^}]*\}\})'/g, '$1');
-    processed = processed.replace(/"(\{\{[^}]*\}\})"/g, '$1');
-    processed = processed.replace(/\\(\{\{[^}]*\}\})/g, '$1');
-    return processed;
-}
 export function stringify(obj, options = {}) {
     const jsYamlOptions = {
         lineWidth: options.lineWidth ?? 0,
@@ -82,7 +105,280 @@ export function stringify(obj, options = {}) {
     };
     return dumpHelmAwareYaml(obj, jsYamlOptions);
 }
-export function validateHelmExpressions(yaml) {
-    const quotedHelmExpressions = [/'(\{\{[^}]*\}\})'/g, /"(\{\{[^}]*\}\})"/g];
-    return !quotedHelmExpressions.some((pattern) => pattern.test(yaml));
+export function validateHelmYaml(yaml) {
+    const errors = [];
+    const warnings = [];
+    const expressions = parseHelmExpressions(yaml);
+    for (const expr of expressions) {
+        try {
+            validateHelmSyntax(expr.expression);
+        }
+        catch (err) {
+            errors.push({
+                type: 'syntax',
+                message: err instanceof Error ? err.message : 'Unknown syntax error',
+                line: expr.startLine,
+                column: expr.startCol,
+                expression: expr.expression,
+            });
+        }
+    }
+    checkCommonIssues(yaml, warnings);
+    checkQuotedExpressions(yaml, warnings);
+    const expressionsByType = expressions.reduce((acc, expr) => {
+        acc[expr.type] = (acc[expr.type] || 0) + 1;
+        return acc;
+    }, {});
+    const complexity = calculateComplexity(expressions.map((expr) => ({
+        type: expr.type,
+        expression: expr.expression,
+        start: 0,
+        end: 0,
+    })));
+    return {
+        isValid: errors.length === 0,
+        errors,
+        warnings,
+        statistics: {
+            totalExpressions: expressions.length,
+            expressionsByType,
+            complexity,
+        },
+    };
+}
+export function parseHelmExpressions(content) {
+    const expressions = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (!line)
+            continue;
+        for (const { regex, type } of COMPILED_PATTERNS) {
+            let match;
+            regex.lastIndex = 0;
+            while ((match = regex.exec(line)) !== null) {
+                expressions.push({
+                    type,
+                    expression: match[0],
+                    startLine: i + 1,
+                    startCol: match.index + 1,
+                    endLine: i + 1,
+                    endCol: match.index + match[0].length + 1,
+                });
+                if (match.index === regex.lastIndex)
+                    regex.lastIndex++;
+            }
+        }
+    }
+    return expressions;
+}
+function validateHelmSyntax(expression) {
+    const content = expression.replace(/^\{\{-?\s*/, '').replace(/\s*-?\}\}$/, '');
+    if (!isBalanced(content, '(', ')')) {
+        throw new Error('Unbalanced parentheses in Helm expression');
+    }
+    if (!isQuotesBalanced(content)) {
+        throw new Error('Unbalanced quotes in Helm expression');
+    }
+    validateFunctionCalls(content);
+}
+function isBalanced(str, open, close) {
+    let count = 0;
+    for (const c of str) {
+        if (c === open)
+            count++;
+        else if (c === close)
+            count--;
+        if (count < 0)
+            return false;
+    }
+    return count === 0;
+}
+function isQuotesBalanced(str) {
+    let singleQuoteOpen = false;
+    let doubleQuoteOpen = false;
+    let escaped = false;
+    for (const c of str) {
+        if (c === '\\' && !escaped) {
+            escaped = true;
+            continue;
+        }
+        if ((c === "'" && !doubleQuoteOpen && !escaped) ||
+            (c === '"' && !singleQuoteOpen && !escaped)) {
+            if (c === "'")
+                singleQuoteOpen = !singleQuoteOpen;
+            else
+                doubleQuoteOpen = !doubleQuoteOpen;
+        }
+        escaped = false;
+    }
+    return !singleQuoteOpen && !doubleQuoteOpen;
+}
+function validateFunctionCalls(_content) {
+}
+function checkCommonIssues(yaml, warnings) {
+    const deprecatedFunctions = ['template', 'default'];
+    for (const func of deprecatedFunctions) {
+        const pattern = new RegExp(`\\{\\{[^}]*\\b${func}\\b[^}]*\\}\\}`, 'g');
+        let match;
+        while ((match = pattern.exec(yaml)) !== null) {
+            warnings.push({
+                type: 'semantic',
+                message: `Function '${func}' is deprecated`,
+                expression: match[0],
+                suggestion: `Consider avoiding deprecated function '${func}'`,
+            });
+        }
+    }
+}
+function checkQuotedExpressions(yaml, warnings) {
+    const quotedPatterns = [/'\(\\{\\{[^}]+\\}\\}\)'/g, /"\(\\{\\{[^}]+\\}\\}\)"/g];
+    for (const pattern of quotedPatterns) {
+        let match;
+        pattern.lastIndex = 0;
+        while ((match = pattern.exec(yaml)) !== null) {
+            warnings.push({
+                type: 'semantic',
+                message: 'Helm expression should not be quoted',
+                expression: match[0],
+                suggestion: `Remove quotes around: ${match[1]}`,
+            });
+        }
+    }
+}
+function calculateComplexity(expressions) {
+    let score = 0;
+    for (const expr of expressions) {
+        switch (expr.type) {
+            case 'block':
+                score += 5;
+                break;
+            case 'nested':
+                score += 4;
+                break;
+            case 'comment':
+                score += 0;
+                break;
+            default:
+                score += 1;
+        }
+    }
+    return score;
+}
+export function prettifyHelmTemplate(yaml, options = {}) {
+    const { indentSize = 2, alignExpressions = true, preserveComments: _preserveComments = true, maxLineWidth = 120, sortKeys = false, groupHelpers = true, } = options;
+    let formatted = yaml;
+    if (groupHelpers) {
+        formatted = groupHelmHelpers(formatted);
+    }
+    if (alignExpressions) {
+        formatted = alignTemplateExpressions(formatted, indentSize);
+    }
+    formatted = formatConditionalBlocks(formatted, indentSize);
+    formatted = formatLoopBlocks(formatted, indentSize);
+    formatted = wrapLongLines(formatted, maxLineWidth);
+    if (sortKeys) {
+        formatted = sortYamlKeys(formatted);
+    }
+    return formatted;
+}
+function alignTemplateExpressions(yaml, _indentSize) {
+    const lines = yaml.split('\n');
+    const aligned = [];
+    for (const line of lines) {
+        const expressions = line.match(/\{\{[^}]*\}\}/g);
+        if (expressions && expressions.length > 1) {
+            const baseIndent = (line.match(/^\s*/) || [''])[0];
+            const content = line.trim();
+            const parts = content.split(/(\{\{[^}]*\}\})/);
+            let alignedLine = baseIndent;
+            for (let i = 0; i < parts.length; i++) {
+                alignedLine += parts[i] || '';
+                const nextPart = parts[i + 1];
+                if (i < parts.length - 1 && nextPart && nextPart.startsWith('{{')) {
+                    alignedLine += ' ';
+                }
+            }
+            aligned.push(alignedLine);
+        }
+        else {
+            aligned.push(line);
+        }
+    }
+    return aligned.join('\n');
+}
+function groupHelmHelpers(yaml) {
+    const lines = yaml.split('\n');
+    const groups = {
+        comments: [],
+        definitions: [],
+        conditionals: [],
+        loops: [],
+        other: [],
+    };
+    for (const line of lines) {
+        if (line.includes('{{/*')) {
+            groups.comments.push(line);
+        }
+        else if (line.includes('{{- define')) {
+            groups.definitions.push(line);
+        }
+        else if (/\{\{\s*(if|else|end)\s/.test(line)) {
+            groups.conditionals.push(line);
+        }
+        else if (/\{\{\s*(range|with)\s/.test(line)) {
+            groups.loops.push(line);
+        }
+        else {
+            groups.other.push(line);
+        }
+    }
+    return [
+        ...groups.comments,
+        ...groups.definitions,
+        ...groups.conditionals,
+        ...groups.loops,
+        ...groups.other,
+    ].join('\n');
+}
+function formatConditionalBlocks(yaml, indentSize) {
+    const indent = ' '.repeat(indentSize);
+    return yaml
+        .replace(/(\{\{\s*if\s+[^}]+\}\})/g, '$1\n' + indent)
+        .replace(/(\{\{\s*else\s*\}\})/g, '$1\n' + indent)
+        .replace(/(\{\{\s*end\s*\}\})/g, '\n$1');
+}
+function formatLoopBlocks(yaml, indentSize) {
+    const indent = ' '.repeat(indentSize);
+    return yaml
+        .replace(/(\{\{\s*range\s+[^}]+\}\})/g, '$1\n' + indent)
+        .replace(/(\{\{\s*with\s+[^}]+\}\})/g, '$1\n' + indent);
+}
+function wrapLongLines(yaml, maxLineWidth) {
+    if (maxLineWidth <= 0)
+        return yaml;
+    const lines = yaml.split('\n');
+    const wrapped = [];
+    for (const line of lines) {
+        if (line.length <= maxLineWidth) {
+            wrapped.push(line);
+            continue;
+        }
+        let remaining = line;
+        while (remaining.length > maxLineWidth) {
+            let wrapIndex = remaining.lastIndexOf(' ', maxLineWidth);
+            if (wrapIndex === -1)
+                wrapIndex = maxLineWidth;
+            wrapped.push(remaining.slice(0, wrapIndex));
+            remaining = remaining.slice(wrapIndex).trim();
+        }
+        if (remaining.length > 0) {
+            wrapped.push(remaining);
+        }
+    }
+    return wrapped.join('\n');
+}
+function sortYamlKeys(yaml) {
+    return yaml;
 }
+export { createHelmExpression, isHelmExpression, detectHelmExpressions, preprocessHelmExpressions, postProcessHelmExpressions, };

package/dist/lib/utils/logger.d.ts

@@ -0,0 +1,49 @@
+export declare enum LogLevel {
+    FATAL = 60,
+    ERROR = 50,
+    WARN = 40,
+    INFO = 30,
+    DEBUG = 20,
+    TRACE = 10
+}
+export interface LoggerConfig {
+    level: LogLevel;
+    silent: boolean;
+    service: string;
+    environment: string;
+    prettyPrint: boolean;
+    base?: Record<string, unknown>;
+}
+export interface LogContext {
+    correlationId?: string;
+    userId?: string;
+    operation?: string;
+    component?: string;
+    chartName?: string;
+    [key: string]: unknown;
+}
+export declare class TimonelLogger {
+    private readonly logger;
+    private readonly config;
+    private static readonly SENSITIVE_FIELDS;
+    constructor(config?: Partial<LoggerConfig>);
+    private mapLogLevel;
+    private requestSerializer;
+    private responseSerializer;
+    fatal(message: string, context?: LogContext): void;
+    error(message: string, context?: LogContext): void;
+    warn(message: string, context?: LogContext): void;
+    info(message: string, context?: LogContext): void;
+    debug(message: string, context?: LogContext): void;
+    trace(message: string, context?: LogContext): void;
+    private log;
+    private sanitizeContext;
+    private sanitizeNestedObject;
+    child(context: LogContext): TimonelLogger;
+    time(operation: string): () => void;
+    setLevel(level: LogLevel): void;
+    setSilent(silent: boolean): void;
+    flush(): Promise<void>;
+}
+export declare const logger: TimonelLogger;
+export declare function createLogger(component: string, additionalConfig?: Partial<LoggerConfig>): TimonelLogger;