@firestartr/cli 1.39.1 → 1.39.2-SNAPSHOT

package/build/index.js

@@ -276344,10 +276344,15 @@ var __webpack_exports__ = {};
 var regex_namespaceObject = {};
 __nccwpck_require__.r(regex_namespaceObject);
 __nccwpck_require__.d(regex_namespaceObject, {
+  "GenericRefRegex": () => (GenericRefRegex),
   "GroupRefRegex": () => (GroupRefRegex),
   "SecretRefRegex": () => (SecretRefRegex),
   "TFWorkspaceRefCR": () => (TFWorkspaceRefCR),
-  "TFWorkspaceRefRegex": () => (TFWorkspaceRefRegex)
+  "TFWorkspaceRefRegex": () => (TFWorkspaceRefRegex),
+  "YAMLHeaderRegex": () => (YAMLHeaderRegex),
+  "YAMLInlineListRegex": () => (YAMLInlineListRegex),
+  "YAMLListItemRegex": () => (YAMLListItemRegex),
+  "YAMLMultilineRegex": () => (YAMLMultilineRegex)
 });
 
 // NAMESPACE OBJECT: ../catalog_common/src/features/tarballs.ts
@@ -277906,6 +277911,11 @@ const TFWorkspaceRefRegex = new RegExp(`\\$\\{\\{\\s*tfworkspace\\:(${regModuleN
 const SecretRefRegex = new RegExp(`\\$\\{\\{\\s*secret\\:(${regModuleName.source})\\.(${regModuleName.source})\\s*\\}\\}`, 'ig');
 const GroupRefRegex = new RegExp(`group\\:(${regModuleName.source})`, 'ig');
 const TFWorkspaceRefCR = new RegExp(`\\$\\{\\{\\s*references\\.(${regModuleName.source})\\s*\\}\\}`, 'i');
+const GenericRefRegex = new RegExp(`user:${regModuleName.source}|group:${regModuleName.source}|system:${regModuleName.source}`, 'gm');
+const YAMLHeaderRegex = new RegExp(/^\s*(\w+:\s?)/);
+const YAMLListItemRegex = new RegExp(/^\s*(-\s)/);
+const YAMLInlineListRegex = new RegExp(/^\s*(\[.+\])/);
+const YAMLMultilineRegex = new RegExp(/^\s*([>|][-+]?)/);
 
 ;// CONCATENATED MODULE: ../catalog_common/src/types/catalog.ts
 var KindTypes;
@@ -287089,6 +287099,254 @@ const NORMALIZERS = [
     RevisionNormalizer,
 ];
 
+;// CONCATENATED MODULE: ../cdk8s_renderer/src/refsSorter/refsExtractor.ts
+
+
+
+const refsExtractor_log = src_default()('firestartr:renderer:refsextractor');
+const kindMap = {
+    user: 'UserClaim',
+    group: 'GroupClaim',
+    system: 'SystemClaim',
+};
+function extractRefs(renderClaims, kind) {
+    const result = {};
+    for (const key in renderClaims) {
+        const claim = renderClaims[key].claim;
+        let refs = [];
+        switch (kind) {
+            case 'TFWorkspaceClaim':
+                refs = getTfWorkspacesRefs(claim.providers.terraform.values);
+                break;
+            case 'GroupClaim':
+                /**
+                 * Groups can have refs to other groups in parent property
+                 **/
+                refs = getGroupParentRef(claim.parent);
+                break;
+            default:
+                throw new Error(`No refs for kind ${kind}`);
+        }
+        result[claim.name] = {
+            name: `${claim.kind}-${claim.name}`,
+            refs: refs,
+        };
+    }
+    return result;
+}
+function extractAllRefs(claimData) {
+    const refs = getClaimReferences(claimData);
+    const parsedClaim = yaml_dist.parse(claimData);
+    switch (parsedClaim.kind) {
+        case 'TFWorkspaceClaim': {
+            const tfWorkspaceRefs = getTfWorkspacesRefs(parsedClaim.providers.terraform.values);
+            tfWorkspaceRefs.forEach((ref, idx, arr) => {
+                arr[idx] = `TFWorkspaceClaim-${ref}`;
+            });
+            refs.push(...tfWorkspaceRefs);
+            break;
+        }
+        case 'GroupClaim': {
+            const groupRefs = getGroupParentRef(parsedClaim.parent);
+            groupRefs.forEach((ref, idx, arr) => {
+                arr[idx] = `GroupClaim-${ref}`;
+            });
+            refs.push(...groupRefs);
+            break;
+        }
+    }
+    return [...new Set(refs)];
+}
+function getGroupParentRef(parent, references = []) {
+    if (!parent)
+        return [];
+    const regex = catalog_common.types.regex.GroupRefRegex;
+    for (const match of parent.matchAll(regex)) {
+        refsExtractor_log(match);
+        const [_, claimName] = match;
+        references.push(claimName);
+    }
+    return references;
+}
+function getTfWorkspacesRefs(values, references = []) {
+    const regex = catalog_common.types.regex.TFWorkspaceRefRegex;
+    for (const key in values) {
+        switch (typeof values[key]) {
+            case 'object':
+                getTfWorkspacesRefs(values[key], references);
+                break;
+            case 'string':
+                for (const match of values[key].matchAll(regex)) {
+                    const [_, claimName] = match;
+                    references.push(claimName);
+                }
+                break;
+        }
+    }
+    return references;
+}
+function getClaimReferences(claim) {
+    const headerRegex = catalog_common.types.regex.YAMLHeaderRegex;
+    const multilineRegex = catalog_common.types.regex.YAMLMultilineRegex;
+    const listItemRegex = catalog_common.types.regex.YAMLListItemRegex;
+    const inlineListRegex = catalog_common.types.regex.YAMLInlineListRegex;
+    const valueRegex = catalog_common.types.regex.GenericRefRegex;
+    const refs = [];
+    let multilineMargin = -1;
+    for (const line of claim.split('\n')) {
+        if (multilineMargin >= 0) {
+            const currentLineMargin = line.length - line.trimStart().length;
+            if (currentLineMargin > multilineMargin) {
+                continue;
+            }
+            else {
+                multilineMargin = -1;
+            }
+        }
+        if (!line.match(headerRegex) && !line.match(listItemRegex))
+            continue;
+        let lineValue = line.match(headerRegex)
+            ? line.replace(headerRegex, '')
+            : line.replace(listItemRegex, '');
+        if (lineValue.match(valueRegex)) {
+            lineValue = lineValue.replace(/"/g, '').replace(/'/g, '');
+            let pendingRefs = [];
+            if (lineValue.match(inlineListRegex)) {
+                lineValue = lineValue
+                    .replace('[', '')
+                    .replace(']', '')
+                    .replace(/\s/g, '');
+                pendingRefs = lineValue.split(',');
+            }
+            else {
+                pendingRefs.push(lineValue);
+            }
+            for (const ref of pendingRefs) {
+                refs.push(resolveFirestartrRef(ref));
+            }
+        }
+        else if (lineValue.match(multilineRegex)) {
+            multilineMargin = line.length - line.trimStart().length;
+        }
+    }
+    return refs;
+}
+function resolveFirestartrRef(reference) {
+    const splittedRef = reference.split(':');
+    if (splittedRef.length === 2)
+        return `${kindMap[splittedRef[0]]}-${splittedRef[1]}`;
+    return '';
+}
+
+;// CONCATENATED MODULE: external "node:child_process"
+const external_node_child_process_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:child_process");
+;// CONCATENATED MODULE: ../cdk8s_renderer/src/loader/lazy_loader.ts
+
+
+
+
+
+
+
+const lazy_loader_log = src_default()('firestartr:renderer:lazy_loader');
+async function loadClaim(claimRef, defaults, patchClaim, loadInitializers, loadGlobals, loadOverrides, loadNormalizers, cwd) {
+    try {
+        let result = {};
+        // cargas datos con grep
+        const claimData = await lazyGetClaim(claimRef.split(/-/)[0], claimRef.replace(/^[^-]+-/, ''), cwd);
+        const claim = patchClaim(catalog_common.io.fromYaml(claimData), defaults);
+        result[claimRef] = {};
+        result[claimRef]['claim'] = claim;
+        result[claimRef]['claimPath'] = VisitedClaims[claimRef];
+        result[claimRef]['initializers'] = await loadInitializers(claim);
+        result[claimRef]['globals'] = await loadGlobals(claim);
+        result[claimRef]['overrides'] = loadOverrides(claim);
+        result[claimRef]['normalizers'] = await loadNormalizers(claim, result[claimRef]['claimPath']);
+        const claimKind = claim.kind;
+        const references = extractAllRefs(claimData);
+        for (const ref of references) {
+            if (!result[ref]) {
+                const resolvedReferences = await loadClaim(ref, defaults, patchClaim, loadInitializers, loadGlobals, loadOverrides, loadNormalizers, cwd);
+                result = lodash_default().merge(result, resolvedReferences);
+            }
+        }
+        return result;
+    }
+    catch (e) {
+        if (e.message.indexOf(claimRef) > -1) {
+            throw new Error(`Error when loading main claim ${claimRef}: ${e.message}`);
+        }
+        else {
+            throw new Error(`Error when loading dependency: ${e.message}`);
+        }
+    }
+}
+const LoadedClaims = {};
+const VisitedClaims = {};
+async function lazyGetClaim(kind, name, cwd) {
+    const indice = `${kind}-${name}`;
+    if (indice in LoadedClaims)
+        return LoadedClaims[indice];
+    await getClaimsByName(name, cwd);
+    if (indice in LoadedClaims) {
+        return LoadedClaims[indice];
+    }
+    else {
+        throw new Error(`Error: ${kind}-${name} not found`);
+    }
+}
+async function getClaimsByName(name, cwd = '.') {
+    return new Promise((ok, ko) => {
+        const handler = (0,external_node_child_process_namespaceObject.spawn)('grep', ['-r', '-l', '--include=*', '-E', `name: "?${name}"?`, '.'], {
+            cwd: cwd,
+        });
+        const entradas = [];
+        handler.stdout.on('data', (data) => {
+            const fileNameList = data
+                .toString('utf-8')
+                .split(/\n/)
+                .filter((l) => l !== '');
+            for (const fileName of fileNameList) {
+                // only yaml files
+                if (!fileName.match(/\.yml$|\.yaml$/)) {
+                    continue;
+                }
+                // only entries not already visited
+                if (Object.values(VisitedClaims).includes(fileName)) {
+                    continue;
+                }
+                entradas.push(external_path_.join(cwd, fileName));
+            }
+        });
+        handler.on('close', () => {
+            Promise.all(entradas.map((entrada) => {
+                return loadRawClaim(entrada);
+            }))
+                .then(() => {
+                ok();
+            })
+                .catch(() => {
+                ko();
+            });
+        });
+    });
+}
+async function loadRawClaim(entry) {
+    return new Promise((ok, ko) => {
+        external_fs_.readFile(entry, 'utf-8', (error, data) => {
+            if (error)
+                return ko(`Reading ${entry}: ${error}`);
+            const claim = catalog_common.io.fromYaml(data);
+            if (!('kind' in claim && 'name' in claim)) {
+                lazy_loader_log(`Invalid claim file ${entry}`);
+            }
+            LoadedClaims[`${claim.kind}-${claim.name}`] = data;
+            VisitedClaims[`${claim.kind}-${claim.name}`] = entry;
+            ok();
+        });
+    });
+}
+
 ;// CONCATENATED MODULE: ../cdk8s_renderer/src/loader/loader.ts
 
 
@@ -287108,6 +287366,8 @@ const NORMALIZERS = [
 
 
 
+
+
 
 const loader_log = src_default()('firestartr:renderer:loader');
 const isYamlFile = new RegExp(/\.(yaml|yml)$/);
@@ -287334,7 +287594,7 @@ function patchClaim(claim, defaultsClaims) {
  * - An object promise which contains each loaded CR
  *
  */
-async function loadCRs(crsPath = config_getPath('crs'), excludedPaths = [config_getPath('globals'), config_getPath('initializers')]) {
+async function loadCRs(crsPath = config_getPath('crs'), excludedPaths = [config_getPath('globals'), config_getPath('initializers')], allowedClaimReferences = []) {
     const result = {};
     await crawlWithExclusions(crsPath, (entry) => {
         return isYamlFile.test(entry);
@@ -287347,7 +287607,10 @@ async function loadCRs(crsPath = config_getPath('crs'), excludedPaths = [config_
             if (result[`${yamlData.kind}-${yamlData.metadata.name}`]) {
                 loader_log(`Duplicate CR ${yamlData.kind}-${yamlData.metadata.name}`);
             }
-            result[`${yamlData.kind}-${yamlData.metadata.name}`] = yamlData;
+            if (allowedClaimReferences.length === 0 ||
+                allowedClaimReferences.includes(yamlData.metadata?.annotations?.[catalog_common.generic.getFirestartrAnnotation('claim-ref')])) {
+                result[`${yamlData.kind}-${yamlData.metadata.name}`] = yamlData;
+            }
         }
     }, excludedPaths.concat(getAdditionalPaths()));
     return result;
@@ -287465,6 +287728,24 @@ async function loadAll() {
     data['renames'] = await loadRenames(data['renderClaims'], data['crs']);
     return data;
 }
+async function loadClaimsList(claimRefList, claimsPath = config_getPath('claims')) {
+    const data = {
+        renderClaims: {},
+        crs: {},
+    };
+    const defaults = loadClaimDefaults();
+    for (const claimRef of claimRefList) {
+        const renderedClaimData = await loadClaim(claimRef, defaults, patchClaim, loadInitializers, loadGlobals, loadOverrides, loadNormalizers, claimsPath);
+        data.renderClaims = lodash_default().merge(data.renderClaims, renderedClaimData);
+    }
+    const crClaimReferences = [];
+    for (const ref of Object.keys(data.renderClaims)) {
+        // Replaces only the first instance of '-'
+        crClaimReferences.push(ref.replace('-', '/'));
+    }
+    data['crs'] = await loadCRs(config_getPath('crs'), [config_getPath('globals'), config_getPath('initializers')], crClaimReferences);
+    return data;
+}
 function getOrg() {
     const groupOrg = catalog_common.environment.getFromEnvironmentWithDefault(catalog_common.types.envVars.org, '');
     return groupOrg;
@@ -287674,62 +287955,6 @@ function isTerraformWorkspace(cr) {
     return cr.kind === 'FirestartrTerraformWorkspace';
 }
 
-;// CONCATENATED MODULE: ../cdk8s_renderer/src/refsSorter/refsExtractor.ts
-
-function extractRefs(renderClaims, kind) {
-    const result = {};
-    for (const key in renderClaims) {
-        const claim = renderClaims[key].claim;
-        let refs = [];
-        switch (kind) {
-            case 'TFWorkspaceClaim':
-                refs = getTfWorkspacesRefs(claim.providers.terraform.values);
-                break;
-            case 'GroupClaim':
-                /**
-                 * Groups can have refs to other groups in parent property
-                 **/
-                refs = getGroupParentRef(claim.parent);
-                break;
-            default:
-                throw new Error(`No refs for kind ${kind}`);
-        }
-        result[claim.name] = {
-            name: `${claim.kind}-${claim.name}`,
-            refs: refs,
-        };
-    }
-    return result;
-}
-function getGroupParentRef(parent, references = []) {
-    if (!parent)
-        return [];
-    const regex = catalog_common.types.regex.GroupRefRegex;
-    for (const match of parent.matchAll(regex)) {
-        console.log(match);
-        const [_, claimName] = match;
-        references.push(claimName);
-    }
-    return references;
-}
-function getTfWorkspacesRefs(values, references = []) {
-    const regex = catalog_common.types.regex.TFWorkspaceRefRegex;
-    for (const key in values) {
-        switch (typeof values[key]) {
-            case 'object':
-                getTfWorkspacesRefs(values[key], references);
-                break;
-            case 'string':
-                for (const match of values[key].matchAll(regex)) {
-                    const [_, claimName] = match;
-                    references.push(claimName);
-                }
-                break;
-        }
-    }
-    return references;
-}
-
 ;// CONCATENATED MODULE: ../cdk8s_renderer/src/refsSorter/refsSorter.ts
 
 /**
@@ -292623,8 +292848,14 @@ async function renderClaim(catalogScope, firestartrScope, claim, patches, previo
  *   rendered firestartr-all group
  *
  */
-async function renderer_render(catalogScope, firestartrScope, activateReferentialIntegrityValidation = true) {
-    const data = await loadAll();
+async function renderer_render(catalogScope, firestartrScope, activateReferentialIntegrityValidation = true, claimList = []) {
+    let data;
+    if (claimList.length > 0) {
+        data = await loadClaimsList(claimList);
+    }
+    else {
+        data = await loadAll();
+    }
     const result = await renderClaims(catalogScope, firestartrScope, data);
     if (activateReferentialIntegrityValidation) {
         validateReferentialIntegrity(result);
@@ -292934,7 +293165,7 @@ async function addLastStateAndLastClaimAnnotations(filePath, lastStatePRLink, la
  * This function returns nothing.
  *
  */
-async function runRenderer(globalsPath, initializersPath, claimsPath, crsPath, claimsDefaults, outputCatalogDir, outputCrDir, renamesEnabled, provider, excludedPaths = [], validateReferentialIntegrity) {
+async function runRenderer(globalsPath, initializersPath, claimsPath, crsPath, claimsDefaults, outputCatalogDir, outputCrDir, renamesEnabled, provider, excludedPaths = [], validateReferentialIntegrity, claimRefs = '') {
     configureProvider(provider);
     setPath('initializers', initializersPath);
     setPath('crs', crsPath);
@@ -292953,7 +293184,11 @@ async function runRenderer(globalsPath, initializersPath, claimsPath, crsPath, c
         outputFileExtension: '.yaml',
         yamlOutputType: lib.YamlOutputType.FILE_PER_RESOURCE,
     });
-    await renderer_render(catalogApp, firestartrApp, validateReferentialIntegrity === 'enabled' ? true : false);
+    let claimRefsList = [];
+    if (claimRefs) {
+        claimRefsList = claimRefs.replace(/\s/, '').split(',');
+    }
+    await renderer_render(catalogApp, firestartrApp, validateReferentialIntegrity === 'enabled' ? true : false, claimRefsList);
     catalogApp.synth();
     firestartrApp.synth();
 }
@@ -301086,6 +301321,7 @@ const cdk8s_rendererSubcommands = {
             defaultValue: '/tmp/.resources',
         },
         { name: 'disableRenames', type: Boolean, defaultValue: false },
+        { name: 'claimRefsList', type: String, defaultValue: '' },
         /**
          * Path where the claims defaults are located
          */
@@ -301114,7 +301350,7 @@ const cdk8s_rendererSubcommands = {
     run: async (options) => {
         if (options['render']) {
             console.table(options);
-            await runRenderer(options['globals'], options['initializers'], options['claims'], options['previousCRs'], options['claimsDefaults'], options['outputCatalogDir'], options['outputCrDir'], !options['disableRenames'], options['provider'], options['excludePath'], options['validateReferentialIntegrity']);
+            await runRenderer(options['globals'], options['initializers'], options['claims'], options['previousCRs'], options['claimsDefaults'], options['outputCatalogDir'], options['outputCrDir'], !options['disableRenames'], options['provider'], options['excludePath'], options['validateReferentialIntegrity'], options['claimRefsList']);
         }
         else if (options['compare']) {
             await cdk8s_renderer.runComparer(options['claimsFromMain'], options['claimsFromPr'], options['claimsDefaults'], options['wetReposConfig'], options['outputComparer']);

package/build/packages/catalog_common/src/types/regex.d.ts

@@ -2,3 +2,8 @@ export declare const TFWorkspaceRefRegex: RegExp;
 export declare const SecretRefRegex: RegExp;
 export declare const GroupRefRegex: RegExp;
 export declare const TFWorkspaceRefCR: RegExp;
+export declare const GenericRefRegex: RegExp;
+export declare const YAMLHeaderRegex: RegExp;
+export declare const YAMLListItemRegex: RegExp;
+export declare const YAMLInlineListRegex: RegExp;
+export declare const YAMLMultilineRegex: RegExp;

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

@@ -37,4 +37,4 @@ declare const _default: {
     addLastStateAndLastClaimAnnotations: typeof addLastStateAndLastClaimAnnotations;
 };
 export default _default;
-export declare function runRenderer(globalsPath: string, initializersPath: string, claimsPath: string, crsPath: string, claimsDefaults: string, outputCatalogDir: string, outputCrDir: string, renamesEnabled: boolean, provider: AllowedProviders, excludedPaths: string[], validateReferentialIntegrity: string): Promise<void>;
+export declare function runRenderer(globalsPath: string, initializersPath: string, claimsPath: string, crsPath: string, claimsDefaults: string, outputCatalogDir: string, outputCrDir: string, renamesEnabled: boolean, provider: AllowedProviders, excludedPaths: string[], validateReferentialIntegrity: string, claimRefs?: string): Promise<void>;

package/build/packages/cdk8s_renderer/src/loader/lazy_loader.d.ts

@@ -0,0 +1,5 @@
+import { InitializerPatches } from '../initializers/base';
+import { GlobalSection } from '../globals/base';
+import { OverriderPatches } from '../overriders/base';
+import { Normalizer } from '../normalizers/base';
+export declare function loadClaim(claimRef: string, defaults: any, patchClaim: (claim: any, defaults: any) => any, loadInitializers: (claim: any) => Promise<InitializerPatches[]>, loadGlobals: (claim: any) => Promise<GlobalSection[]>, loadOverrides: (claim: any) => OverriderPatches[], loadNormalizers: (claim: any, path: string) => Promise<Normalizer[]>, cwd?: string): Promise<{}>;

package/build/packages/cdk8s_renderer/src/loader/loader.d.ts

@@ -3,6 +3,7 @@ import { GlobalSection } from '../globals/base';
 import { OverriderPatches } from '../overriders/base';
 import { Normalizer } from '../normalizers/base';
 import { RenderClaims } from '../renderer/types';
+export declare const isYamlFile: RegExp;
 export declare function loadSystems(): Promise<any[]>;
 export declare function loadDomains(): Promise<any[]>;
 export declare function loadGlobals(claim: any): Promise<GlobalSection[]>;
@@ -17,7 +18,7 @@ export declare function loadInitializers(claim: any, initializersPath?: string):
 export declare function loadClaims(claimsPath?: string): Promise<RenderClaims>;
 export declare function loadClaimDefaults(): any;
 export declare function patchClaim(claim: any, defaultsClaims: any): any;
-export declare function loadCRs(crsPath?: string, excludedPaths?: string[]): Promise<any>;
+export declare function loadCRs(crsPath?: string, excludedPaths?: string[], allowedClaimReferences?: string[]): Promise<any>;
 export interface IRenameResult {
     kind: string;
     claimPath: string;
@@ -38,3 +39,8 @@ export declare function loadAll(): Promise<{
     crs: any;
     renames?: IRenameResult[];
 }>;
+export declare function loadClaimsList(claimRefList: string[], claimsPath?: string): Promise<{
+    renderClaims: RenderClaims;
+    crs: any;
+    renames?: IRenameResult[];
+}>;

package/build/packages/cdk8s_renderer/src/refsSorter/refsExtractor.d.ts

@@ -1,4 +1,5 @@
 import { RenderClaims } from '../renderer/types';
 export declare function extractRefs(renderClaims: RenderClaims, kind: string): any;
+export declare function extractAllRefs(claimData: string): any[];
 export declare function getGroupParentRef(parent: string, references?: any[]): any[];
 export declare function getTfWorkspacesRefs(values: any, references?: any[]): any[];

package/build/packages/cdk8s_renderer/src/renderer/renderer.d.ts

@@ -1,3 +1,3 @@
 import { Construct } from 'constructs';
 import { RenderedCrMap } from './types';
-export declare function render(catalogScope: Construct, firestartrScope: Construct, activateReferentialIntegrityValidation?: boolean): Promise<RenderedCrMap>;
+export declare function render(catalogScope: Construct, firestartrScope: Construct, activateReferentialIntegrityValidation?: boolean, claimList?: string[]): Promise<RenderedCrMap>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@firestartr/cli",
-  "version": "1.39.1",
+  "version": "1.39.2-SNAPSHOT+PR934",
   "private": false,
   "description": "Commandline tool",
   "main": "build/main.js",