timonel 2.14.0-beta.1 → 3.0.0

package/dist/lib/utils/logger.js

@@ -180,19 +180,24 @@ export class TimonelLogger {
         }
     }
     requestSerializer(req) {
-        if (!req || typeof req !== 'object')
+        try {
+            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,
+            };
+        }
+        catch {
             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')
@@ -256,40 +261,50 @@ export class TimonelLogger {
         }
     }
     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;
+        try {
+            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;
+        }
+        catch {
+            return {};
         }
-        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);
+        try {
+            if (depth <= 0 || !obj || typeof obj !== 'object') {
+                return obj;
             }
-            else if (value && typeof value === 'object') {
-                sanitized[key] = this.sanitizeNestedObject(value, depth - 1);
-            }
-            else {
-                sanitized[key] = value;
+            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;
+        }
+        catch {
+            return obj;
         }
-        return sanitized;
     }
     child(context) {
         const sanitizedContext = this.sanitizeContext(context);

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

@@ -0,0 +1,102 @@
+import { type HelmExpression } from './helmControlStructures.js';
+declare const HELM_VALUE_SYMBOL: unique symbol;
+export interface HelmValue<T = unknown> {
+    [HELM_VALUE_SYMBOL]: true;
+    __path: string;
+    __type?: T;
+    eq(value: HelmValue | string | number | boolean): HelmCondition;
+    ne(value: HelmValue | string | number | boolean): HelmCondition;
+    gt(value: HelmValue | number): HelmCondition;
+    ge(value: HelmValue | number): HelmCondition;
+    lt(value: HelmValue | number): HelmCondition;
+    le(value: HelmValue | number): HelmCondition;
+    not(): HelmCondition;
+    and(other: HelmCondition): HelmCondition;
+    or(other: HelmCondition): HelmCondition;
+    default(defaultValue: HelmValue | string | number | boolean): HelmValue<T>;
+    quote(): HelmValue<string>;
+    upper(): HelmValue<string>;
+    lower(): HelmValue<string>;
+    title(): HelmValue<string>;
+    trim(): HelmValue<string>;
+    trimPrefix(prefix: string): HelmValue<string>;
+    trimSuffix(suffix: string): HelmValue<string>;
+    replace(old: string, newStr: string): HelmValue<string>;
+    contains(substr: string): HelmCondition;
+    hasPrefix(prefix: string): HelmCondition;
+    hasSuffix(suffix: string): HelmCondition;
+    trunc(length: number): HelmValue<string>;
+    kindIs(kind: 'string' | 'slice' | 'map' | 'bool' | 'int' | 'float'): HelmCondition;
+    hasKey(key: string): HelmCondition;
+    toYaml(): HelmValue<string>;
+    toJson(): HelmValue<string>;
+    nindent(spaces: number): HelmValue<string>;
+    indent(spaces: number): HelmValue<string>;
+    toExpression(): HelmExpression;
+    if<V>(condition: HelmCondition, thenValue: V): HelmFieldConditional<V>;
+    ifElse<V>(condition: HelmCondition, thenValue: V, elseValue: V): HelmValue<V>;
+    range<V>(callback: (item: HelmValue<T extends (infer U)[] ? U : unknown>, index: HelmValue<number>) => V): HelmRange<V>;
+    with<V>(callback: (ctx: HelmValue<T>) => V): HelmWith<V>;
+}
+export interface HelmCondition {
+    [HELM_VALUE_SYMBOL]: true;
+    __condition: string;
+    not(): HelmCondition;
+    and(other: HelmCondition): HelmCondition;
+    or(other: HelmCondition): HelmCondition;
+    toString(): string;
+}
+export interface HelmFieldConditional<T> {
+    __helmFieldConditional: true;
+    condition: HelmCondition;
+    thenValue: T;
+    elseValue?: T;
+}
+export interface HelmRange<T> {
+    __helmRange: true;
+    source: HelmValue;
+    callback: (item: HelmValue, index: HelmValue<number>) => T;
+}
+export interface HelmWith<T> {
+    __helmWith: true;
+    source: HelmValue;
+    callback: (ctx: HelmValue) => T;
+}
+export interface HelmHelpers {
+    include(templateName: string, context?: '.' | HelmValue): HelmValue<string>;
+    printf(format: string, ...args: (HelmValue | string | number)[]): HelmValue<string>;
+    release: {
+        name: HelmValue<string>;
+        namespace: HelmValue<string>;
+        service: HelmValue<string>;
+        isUpgrade: HelmValue<boolean>;
+        isInstall: HelmValue<boolean>;
+        revision: HelmValue<number>;
+    };
+    chart: {
+        name: HelmValue<string>;
+        version: HelmValue<string>;
+        appVersion: HelmValue<string>;
+        type: HelmValue<string>;
+    };
+    capabilities: {
+        kubeVersion: {
+            version: HelmValue<string>;
+            major: HelmValue<string>;
+            minor: HelmValue<string>;
+        };
+        apiVersions: {
+            has(apiVersion: string): HelmCondition;
+        };
+    };
+    rawCondition(condition: string): HelmCondition;
+}
+export declare function valuesRef<T extends Record<string, unknown>>(): HelmValue<T> & HelmHelpers;
+export declare function isHelmValue(value: unknown): value is HelmValue;
+export declare function isHelmCondition(value: unknown): value is HelmCondition;
+export declare function isHelmFieldConditional(value: unknown): value is HelmFieldConditional<unknown>;
+export declare function isHelmRange(value: unknown): value is HelmRange<unknown>;
+export declare function isHelmWith(value: unknown): value is HelmWith<unknown>;
+export declare function serializeHelmValue(value: HelmValue): string;
+export declare function serializeHelmCondition(condition: HelmCondition): string;
+export {};

package/dist/lib/utils/valuesRef.js

@@ -0,0 +1,273 @@
+import { createHelmExpression } from './helmControlStructures.js';
+const HELM_VALUE_SYMBOL = Symbol('HelmValue');
+function serializeValue(value) {
+    if (typeof value === 'object' && value !== null && HELM_VALUE_SYMBOL in value) {
+        return value.__path;
+    }
+    if (typeof value === 'string') {
+        return `"${value}"`;
+    }
+    return String(value);
+}
+function createCondition(condition) {
+    if (!condition || typeof condition !== 'string') {
+        throw new Error('Condition must be a non-empty string');
+    }
+    return {
+        [HELM_VALUE_SYMBOL]: true,
+        __condition: condition,
+        not() {
+            return createCondition(`not (${this.__condition})`);
+        },
+        and(other) {
+            if (!other || typeof other.__condition !== 'string') {
+                throw new Error('Invalid HelmCondition provided to and()');
+            }
+            return createCondition(`and (${this.__condition}) (${other.__condition})`);
+        },
+        or(other) {
+            if (!other || typeof other.__condition !== 'string') {
+                throw new Error('Invalid HelmCondition provided to or()');
+            }
+            return createCondition(`or (${this.__condition}) (${other.__condition})`);
+        },
+        toString() {
+            return this.__condition;
+        },
+    };
+}
+function createValueProxy(path) {
+    const baseObject = Object.create(null);
+    baseObject.__helmExpression = true;
+    baseObject.value = `{{ ${path} }}`;
+    const handler = {
+        ownKeys() {
+            return ['__helmExpression', 'value'];
+        },
+        getOwnPropertyDescriptor(target, prop) {
+            if (prop === '__helmExpression') {
+                return { value: true, writable: false, enumerable: true, configurable: true };
+            }
+            if (prop === 'value') {
+                return { value: `{{ ${path} }}`, writable: false, enumerable: true, configurable: true };
+            }
+            return undefined;
+        },
+        has(target, prop) {
+            if (prop === HELM_VALUE_SYMBOL)
+                return true;
+            if (prop === '__helmExpression')
+                return true;
+            if (prop === 'value')
+                return true;
+            return false;
+        },
+        get(target, prop) {
+            if (prop === HELM_VALUE_SYMBOL)
+                return true;
+            if (prop === '__path')
+                return path;
+            if (prop === '__type')
+                return undefined;
+            if (prop === '__helmExpression')
+                return true;
+            if (prop === 'value')
+                return `{{ ${path} }}`;
+            if (prop === 'toJSON') {
+                return () => ({ __helmExpression: true, value: `{{ ${path} }}` });
+            }
+            if (typeof prop === 'string') {
+                switch (prop) {
+                    case 'eq':
+                        return (value) => createCondition(`eq ${path} ${serializeValue(value)}`);
+                    case 'ne':
+                        return (value) => createCondition(`ne ${path} ${serializeValue(value)}`);
+                    case 'gt':
+                        return (value) => createCondition(`gt ${path} ${serializeValue(value)}`);
+                    case 'ge':
+                        return (value) => createCondition(`ge ${path} ${serializeValue(value)}`);
+                    case 'lt':
+                        return (value) => createCondition(`lt ${path} ${serializeValue(value)}`);
+                    case 'le':
+                        return (value) => createCondition(`le ${path} ${serializeValue(value)}`);
+                    case 'not':
+                        return () => createCondition(`not ${path}`);
+                    case 'and':
+                        return (other) => createCondition(`and ${path} (${other.__condition})`);
+                    case 'or':
+                        return (other) => createCondition(`or ${path} (${other.__condition})`);
+                    case 'default':
+                        return (defaultValue) => createValueProxy(`${path} | default ${serializeValue(defaultValue)}`);
+                    case 'quote':
+                        return () => createValueProxy(`(${path} | quote)`);
+                    case 'upper':
+                        return () => createValueProxy(`(${path} | upper)`);
+                    case 'lower':
+                        return () => createValueProxy(`(${path} | lower)`);
+                    case 'title':
+                        return () => createValueProxy(`(${path} | title)`);
+                    case 'trim':
+                        return () => createValueProxy(`(${path} | trim)`);
+                    case 'trimPrefix':
+                        return (prefix) => createValueProxy(`(${path} | trimPrefix "${prefix}")`);
+                    case 'trimSuffix':
+                        return (suffix) => createValueProxy(`(${path} | trimSuffix "${suffix}")`);
+                    case 'replace':
+                        return (old, newStr) => createValueProxy(`(${path} | replace "${old}" "${newStr}")`);
+                    case 'contains':
+                        return (substr) => createCondition(`contains "${substr}" ${path}`);
+                    case 'hasPrefix':
+                        return (prefix) => createCondition(`hasPrefix ${path} "${prefix}"`);
+                    case 'hasSuffix':
+                        return (suffix) => createCondition(`hasSuffix ${path} "${suffix}"`);
+                    case 'trunc':
+                        return (length) => createValueProxy(`(${path} | trunc ${length})`);
+                    case 'kindIs':
+                        return (kind) => createCondition(`kindIs "${kind}" ${path}`);
+                    case 'hasKey':
+                        return (key) => createCondition(`hasKey ${path} "${key}"`);
+                    case 'toYaml':
+                        return () => createValueProxy(`${path} | toYaml`);
+                    case 'toJson':
+                        return () => createValueProxy(`${path} | toJson`);
+                    case 'nindent':
+                        return (spaces) => createValueProxy(`${path} | nindent ${spaces}`);
+                    case 'indent':
+                        return (spaces) => createValueProxy(`${path} | indent ${spaces}`);
+                    case 'toExpression':
+                        return () => createHelmExpression(`{{ ${path} }}`);
+                    case 'if':
+                        return (condition, thenValue) => {
+                            let helmCondition;
+                            if (isHelmCondition(condition)) {
+                                helmCondition = condition;
+                            }
+                            else if (isHelmValue(condition)) {
+                                helmCondition = createCondition(condition.__path);
+                            }
+                            else {
+                                throw new Error('v.if() requires a HelmCondition or HelmValue as the first argument');
+                            }
+                            return {
+                                __helmFieldConditional: true,
+                                condition: helmCondition,
+                                thenValue,
+                            };
+                        };
+                    case 'ifElse':
+                        return (condition, thenValue, elseValue) => {
+                            const condStr = condition.__condition;
+                            return createValueProxy(`(ternary ${serializeValue(thenValue)} ${serializeValue(elseValue)} (${condStr}))`);
+                        };
+                    case 'range':
+                        return (callback) => ({
+                            __helmRange: true,
+                            source: createValueProxy(path),
+                            callback,
+                        });
+                    case 'with':
+                        return (callback) => {
+                            const ctxProxy = { __path: '.', [HELM_VALUE_SYMBOL]: true };
+                            const content = callback(ctxProxy);
+                            let contentStr;
+                            if (typeof content === 'object' &&
+                                content !== null &&
+                                '__helmExpression' in content) {
+                                const helmExpr = content;
+                                contentStr = helmExpr.value;
+                            }
+                            else {
+                                contentStr = String(content);
+                            }
+                            const marker = `__FIELD_WITH_MARKER__:${path}:${contentStr}`;
+                            return createHelmExpression(marker);
+                        };
+                    case 'toString':
+                        return () => `{{ ${path} }}`;
+                    case 'valueOf':
+                        return () => path;
+                    default:
+                        return createValueProxy(`${path}.${prop}`);
+                }
+            }
+            return undefined;
+        },
+    };
+    return new Proxy(baseObject, handler);
+}
+export function valuesRef() {
+    const values = createValueProxy('.Values');
+    const helpers = {
+        include(templateName, context = '.') {
+            const ctx = context === '.' ? '.' : context.__path;
+            return createValueProxy(`(include "${templateName}" ${ctx})`);
+        },
+        printf(format, ...args) {
+            const argsStr = args
+                .map((arg) => serializeValue(arg))
+                .join(' ');
+            return createValueProxy(`(printf "${format}" ${argsStr})`);
+        },
+        release: {
+            name: createValueProxy('.Release.Name'),
+            namespace: createValueProxy('.Release.Namespace'),
+            service: createValueProxy('.Release.Service'),
+            isUpgrade: createValueProxy('.Release.IsUpgrade'),
+            isInstall: createValueProxy('.Release.IsInstall'),
+            revision: createValueProxy('.Release.Revision'),
+        },
+        chart: {
+            name: createValueProxy('.Chart.Name'),
+            version: createValueProxy('.Chart.Version'),
+            appVersion: createValueProxy('.Chart.AppVersion'),
+            type: createValueProxy('.Chart.Type'),
+        },
+        capabilities: {
+            kubeVersion: {
+                version: createValueProxy('.Capabilities.KubeVersion.Version'),
+                major: createValueProxy('.Capabilities.KubeVersion.Major'),
+                minor: createValueProxy('.Capabilities.KubeVersion.Minor'),
+            },
+            apiVersions: {
+                has(apiVersion) {
+                    return createCondition(`.Capabilities.APIVersions.Has "${apiVersion}"`);
+                },
+            },
+        },
+        rawCondition(condition) {
+            return createCondition(condition);
+        },
+    };
+    return new Proxy(values, {
+        get(target, prop) {
+            if (prop in helpers) {
+                return helpers[prop];
+            }
+            return target[prop];
+        },
+    });
+}
+export function isHelmValue(value) {
+    return typeof value === 'object' && value !== null && HELM_VALUE_SYMBOL in value;
+}
+export function isHelmCondition(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        HELM_VALUE_SYMBOL in value &&
+        '__condition' in value);
+}
+export function isHelmFieldConditional(value) {
+    return typeof value === 'object' && value !== null && '__helmFieldConditional' in value;
+}
+export function isHelmRange(value) {
+    return typeof value === 'object' && value !== null && '__helmRange' in value;
+}
+export function isHelmWith(value) {
+    return typeof value === 'object' && value !== null && '__helmWith' in value;
+}
+export function serializeHelmValue(value) {
+    return `{{ ${value.__path} }}`;
+}
+export function serializeHelmCondition(condition) {
+    return condition.__condition;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "timonel",
   "type": "module",
-  "version": "2.14.0-beta.1",
+  "version": "3.0.0",
   "description": "Timonel: programmatic Helm chart generator using cdk8s (TypeScript)",
   "bin": {
     "timonel": "dist/cli.js",