@firestartr/cli 1.47.0 → 1.48.0-snapshot-0

package/build/index.js

@@ -300247,11 +300247,17 @@ class TFWorkspaceNormalizer extends Normalizer {
 }
 async function normalizeModuleContent(tfRootModulePath) {
     let content = '';
+    const files = {};
     await crawl(tfRootModulePath, (entry) => {
         return entry.endsWith('.tf');
     }, (entry, data) => {
+        files[entry] = data;
+    });
+    Object.keys(files)
+        .sort()
+        .forEach((entry) => {
         content += `# ${external_path_.basename(entry)}
-${data}
+${files[entry]}
 `;
     });
     return content;
@@ -303205,6 +303211,210 @@ function renderContent(template, ctx) {
     return mustache_mustache.render(template, ctx, {}, ['{{|', '|}}']);
 }
 
+// EXTERNAL MODULE: external "node:fs"
+var external_node_fs_ = __nccwpck_require__(87561);
+// EXTERNAL MODULE: external "node:path"
+var external_node_path_ = __nccwpck_require__(49411);
+;// CONCATENATED MODULE: external "node:os"
+const external_node_os_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:os");
+;// CONCATENATED MODULE: ../features_renderer/src/auxiliar.ts
+// src/auxiliar.ts
+
+
+
+
+
+
+
+const renderTestsSchema = {
+    $schema: 'http://json-schema.org/draft-07/schema#',
+    type: 'object',
+    additionalProperties: false,
+    required: ['tests'],
+    properties: {
+        tests: {
+            type: 'array',
+            minItems: 1,
+            items: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['name', 'cr'],
+                properties: {
+                    name: { type: 'string', minLength: 1 },
+                    cr: { type: 'string', minLength: 1 },
+                    args: { type: 'object' },
+                },
+            },
+        },
+    },
+};
+const YAML_FILE_REGEX = /\.[yY]a?ml$/;
+/* ---------- Core helpers ---------- */
+function formatAjvErrors(errors) {
+    if (!errors || errors.length === 0)
+        return 'Unknown schema error';
+    return errors
+        .map((e) => {
+        const where = e.instancePath && e.instancePath.length ? e.instancePath : '/';
+        const msg = e.message ?? 'validation error';
+        return `- ${where} ${msg}`;
+    })
+        .join('\n');
+}
+function ensureUniqueTestNames(doc) {
+    const seen = new Set();
+    for (const t of doc.tests) {
+        if (seen.has(t.name)) {
+            throw new Error(`Duplicate test name "${t.name}" in render_tests.yaml`);
+        }
+        seen.add(t.name);
+    }
+}
+function loadAndValidateRenderTests(featurePath) {
+    const file = external_node_path_.join(featurePath, 'render_tests.yaml');
+    if (!external_node_fs_.existsSync(file)) {
+        throw new Error(`render_tests.yaml is required but not found at ${file}`);
+    }
+    const raw = loadYaml(file);
+    const ajv = new (ajv_default())({ allErrors: true, strict: true });
+    const validate = ajv.compile(renderTestsSchema);
+    const ok = validate(raw);
+    if (!ok) {
+        throw new Error(`render_tests.yaml schema validation failed:\n${formatAjvErrors(validate.errors ?? [])}`);
+    }
+    const doc = raw;
+    ensureUniqueTestNames(doc);
+    return doc;
+}
+function resolveCrPath(featurePath, crRelPath) {
+    if (external_node_path_.isAbsolute(crRelPath)) {
+        throw new Error(`CR path must be relative to the feature root, got absolute: ${crRelPath}`);
+    }
+    const resolved = external_node_path_.resolve(featurePath, crRelPath);
+    if (!external_node_fs_.existsSync(resolved)) {
+        throw new Error(`CR file not found (resolved from "${crRelPath}"): ${resolved}`);
+    }
+    return resolved;
+}
+function listYamlFiles(dir) {
+    if (!fs.existsSync(dir))
+        return [];
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        throw new Error(`Failed to read directory "${dir}": ${msg}`);
+    }
+    return entries
+        .filter((e) => e.isFile() && YAML_FILE_REGEX.test(e.name))
+        .map((e) => path.join(dir, e.name));
+}
+function loadYaml(file) {
+    try {
+        const configDataRaw = common_slurpFile(external_node_path_.join(file));
+        return catalog_common.io.fromYaml(configDataRaw);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        throw new Error(`Failed to parse YAML "${file}": ${msg}`);
+    }
+}
+function ensureSafeTmpName(name) {
+    if (typeof name !== 'string' || !name.trim()) {
+        throw new Error('Test "name" must be a non-empty string');
+    }
+    if (name.length > 128) {
+        throw new Error('Test "name" is too long (max 128 characters)');
+    }
+    if (external_node_path_.isAbsolute(name)) {
+        throw new Error(`Test "name" must be relative, got absolute: "${name}"`);
+    }
+    if (name.includes('..')) {
+        throw new Error('Test "name" must not contain ".."');
+    }
+    if (/[/\\]/.test(name)) {
+        throw new Error('Test "name" must not contain path separators (/ or \\)');
+    }
+    if (!/^[A-Za-z0-9._-]+$/.test(name)) {
+        throw new Error('Test "name" may only contain letters, numbers, ".", "_", or "-"');
+    }
+}
+async function mkNamedTmp(name) {
+    ensureSafeTmpName(name);
+    const dir = external_node_path_.join(external_node_os_namespaceObject.tmpdir(), name);
+    await promises_namespaceObject.rm(dir, { recursive: true, force: true });
+    await promises_namespaceObject.mkdir(dir, { recursive: true });
+    return dir;
+}
+async function mkTmp(prefix = 'feature-render-') {
+    return await fsp.mkdtemp(path.join(os.tmpdir(), prefix));
+}
+function buildExpectedOutput(config, renderDir) {
+    const files = (config.files || []).map((f) => ({
+        localPath: external_node_path_.join(renderDir, f.dest),
+        repoPath: f.src,
+        userManaged: f.user_managed,
+    }));
+    return {
+        files,
+        patches: config.patches || [],
+    };
+}
+/* ---------- Context-style API for a render temp dir ---------- */
+async function createRenderContext(prefix = 'feature-render-') {
+    const dir = await mkTmp(prefix);
+    const join = (...p) => path.join(dir, ...p);
+    return {
+        getContextPath: () => dir,
+        join,
+        getFile: async (relPath, { yaml: asYaml = false, json: asJson = false, } = {}) => {
+            const data = await fsp.readFile(join(relPath), 'utf8');
+            if (asYaml)
+                return common.io.fromYaml(data);
+            if (asJson)
+                return JSON.parse(data);
+            return data;
+        },
+        getFilePath: (relPath) => join(relPath),
+        setFile: async (relPath, contents) => {
+            await fsp.mkdir(path.dirname(join(relPath)), { recursive: true });
+            await fsp.writeFile(join(relPath), contents);
+        },
+        exists: async (relPath) => {
+            try {
+                await fsp.access(join(relPath));
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+        getOutputJson: async () => {
+            const p = join('output.json');
+            const raw = await fsp.readFile(p, 'utf8');
+            return JSON.parse(raw);
+        },
+        list: async (relPath = '.') => {
+            const entries = await fsp.readdir(join(relPath), {
+                withFileTypes: true,
+            });
+            return entries.map((e) => ({ name: e.name, isDir: e.isDirectory() }));
+        },
+        remove: async () => {
+            await fsp.rm(dir, { recursive: true, force: true });
+        },
+    };
+}
+/* harmony default export */ const auxiliar = ({
+    mkNamedTmp,
+    loadYaml,
+    buildExpectedOutput,
+    loadAndValidateRenderTests,
+    resolveCrPath,
+});
+
 ;// CONCATENATED MODULE: ../features_renderer/src/update_file.ts
 
 
@@ -303216,10 +303426,12 @@ function updateFileContent(featureRenderPath, filePath, content) {
 
 
 
+
 /* harmony default export */ const features_renderer = ({
     validate: validate_validate,
     render: render,
     updateFileContent: updateFileContent,
+    auxiliar: auxiliar,
 });
 
 ;// CONCATENATED MODULE: ../features_preparer/src/renderer.ts
@@ -315600,27 +315812,28 @@ var sdk_metrics_build_src = __nccwpck_require__(84016);
 ;// CONCATENATED MODULE: ../operator/src/metrics/CRStates.ts
 
 
+
 const INTERVAL_IN_SEGS = 60;
 class CRStateMetrics {
     constructor(kind, namespace, meter) {
         this.kind = kind;
-        this.provisionedGauge = meter.createGauge(`firestartr_${this.kind}_provisioned_total`, {
-            description: `Total number of ${this.kind} in PROVISIONED state`,
+        this.provisionedGauge = meter.createGauge('firestartr_provisioned_total', {
+            description: 'Total number of CRs in PROVISIONED state',
         });
-        this.provisioningGauge = meter.createGauge(`firestartr_${this.kind}_provisioning_total`, {
-            description: `Total number of ${this.kind} in PROVISIONING state`,
+        this.provisioningGauge = meter.createGauge('firestartr_provisioning_total', {
+            description: 'Total number of CRs in PROVISIONING state',
         });
-        this.outOfSyncGauge = meter.createGauge(`firestartr_${this.kind}_out_of_sync_total`, {
-            description: `Total number of ${this.kind} in OUT_OF_SYNC state`,
+        this.outOfSyncGauge = meter.createGauge('firestartr_out_of_sync_total', {
+            description: 'Total number of CRs in OUT_OF_SYNC state',
         });
-        this.errorGauge = meter.createGauge(`firestartr_${this.kind}_error_total`, {
-            description: `Total number of ${this.kind} in ERROR state`,
+        this.errorGauge = meter.createGauge('firestartr_error_total', {
+            description: 'Total number of CRs in ERROR state',
         });
-        this.planningGauge = meter.createGauge(`firestartr_${this.kind}_planning_total`, {
-            description: `Total number of ${this.kind} in PLANNING state`,
+        this.planningGauge = meter.createGauge('firestartr_planning_total', {
+            description: 'Total number of CRs in PLANNING state',
         });
-        this.deletedGauge = meter.createGauge(`firestartr_${this.kind}_deleted_total`, {
-            description: `Total number of ${this.kind} in DELETED state`,
+        this.deletedGauge = meter.createGauge('firestartr_deleted_total', {
+            description: 'Total number of CRs in DELETED state',
         });
         this.namespace = namespace;
     }
@@ -315677,19 +315890,33 @@ class CRStateMetrics {
             }
             this.provisionedGauge.record(provisionedCount, {
                 namespace: this.namespace,
+                kind: this.kind,
             });
             this.provisioningGauge.record(provisioningCount, {
                 namespace: this.namespace,
+                kind: this.kind,
+            });
+            this.planningGauge.record(planningCount, {
+                namespace: this.namespace,
+                kind: this.kind,
+            });
+            this.deletedGauge.record(deletedCount, {
+                namespace: this.namespace,
+                kind: this.kind,
+            });
+            this.outOfSyncGauge.record(outOfSyncCount, {
+                namespace: this.namespace,
+                kind: this.kind,
+            });
+            this.errorGauge.record(errorCount, {
+                namespace: this.namespace,
+                kind: this.kind,
             });
-            this.planningGauge.record(planningCount, { namespace: this.namespace });
-            this.deletedGauge.record(deletedCount, { namespace: this.namespace });
-            this.outOfSyncGauge.record(outOfSyncCount, { namespace: this.namespace });
-            this.errorGauge.record(errorCount, { namespace: this.namespace });
         }
         catch (err) {
-            console.log(err);
+            console.log(`CRStateMetrics: update ${err}`);
             this.onUpdate = false;
-            throw new Error(`CRStateMetrics: update ${err}`);
+            src_logger.error('CR_METRICS_UPDATE', { error: err });
         }
         this.onUpdate = false;
     }

package/build/packages/features_renderer/index.d.ts

@@ -5,5 +5,12 @@ declare const _default: {
     validate: typeof validate;
     render: typeof render;
     updateFileContent: typeof updateFileContent;
+    auxiliar: {
+        mkNamedTmp: (name: string) => Promise<string>;
+        loadYaml: <T = unknown>(file: string) => T;
+        buildExpectedOutput: (config: import("./src/auxiliar").FeatureConfig, renderDir: string) => import("./src/auxiliar").ExpectedOutput;
+        loadAndValidateRenderTests: (featurePath: string) => import("./src/auxiliar").RenderTestsFile;
+        resolveCrPath: (featurePath: string, crRelPath: string) => string;
+    };
 };
 export default _default;

package/build/packages/features_renderer/src/auxiliar.d.ts

@@ -0,0 +1,72 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+export interface ConfigFile {
+    dest: string;
+    src: string;
+    user_managed: boolean;
+}
+export interface FeatureConfig {
+    files?: ConfigFile[];
+    patches?: unknown[];
+}
+export interface ExpectedFile {
+    localPath: string;
+    repoPath: string;
+    userManaged: boolean;
+}
+export interface ExpectedOutput {
+    files: ExpectedFile[];
+    patches: unknown[];
+}
+export interface RenderTest {
+    name: string;
+    cr: string;
+    args?: Record<string, unknown>;
+}
+export interface RenderTestsFile {
+    tests: RenderTest[];
+}
+export interface RenderContext {
+    /** Absolute path to the temp dir */
+    getContextPath: () => string;
+    /** Join a relative path inside the temp dir */
+    join: (...p: string[]) => string;
+    /** Read a file (raw / JSON / YAML) from the temp dir */
+    getFile: <T = unknown>(relPath: string, opts?: {
+        yaml?: boolean;
+        json?: boolean;
+    }) => Promise<T | string>;
+    /** Absolute path of a file in the temp dir (no existence check) */
+    getFilePath: (relPath: string) => string;
+    /** Write a file (ensures parent dirs) */
+    setFile: (relPath: string, contents: string | Buffer | NodeJS.ArrayBufferView) => Promise<void>;
+    /** Whether a path exists in the temp dir */
+    exists: (relPath: string) => Promise<boolean>;
+    /** Convenience: read output.json from the temp dir */
+    getOutputJson: <T = unknown>() => Promise<T>;
+    /** List entries (name + isDir) in a subdirectory */
+    list: (relPath?: string) => Promise<Array<{
+        name: string;
+        isDir: boolean;
+    }>>;
+    /** Optional cleanup */
+    remove: () => Promise<void>;
+}
+declare function loadAndValidateRenderTests(featurePath: string): RenderTestsFile;
+declare function resolveCrPath(featurePath: string, crRelPath: string): string;
+export declare function listYamlFiles(dir: string): string[];
+declare function loadYaml<T = unknown>(file: string): T;
+export declare function ensureSafeTmpName(name: string): void;
+declare function mkNamedTmp(name: string): Promise<string>;
+export declare function mkTmp(prefix?: string): Promise<string>;
+declare function buildExpectedOutput(config: FeatureConfig, renderDir: string): ExpectedOutput;
+export declare function createRenderContext(prefix?: string): Promise<RenderContext>;
+declare const _default: {
+    mkNamedTmp: typeof mkNamedTmp;
+    loadYaml: typeof loadYaml;
+    buildExpectedOutput: typeof buildExpectedOutput;
+    loadAndValidateRenderTests: typeof loadAndValidateRenderTests;
+    resolveCrPath: typeof resolveCrPath;
+};
+export default _default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@firestartr/cli",
-  "version": "1.47.0",
+  "version": "1.48.0-snapshot-0",
   "private": false,
   "description": "Commandline tool",
   "main": "build/main.js",