@firestartr/cli 2.8.0 → 2.9.0-snapshot-01

package/build/index.js

@@ -317847,7 +317847,18 @@ function configurePathsForRendering() {
     const configPath = '/tmp/defaults';
     createInitializers(configPath);
     createExpanders(configPath);
-    configureProvider(AllowedProviders.all);
+    try {
+        configureProvider(AllowedProviders.all);
+    }
+    catch (err) {
+        // Only the already-configured case is expected here; any other
+        // configuration error must surface instead of being silently hidden.
+        if (!(err instanceof Error) ||
+            !err.message.includes('Provider already configured')) {
+            throw err;
+        }
+        reconfigureProvider(AllowedProviders.all);
+    }
     setPath('initializers', configPath);
     setPath('crs', '/tmp/resources_from_main_branch');
     setPath('globals', configPath);
@@ -322024,6 +322035,9 @@ var ajv_default = /*#__PURE__*/__nccwpck_require__.n(dist_ajv);
                     description: 'a list of references to a different file where files key is filled by an expanded template',
                     items: {
                         type: 'string',
+                        not: {
+                            pattern: '^/|(^|/)\\.\\.(/|$)',
+                        },
                     },
                 },
             },
@@ -322070,9 +322084,15 @@ var ajv_default = /*#__PURE__*/__nccwpck_require__.n(dist_ajv);
             properties: {
                 src: {
                     type: 'string',
+                    not: {
+                        pattern: '^/|(^|/)\\.\\.(/|$)',
+                    },
                 },
                 dest: {
                     type: 'string',
+                    not: {
+                        pattern: '^/|(^|/)\\.\\.(/|$)',
+                    },
                 },
                 upgradable: {
                     type: 'boolean',
@@ -322984,12 +323004,19 @@ function render(featurePath, featureRenderPath, entity, firestartrConfig = {}, f
     if ('filesTemplates' in context.config) {
         expandFiles(featurePath, configData, context);
     }
+    for (const file of context.config.files) {
+        const { src, dest } = file;
+        assertSafeRelativePath(src, 'file src');
+        assertSafeRelativePath(dest, 'file dest');
+        resolveInside(featurePath, external_path_default().join('templates', src), 'file src', 'feature directory');
+        resolveInside(featureRenderPath, dest, 'file dest', 'render target directory');
+    }
     const output = { files: [] };
     context.config.files.forEach((file) => {
         const { src, dest } = file;
-        // For now let's keep upgradeable flag for backward compatibility
+        // For now let's keep upgradable flag for backward compatibility
         // by default it's false
-        const userManaged = file.user_managed ?? file.upgradeable ?? false;
+        const userManaged = file.user_managed ?? file.upgradable ?? false;
         const targetBranch = file.target_branch ?? '';
         src_logger.debug(`Rendering ${src} to ${dest}`);
         // render the content of the file
@@ -323009,6 +323036,7 @@ function render(featurePath, featureRenderPath, entity, firestartrConfig = {}, f
         // Not used anymore
         // output.unpatches = context.config.unpatches
     });
+    external_fs_default().writeFileSync(external_path_default().join(featureRenderPath, 'config.json'), JSON.stringify(context.config));
     // write the output file
     const configFile = external_path_default().join(featureRenderPath, 'output.json');
     external_fs_default().writeFileSync(configFile, JSON.stringify(output));
@@ -323033,8 +323061,9 @@ function buildContext(entity, args, firestartrConfig, featureArgs) {
             context[key] = arg['$lit'];
         }
         else if ('$arg' in arg) {
-            if (featureArgs[arg['$arg']])
+            if (Object.prototype.hasOwnProperty.call(featureArgs, arg['$arg'])) {
                 context[key] = featureArgs[arg['$arg']];
+            }
         }
     });
     context.firestartrConfig = firestartrConfig;
@@ -323066,7 +323095,7 @@ function expandFiles(featurePath, configData, context) {
     context.config.files = context.config.files.concat(files).flat(Infinity);
 }
 function expandFilesTemplate(featurePath, tplPath, context) {
-    const templatePath = external_path_default().join(featurePath, tplPath);
+    const templatePath = resolveInside(featurePath, tplPath, 'filesTemplates entry', 'feature directory');
     src_logger.debug(`Expanding files section with template located at ${templatePath}`);
     let template;
     try {
@@ -323086,6 +323115,55 @@ function expandFilesTemplate(featurePath, tplPath, context) {
 function renderContent(template, ctx) {
     return mustache_mustache.render(template, ctx, {}, ['{{|', '|}}']);
 }
+function assertNonEmptyString(value, what) {
+    if (typeof value !== 'string' || value.length === 0) {
+        throw new Error(`Feature path error: ${what} must be a non-empty string, got ${JSON.stringify(value)}`);
+    }
+}
+function assertSafeRelativePath(candidate, what) {
+    assertNonEmptyString(candidate, what);
+    if (external_path_default().isAbsolute(candidate)) {
+        throw new Error(`Feature path error: ${what} "${candidate}" must be a relative path`);
+    }
+    if (candidate.split(/[\\/]+/).includes('..')) {
+        throw new Error(`Feature path error: ${what} "${candidate}" must not contain ".." path segments`);
+    }
+}
+function hasSymbolicLinkComponent(target) {
+    let current = target;
+    for (;;) {
+        try {
+            return external_fs_default().realpathSync(current) !== current;
+        }
+        catch (err) {
+            if (err && err.code === 'ENOENT') {
+                const parent = external_path_default().dirname(current);
+                if (parent === current) {
+                    return false;
+                }
+                current = parent;
+                continue;
+            }
+            throw err;
+        }
+    }
+}
+function resolveInside(basePath, candidate, what, baseLabel) {
+    assertSafeRelativePath(candidate, what);
+    const root = external_path_default().resolve(basePath);
+    const target = external_path_default().resolve(root, candidate);
+    const relative = external_path_default().relative(root, target);
+    const escaped = relative === '..' ||
+        relative.startsWith('..' + (external_path_default()).sep) ||
+        external_path_default().isAbsolute(relative);
+    if (escaped) {
+        throw new Error(`Feature path error: ${what} "${candidate}" escapes ${baseLabel} "${root}"`);
+    }
+    if (hasSymbolicLinkComponent(target)) {
+        throw new Error(`Feature path error: ${what} "${candidate}" must not traverse a symbolic link under ${baseLabel}`);
+    }
+    return target;
+}
 
 // EXTERNAL MODULE: external "node:fs"
 var external_node_fs_ = __nccwpck_require__(87561);
@@ -323230,7 +323308,8 @@ function buildExpectedOutput(config, renderDir) {
     const files = (config.files || []).map((f) => ({
         localPath: external_node_path_.join(renderDir, f.dest),
         repoPath: f.dest,
-        userManaged: f.user_managed,
+        userManaged: f.user_managed ?? f.upgradable ?? false,
+        targetBranch: f.target_branch ?? '',
     }));
     return {
         files,
@@ -323309,6 +323388,7 @@ function updateFileContent(featureRenderPath, filePath, content) {
     auxiliar: auxiliar,
     buildContext: buildContext,
     renderContent: renderContent,
+    expandFiles: expandFiles,
 });
 
 ;// CONCATENATED MODULE: ../features_preparer/src/logger.ts
@@ -323717,6 +323797,7 @@ const KINDS_CR_MAP = {
 
 
 
+
 function resolveStringReference(reference) {
     const referenceElements = reference.split(':');
     const actualKind = KINDS_CR_MAP[referenceElements[0]];
@@ -323891,7 +323972,17 @@ async function crawlClaimsDir(dir, basePath, claims) {
                 const relativePath = external_path_default().relative(basePath, fullPath)
                     .split((external_path_default()).sep)
                     .join((external_path_default()).posix.sep);
-                claims[ref] = { filePath: relativePath };
+                if (claim.kind === 'TFWorkspaceClaim') {
+                    const values = claim.providers?.terraform?.values;
+                    const [tfRefs] = getTfWorkspacesRefs(values ?? {});
+                    const uniqueRefs = [
+                        ...new Set(tfRefs.map((r) => `TFWorkspaceClaim-${r}`)),
+                    ];
+                    claims[ref] = { filePath: relativePath, refs: uniqueRefs };
+                }
+                else {
+                    claims[ref] = { filePath: relativePath };
+                }
             }
             catch (err) {
                 throw new Error(`Error processing claim file ${fullPath}: ${err}`);
@@ -328742,6 +328833,9 @@ async function getAffectedRepositories(claimPathFromMain, claimPathFromPR, wetRe
     if (!external_fs_.existsSync(MAIN_BRANCH_OUTPUT_DIR)) {
         external_fs_.mkdirSync(MAIN_BRANCH_OUTPUT_DIR);
     }
+    // Make this function re-callable: clear state left behind by a previous call
+    emptyRenderedClaims();
+    resetLazyLoader();
     /**
      * Object with the affected wet repositories
      * This will be returned in order to trigger
@@ -521982,7 +522076,7 @@ const crsStatusSubcommand = {
 };
 
 ;// CONCATENATED MODULE: ./package.json
-const package_namespaceObject = {"i8":"2.8.0"};
+const package_namespaceObject = JSON.parse('{"i8":"2.9.0-snapshot-01"}');
 ;// CONCATENATED MODULE: ../../package.json
 const package_namespaceObject_1 = {"i8":"2.8.0"};
 ;// CONCATENATED MODULE: ./src/subcommands/index.ts

package/build/packages/cdk8s_renderer/src/utils/claimUtils.d.ts

@@ -7,6 +7,7 @@ export declare function getClaimsEntryAbsolutePath(claimsDir: string, entryPath:
 export declare function sanitizeApiEntityName(name: string): string;
 export interface ClaimsMapEntry {
     filePath: string;
+    refs?: string[];
 }
 export interface ClaimsMap {
     headers: {

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

@@ -1,5 +1,5 @@
 import validate from './src/validate';
-import render, { buildContext, renderContent } from './src/render';
+import render, { buildContext, renderContent, expandFiles } from './src/render';
 import updateFileContent from './src/update_file';
 declare const _default: {
     validate: typeof validate;
@@ -14,5 +14,6 @@ declare const _default: {
     };
     buildContext: typeof buildContext;
     renderContent: typeof renderContent;
+    expandFiles: typeof expandFiles;
 };
 export default _default;

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

@@ -4,7 +4,9 @@
 export interface ConfigFile {
     dest: string;
     src: string;
-    user_managed: boolean;
+    user_managed?: boolean;
+    upgradable?: boolean;
+    target_branch?: string;
 }
 export interface FeatureConfig {
     files?: ConfigFile[];
@@ -13,6 +15,7 @@ export interface FeatureConfig {
 export interface ExpectedFile {
     localPath: string;
     repoPath: string;
+    targetBranch: string;
     userManaged: boolean;
 }
 export interface ExpectedOutput {

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

@@ -2,3 +2,6 @@ export default function render(featurePath: string, featureRenderPath: string, e
 export declare function buildContext(entity: any, args: any, firestartrConfig: any, featureArgs: any): any;
 export declare function expandFiles(featurePath: string, configData: any, context: any): void;
 export declare function renderContent(template: string, ctx: any): any;
+export declare function assertNonEmptyString(value: unknown, what: string): asserts value is string;
+export declare function assertSafeRelativePath(candidate: unknown, what: string): void;
+export declare function resolveInside(basePath: string, candidate: string, what: string, baseLabel: string): string;

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

@@ -34,6 +34,9 @@ declare const _default: {
                     description: string;
                     items: {
                         type: string;
+                        not: {
+                            pattern: string;
+                        };
                     };
                 };
             };
@@ -80,9 +83,15 @@ declare const _default: {
             properties: {
                 src: {
                     type: string;
+                    not: {
+                        pattern: string;
+                    };
                 };
                 dest: {
                     type: string;
+                    not: {
+                        pattern: string;
+                    };
                 };
                 upgradable: {
                     type: string;

package/package.json

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