timonel 2.14.0-beta.1 → 3.0.0-beta.1

package/dist/lib/utils/valuesRef.js

@@ -0,0 +1,264 @@
+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) {
+    return {
+        [HELM_VALUE_SYMBOL]: true,
+        __condition: condition,
+        not() {
+            return createCondition(`not (${this.__condition})`);
+        },
+        and(other) {
+            return createCondition(`and (${this.__condition}) (${other.__condition})`);
+        },
+        or(other) {
+            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-beta.1",
   "description": "Timonel: programmatic Helm chart generator using cdk8s (TypeScript)",
   "bin": {
     "timonel": "dist/cli.js",