timonel 2.10.1 → 2.11.0

package/dist/lib/utils/logger.js

@@ -0,0 +1,418 @@
+import pino from 'pino';
+import { SecurityUtils } from '../security.js';
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["FATAL"] = 60] = "FATAL";
+    LogLevel[LogLevel["ERROR"] = 50] = "ERROR";
+    LogLevel[LogLevel["WARN"] = 40] = "WARN";
+    LogLevel[LogLevel["INFO"] = 30] = "INFO";
+    LogLevel[LogLevel["DEBUG"] = 20] = "DEBUG";
+    LogLevel[LogLevel["TRACE"] = 10] = "TRACE";
+})(LogLevel || (LogLevel = {}));
+export class TimonelLogger {
+    constructor(config = {}) {
+        this.config = {
+            level: LogLevel.INFO,
+            silent: false,
+            service: 'timonel',
+            environment: process.env.NODE_ENV || 'development',
+            prettyPrint: process.env.NODE_ENV !== 'production',
+            ...config,
+        };
+        const pinoOptions = {
+            level: this.mapLogLevel(this.config.level),
+            enabled: !this.config.silent,
+            base: {
+                service: this.config.service,
+                environment: this.config.environment,
+                ...this.config.base,
+            },
+            timestamp: pino.stdTimeFunctions.isoTime,
+            redact: {
+                paths: [
+                    'password',
+                    'passphrase',
+                    'secret',
+                    'secrets',
+                    'token',
+                    'accessToken',
+                    'refreshToken',
+                    'idToken',
+                    'apiKey',
+                    'api_key',
+                    'clientSecret',
+                    'client_secret',
+                    'privateKey',
+                    'private_key',
+                    'sshKey',
+                    'ssh_key',
+                    'credentials',
+                    'authorization',
+                    'sessionId',
+                    'session_id',
+                    'sessionToken',
+                    'session_token',
+                    'bearer',
+                    'auth',
+                    'authToken',
+                    'auth_token',
+                    'jwt',
+                    'jwtToken',
+                    'jwt_token',
+                    'oauth',
+                    'oauthToken',
+                    'oauth_token',
+                    'key',
+                    'keys',
+                    'cert',
+                    'certificate',
+                    'certificates',
+                    'pem',
+                    'p12',
+                    'pfx',
+                    '*.password',
+                    '*.passphrase',
+                    '*.secret',
+                    '*.secrets',
+                    '*.token',
+                    '*.accessToken',
+                    '*.refreshToken',
+                    '*.idToken',
+                    '*.apiKey',
+                    '*.api_key',
+                    '*.clientSecret',
+                    '*.client_secret',
+                    '*.privateKey',
+                    '*.private_key',
+                    '*.sshKey',
+                    '*.ssh_key',
+                    '*.credentials',
+                    '*.authorization',
+                    '*.sessionId',
+                    '*.session_id',
+                    '*.sessionToken',
+                    '*.session_token',
+                    '*.bearer',
+                    '*.auth',
+                    '*.authToken',
+                    '*.auth_token',
+                    '*.jwt',
+                    '*.jwtToken',
+                    '*.jwt_token',
+                    '*.oauth',
+                    '*.oauthToken',
+                    '*.oauth_token',
+                    '*.key',
+                    '*.keys',
+                    '*.cert',
+                    '*.certificate',
+                    '*.certificates',
+                    '*.pem',
+                    '*.p12',
+                    '*.pfx',
+                    'req.headers.authorization',
+                    'req.headers.cookie',
+                    'req.headers.cookies',
+                    'req.headers["set-cookie"]',
+                    'req.headers["authorization"]',
+                    'req.headers["x-api-key"]',
+                    'req.headers["x-auth-token"]',
+                    'res.headers["set-cookie"]',
+                    'res.headers["authorization"]',
+                    'body.password',
+                    'body.token',
+                    'body.apiKey',
+                    'body.api_key',
+                    'body.secret',
+                    'query.password',
+                    'query.token',
+                    'query.apiKey',
+                    'query.secret',
+                    'config.password',
+                    'config.secret',
+                    'config.clientSecret',
+                    'config.privateKey',
+                    'config.apiKey',
+                ],
+                censor: '[REDACTED]',
+            },
+            serializers: {
+                err: pino.stdSerializers.err,
+                error: pino.stdSerializers.err,
+                req: this.requestSerializer,
+                res: this.responseSerializer,
+            },
+        };
+        if (this.config.prettyPrint && this.config.environment === 'development') {
+            this.logger = pino({
+                ...pinoOptions,
+                transport: {
+                    target: 'pino-pretty',
+                    options: {
+                        colorize: true,
+                        translateTime: 'HH:MM:ss.l',
+                        ignore: 'pid,hostname',
+                        messageFormat: '{service}[{component}]: {msg}',
+                    },
+                },
+            });
+        }
+        else {
+            this.logger = pino(pinoOptions);
+        }
+    }
+    mapLogLevel(level) {
+        switch (level) {
+            case LogLevel.FATAL:
+                return 'fatal';
+            case LogLevel.ERROR:
+                return 'error';
+            case LogLevel.WARN:
+                return 'warn';
+            case LogLevel.INFO:
+                return 'info';
+            case LogLevel.DEBUG:
+                return 'debug';
+            case LogLevel.TRACE:
+                return 'trace';
+            default:
+                return 'info';
+        }
+    }
+    requestSerializer(req) {
+        if (!req || typeof req !== 'object')
+            return {};
+        const request = req;
+        return {
+            method: request.method,
+            url: SecurityUtils.sanitizeLogMessage(request.url || ''),
+            headers: {
+                'user-agent': request.headers?.['user-agent'],
+                'content-type': request.headers?.['content-type'],
+            },
+            remoteAddress: request.remoteAddress,
+            remotePort: request.remotePort,
+        };
+    }
+    responseSerializer(res) {
+        if (!res || typeof res !== 'object')
+            return {};
+        const response = res;
+        return {
+            statusCode: response.statusCode,
+            headers: {
+                'content-type': response.headers?.['content-type'],
+                'content-length': response.headers?.['content-length'],
+            },
+        };
+    }
+    fatal(message, context) {
+        this.log(LogLevel.FATAL, message, context);
+    }
+    error(message, context) {
+        this.log(LogLevel.ERROR, message, context);
+    }
+    warn(message, context) {
+        this.log(LogLevel.WARN, message, context);
+    }
+    info(message, context) {
+        this.log(LogLevel.INFO, message, context);
+    }
+    debug(message, context) {
+        this.log(LogLevel.DEBUG, message, context);
+    }
+    trace(message, context) {
+        this.log(LogLevel.TRACE, message, context);
+    }
+    log(level, message, context) {
+        if (this.config.silent || level < this.config.level) {
+            return;
+        }
+        const sanitizedMessage = SecurityUtils.sanitizeLogMessage(message);
+        const sanitizedContext = context ? this.sanitizeContext(context) : {};
+        const logEntry = {
+            ...sanitizedContext,
+            timestamp: new Date().toISOString(),
+        };
+        switch (level) {
+            case LogLevel.FATAL:
+                this.logger.fatal(logEntry, sanitizedMessage);
+                break;
+            case LogLevel.ERROR:
+                this.logger.error(logEntry, sanitizedMessage);
+                break;
+            case LogLevel.WARN:
+                this.logger.warn(logEntry, sanitizedMessage);
+                break;
+            case LogLevel.INFO:
+                this.logger.info(logEntry, sanitizedMessage);
+                break;
+            case LogLevel.DEBUG:
+                this.logger.debug(logEntry, sanitizedMessage);
+                break;
+            case LogLevel.TRACE:
+                this.logger.trace(logEntry, sanitizedMessage);
+                break;
+        }
+    }
+    sanitizeContext(context) {
+        const sanitized = {};
+        for (const [key, value] of Object.entries(context)) {
+            if (TimonelLogger.SENSITIVE_FIELDS.has(key.toLowerCase())) {
+                sanitized[key] = '[REDACTED]';
+            }
+            else if (typeof value === 'string') {
+                sanitized[key] = SecurityUtils.sanitizeLogMessage(value);
+            }
+            else if (value && typeof value === 'object') {
+                sanitized[key] = this.sanitizeNestedObject(value, 2);
+            }
+            else {
+                sanitized[key] = value;
+            }
+        }
+        return sanitized;
+    }
+    sanitizeNestedObject(obj, depth) {
+        if (depth <= 0 || !obj || typeof obj !== 'object') {
+            return obj;
+        }
+        const sanitized = {};
+        for (const [key, value] of Object.entries(obj)) {
+            if (typeof value === 'string') {
+                sanitized[key] = SecurityUtils.sanitizeLogMessage(value);
+            }
+            else if (value && typeof value === 'object') {
+                sanitized[key] = this.sanitizeNestedObject(value, depth - 1);
+            }
+            else {
+                sanitized[key] = value;
+            }
+        }
+        return sanitized;
+    }
+    child(context) {
+        const sanitizedContext = this.sanitizeContext(context);
+        const childLogger = new TimonelLogger(this.config);
+        Object.defineProperty(childLogger, 'logger', {
+            value: this.logger.child(sanitizedContext),
+            writable: false,
+            enumerable: false,
+            configurable: false,
+        });
+        return childLogger;
+    }
+    time(operation) {
+        const start = process.hrtime.bigint();
+        return () => {
+            const end = process.hrtime.bigint();
+            const duration = Number(end - start) / 1000000;
+            this.info('Operation completed', {
+                operation: SecurityUtils.sanitizeLogMessage(operation),
+                duration_ms: Math.round(duration * 100) / 100,
+                performance: 'timing',
+            });
+        };
+    }
+    setLevel(level) {
+        this.config.level = level;
+        this.logger.level = this.mapLogLevel(level);
+    }
+    setSilent(silent) {
+        this.config.silent = silent;
+        if (silent) {
+            this.logger.level = 'silent';
+        }
+        else {
+            this.logger.level = this.mapLogLevel(this.config.level);
+        }
+    }
+    async flush() {
+        return new Promise((resolve) => {
+            if (typeof this.logger.flush === 'function') {
+                this.logger.flush(() => resolve());
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+}
+TimonelLogger.SENSITIVE_FIELDS = new Set([
+    'password',
+    'passphrase',
+    'secret',
+    'secrets',
+    'token',
+    'accessToken',
+    'refreshToken',
+    'idToken',
+    'apiKey',
+    'api_key',
+    'clientSecret',
+    'client_secret',
+    'privateKey',
+    'private_key',
+    'sshKey',
+    'ssh_key',
+    'credentials',
+    'authorization',
+    'sessionId',
+    'session_id',
+    'sessionToken',
+    'session_token',
+    'bearer',
+    'auth',
+    'authToken',
+    'auth_token',
+    'jwt',
+    'jwtToken',
+    'jwt_token',
+    'oauth',
+    'oauthToken',
+    'oauth_token',
+    'key',
+    'keys',
+    'cert',
+    'certificate',
+    'certificates',
+    'pem',
+    'p12',
+    'pfx',
+]);
+export const logger = new TimonelLogger({
+    level: getLogLevelFromEnv(),
+    silent: process.env.TIMONEL_SILENT === 'true',
+    service: 'timonel',
+    environment: process.env.NODE_ENV || 'development',
+});
+export function createLogger(component, additionalConfig) {
+    return new TimonelLogger({
+        ...additionalConfig,
+        service: 'timonel',
+        base: {
+            component: SecurityUtils.sanitizeLogMessage(component),
+            ...additionalConfig?.base,
+        },
+    });
+}
+function getLogLevelFromEnv() {
+    const envLevel = process.env.LOG_LEVEL?.toUpperCase();
+    switch (envLevel) {
+        case 'FATAL':
+            return LogLevel.FATAL;
+        case 'ERROR':
+            return LogLevel.ERROR;
+        case 'WARN':
+        case 'WARNING':
+            return LogLevel.WARN;
+        case 'INFO':
+            return LogLevel.INFO;
+        case 'DEBUG':
+            return LogLevel.DEBUG;
+        case 'TRACE':
+            return LogLevel.TRACE;
+        default:
+            return process.env.NODE_ENV === 'production' ? LogLevel.INFO : LogLevel.DEBUG;
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "timonel",
   "type": "module",
-  "version": "2.10.1",
+  "version": "2.11.0",
   "description": "Timonel: programmatic Helm chart generator using cdk8s (TypeScript)",
   "bin": {
     "timonel": "dist/cli.js",
@@ -17,6 +17,10 @@
     "./lib/helm": {
       "types": "./dist/lib/helm.d.ts",
       "default": "./dist/lib/helm.js"
+    },
+    "./lib/utils/logger": {
+      "types": "./dist/lib/utils/logger.d.ts",
+      "default": "./dist/lib/utils/logger.js"
     }
   },
   "scripts": {
@@ -37,7 +41,9 @@
     "deps:update": "pnpm update --latest",
     "md:lint": "markdownlint \"**/*.md\"",
     "md:fix": "markdownlint --fix \"**/*.md\"",
-    "test:integration": "vitest run --config vitest.config.ts",
+    "test": "vitest run --config vitest.config.ts",
+    "test:unit": "vitest run --config vitest.config.ts",
+    "test:integration": "vitest run --config vitest.integration.config.ts",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
     "ci:check": "pnpm typecheck && pnpm lint && pnpm format:check && pnpm build",
@@ -81,26 +87,27 @@
     ]
   },
   "dependencies": {
-    "cdk8s": "^2.70.15",
-    "cdk8s-plus-33": "^2.3.6",
+    "cdk8s": "^2.70.16",
+    "cdk8s-plus-33": "^2.3.8",
     "constructs": "^10.4.2",
     "handlebars": "^4.7.8",
     "js-yaml": "^4.1.0",
-    "timonel": "^2.10.0",
+    "pino": "^9.11.0",
+    "pino-pretty": "^13.1.1",
     "ts-node": "^10.9.2",
     "yaml": "^2.8.1"
   },
   "devDependencies": {
-    "@commitlint/cli": "^19.8.1",
-    "@commitlint/config-conventional": "^19.8.1",
+    "@commitlint/cli": "^20.0.0",
+    "@commitlint/config-conventional": "^20.0.0",
     "@eslint/js": "^9.36.0",
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/exec": "^7.1.0",
     "@semantic-release/git": "^10.0.1",
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^24.5.2",
-    "@typescript-eslint/eslint-plugin": "^8.44.0",
-    "@typescript-eslint/parser": "^8.44.0",
+    "@typescript-eslint/eslint-plugin": "^8.44.1",
+    "@typescript-eslint/parser": "^8.44.1",
     "@vitest/coverage-v8": "^3.2.4",
     "conventional-changelog-cli": "^5.0.0",
     "eslint": "^9.36.0",
@@ -111,12 +118,12 @@
     "eslint-plugin-sonarjs": "^3.0.5",
     "eslint-plugin-unused-imports": "^4.2.0",
     "husky": "^9.1.7",
-    "lint-staged": "^16.1.6",
+    "lint-staged": "^16.2.1",
     "markdownlint": "^0.38.0",
     "markdownlint-cli": "^0.45.0",
     "prettier": "^3.6.2",
     "semantic-release": "^24.2.9",
-    "tsx": "^4.20.5",
+    "tsx": "^4.20.6",
     "typescript": "^5.9.2",
     "vitest": "^3.2.4"
   },
@@ -131,5 +138,10 @@
     "access": "public",
     "provenance": true
   },
-  "packageManager": "pnpm@10.15.0+sha512.486ebc259d3e999a4e8691ce03b5cac4a71cbeca39372a9b762cb500cfdf0873e2cb16abe3d951b1ee2cf012503f027b98b6584e4df22524e0c7450d9ec7aa7b"
+  "packageManager": "pnpm@10.15.0+sha512.486ebc259d3e999a4e8691ce03b5cac4a71cbeca39372a9b762cb500cfdf0873e2cb16abe3d951b1ee2cf012503f027b98b6584e4df22524e0c7450d9ec7aa7b",
+  "pnpm": {
+    "overrides": {
+      "@conventional-changelog/git-client": ">=2.0.0"
+    }
+  }
 }

package/dist/lib/templates/basic-chart.d.ts

@@ -1,19 +0,0 @@
-import { Chart } from 'cdk8s';
-import type { ChartProps } from 'cdk8s';
-import type { Construct } from 'constructs';
-export interface BasicChartProps extends ChartProps {
-    appName?: string;
-    image?: string;
-    port?: number;
-    replicas?: number;
-    createNamespace?: boolean;
-}
-export declare class BasicChart extends Chart {
-    private rutter;
-    private props;
-    constructor(scope: Construct, id: string, props?: BasicChartProps);
-    private initializeRutter;
-    writeHelmChart(outDir: string): void;
-    private generateKubernetesManifests;
-}
-export declare function generateBasicChart(appName?: string): string;