@firestartr/cli 1.54.0-snapshot-2 → 1.54.0-snapshot-4

package/build/index.js

@@ -357283,8 +357283,10 @@ class TFWorkspaceNormalizer extends Normalizer {
 async function normalizeModuleContent(tfRootModulePath) {
     let content = '';
     const files = {};
-    await crawl(tfRootModulePath, (entry) => {
-        return entry.endsWith('.tf');
+    await crawl(tfRootModulePath, 
+    // bring all files, not only tf
+    (_) => {
+        return true;
     }, (entry, data) => {
         files[entry] = data;
     });
@@ -358548,7 +358550,11 @@ const ArgoCDSchemas = [argocd_schema];
                         additionalProperties: false,
                         type: 'object',
                         properties: {
-                            secretName: { type: 'string' },
+                            secretName: {
+                                type: 'string',
+                                description: 'Validation for Kubernetes Secret keys, allowing only alphanumeric characters, hyphens, underscores, and dots.',
+                                pattern: '^([a-zA-Z0-9._-]+)$',
+                            },
                             remoteRef: { type: 'string' },
                         },
                         required: ['secretName'],
@@ -358611,29 +358617,24 @@ const ArgoCDSchemas = [argocd_schema];
             allOf: [
                 { $ref: 'firestartr.dev://common/ClaimProviderEnvelope' },
                 {
-                    anyOf: [
-                        {
-                            properties: {
-                                externalSecrets: {
-                                    $ref: 'firestartr.dev://secrets/ExternalSecretsSection',
-                                },
-                                secretStore: {
-                                    $ref: 'firestartr.dev://secrets/SecretStore',
-                                },
-                            },
-                            required: ['secretStore', 'externalSecrets'],
+                    type: 'object',
+                    properties: {
+                        externalSecrets: {
+                            $ref: 'firestartr.dev://secrets/ExternalSecretsSection',
                         },
-                        {
-                            properties: {
-                                pushSecrets: {
-                                    $ref: 'firestartr.dev://secrets/PushSecretsSection',
-                                },
-                                secretStore: {
-                                    $ref: 'firestartr.dev://secrets/SecretStore',
-                                },
-                            },
-                            required: ['secretStore', 'pushSecrets'],
+                        secretStore: {
+                            $ref: 'firestartr.dev://secrets/SecretStore',
                         },
+                        pushSecrets: {
+                            $ref: 'firestartr.dev://secrets/PushSecretsSection',
+                        },
+                    },
+                    // 1. MANDATORY RULE (ALWAYS): secretStore
+                    required: ['secretStore'],
+                    // 2. CONDITIONAL RULE (AT LEAST ONE): externalSecrets OR pushSecrets
+                    anyOf: [
+                        { required: ['externalSecrets'] },
+                        { required: ['pushSecrets'] },
                     ],
                 },
             ],
@@ -358861,7 +358862,7 @@ function checkGrep() {
         });
     });
 }
-async function loadClaim(claimRef, org, defaults = loadClaimDefaults(), patchClaim = loader_patchClaim, loadInitializers, loadGlobals, loadOverrides, loadNormalizers, cwd, existingRefs = {}) {
+async function loadClaim(claimRef, org, defaults = loadClaimDefaults(), patchClaim = loader_patchClaim, loadInitializers, loadGlobals, loadOverrides, loadNormalizers, cwd, existingRefs = {}, postValidations = new Map()) {
     await checkGrep();
     let result = existingRefs;
     cdk8s_renderer_src_logger.info(`Load reference ${claimRef}`);
@@ -358899,7 +358900,7 @@ async function loadClaim(claimRef, org, defaults = loadClaimDefaults(), patchCla
         const references = extractAllRefs(catalog_common.io.toYaml(claim));
         for (const ref of references) {
             if (!result[ref]) {
-                const resolvedReferences = await loadClaim(ref, org, defaults, patchClaim, loadInitializers, loadGlobals, loadOverrides, loadNormalizers, cwd, result);
+                const [resolvedReferences] = await loadClaim(ref, org, defaults, patchClaim, loadInitializers, loadGlobals, loadOverrides, loadNormalizers, cwd, result, postValidations);
                 result = lodash_default().merge(result, resolvedReferences);
             }
         }
@@ -358907,7 +358908,7 @@ async function loadClaim(claimRef, org, defaults = loadClaimDefaults(), patchCla
     catch (err) {
         throw `Lazy Loading: ${err}`;
     }
-    return result;
+    return [result, postValidations];
 }
 let LoadedClaims = {};
 let VisitedClaims = {};
@@ -359309,7 +359310,7 @@ async function loadClaimsList(claimRefList, claimsPath = config_getPath('claims'
     };
     const defaults = loadClaimDefaults();
     for await (const claimRef of claimRefList) {
-        const renderedClaimData = await loadClaim(claimRef, getOrg(), defaults, loader_patchClaim, loadInitializers, loadGlobals, loadOverrides, loadNormalizers, claimsPath);
+        const [renderedClaimData] = await loadClaim(claimRef, getOrg(), defaults, loader_patchClaim, loadInitializers, loadGlobals, loadOverrides, loadNormalizers, claimsPath);
         data.renderClaims = lodash_default().merge(data.renderClaims, renderedClaimData);
     }
     const crClaimReferences = [];
@@ -365398,11 +365399,27 @@ async function renderClaim(catalogScope, firestartrScope, claim, patches, previo
 }
 
 ;// CONCATENATED MODULE: ../cdk8s_renderer/src/validations/crossReferences.ts
+
 const IS_COMPONENT_CLAIM_REF = new RegExp(/^ComponentClaim-/);
+const IS_TF_WORKSPACE = new RegExp(/^TFWorkspaceClaim-/);
 function validateSubReferences(renderClaims) {
     for (const ref of Object.keys(renderClaims)) {
         if (IS_COMPONENT_CLAIM_REF.test(ref))
             validateClaimsSecretsRefs(ref, renderClaims);
+        else if (IS_TF_WORKSPACE.test(ref))
+            validateTFClaimsSecretsRefs(ref, renderClaims);
+    }
+}
+function validateTFClaimsSecretsRefs(ref, renderClaims) {
+    const claim = renderClaims[ref].claim;
+    const values = claim.providers?.terraform?.values;
+    const secretRefs = Object.values(values).filter((v) => isRepoSecretRef(v));
+    for (const secret of secretRefs) {
+        const [secretName, key] = secret.split(':').slice(2);
+        const keyFound = searchSecretKey(renderClaims[`SecretsClaim-${secretName}`].claim, key);
+        if (!keyFound) {
+            throw new Error(`CrossReference error: TFWorkspaceClaim/${claim.name} references a non-existent secret key: '${secretName}:${key}'`);
+        }
     }
 }
 function validateClaimsSecretsRefs(ref, renderClaims) {
@@ -371906,25 +371923,36 @@ class WriterBackend extends writer {
 class WriterProvider extends writer {
     constructor(providers) {
         super();
+        this.jsonOutput = {};
         this.providers = providers;
     }
+    async render(renderType = 'tf') {
+        await this._render();
+        if (renderType === 'tf') {
+            return this.output.trim();
+        }
+        else if (renderType === 'json') {
+            return JSON.stringify(this.jsonOutput, null, 2);
+        }
+        else {
+            throw new Error(`Unsupported render type: ${renderType}`);
+        }
+    }
     async _render() {
         for (const provider of this.providers) {
-            this.output += this.__renderProvider(provider);
+            if (provider.inline) {
+                this.output += provider.inline + '\n';
+            }
+            else {
+                this.__populateJsonOutput(provider);
+            }
         }
     }
-    __renderProvider(provider) {
-        let configString = '';
-        if (provider.inline)
-            return provider.inline;
-        for (const key in provider.config) {
-            configString += `${key} = "${provider.config[key]}"\n`;
+    __populateJsonOutput(provider) {
+        if (this.jsonOutput[provider.name] === undefined) {
+            this.jsonOutput[provider.name] = [];
         }
-        return `
-    provider "${provider.name}" {
-
- ${configString}
-}`;
+        this.jsonOutput[provider.name].push(provider.config);
     }
 }
 
@@ -371960,6 +371988,26 @@ class WriterTerraform extends writer {
         this.tfStateKey = tfStateKey;
         this.writeRequiredProvidersBlock = writeRequiredProvidersBlock;
     }
+    async render(renderType = 'tf') {
+        if (renderType === 'tf') {
+            return super.render();
+        }
+        else {
+            await this._renderJson();
+            return this.output.trim();
+        }
+    }
+    async _renderJson() {
+        const providersString = await new WriterProvider(this.requiredProviders).render('json');
+        if (providersString.trim() !== '{}') {
+            this.output = `{
+  "provider": ${providersString}
+}`; // providersString is already a JSON object string
+        }
+        else {
+            this.output = ''; // No providers to include
+        }
+    }
     async _render() {
         const providersString = await new WriterProvider(this.requiredProviders).render();
         let backend = '';
@@ -372168,17 +372216,44 @@ function fCheckString(keys, refs) {
     return true;
 }
 
+;// CONCATENATED MODULE: ../terraform_provisioner/src/writer_provider_tf_json.ts
+
+
+
+class WriterProviderJson extends writer {
+    constructor(mainBlock, providers, backend, tfStateKey) {
+        super();
+        this.mainBlock = mainBlock;
+        this.providers = providers;
+        this.backend = backend;
+        this.tfStateKey = tfStateKey;
+    }
+    async _render() {
+        this.output = await new WriterTerraform(this.providers, this.backend, this.tfStateKey, false).render('json');
+    }
+    writeToTerraformProject(mainTfPath) {
+        if (this.output.trim() === '') {
+            terraform_provisioner_src_logger.info(`Skipping writing ${mainTfPath} as there is no provider to write.`);
+        }
+        else {
+            super.writeToTerraformProject(mainTfPath);
+        }
+    }
+}
+
 ;// CONCATENATED MODULE: ../terraform_provisioner/src/project_tf.ts
 
 
 
 
 
+
 class project_tf_TFProjectManager {
     constructor(ctx) {
         this.tfOutput = '';
         this.projectPath = ctx.projectPath;
         this.mainTfWriter = new WriterMainTf(ctx.inline, ctx.requiredProviders, ctx.backend, ctx.tfStateKey);
+        this.providerJsonWriter = new WriterProviderJson(ctx.inline, ctx.requiredProviders, ctx.backend, ctx.tfStateKey);
         this.tfVarsJsonWriter = new WriterTfVarsJson(ctx.values, ctx.references);
         this.secrets = ctx.secrets;
     }
@@ -372195,7 +372270,9 @@ class project_tf_TFProjectManager {
     }
     async build() {
         await this.mainTfWriter.render();
-        this.mainTfWriter.writeToTerraformProject(external_path_.join(this.projectPath, 'main.tf'));
+        this.mainTfWriter.writeToTerraformProject(external_path_.join(this.projectPath, 'firestartr-main.tf'));
+        await this.providerJsonWriter.render();
+        this.providerJsonWriter.writeToTerraformProject(external_path_.join(this.projectPath, 'firestartr-providers.tf.json'));
         await this.tfVarsJsonWriter.render();
         this.tfVarsJsonWriter.writeToTerraformProject(external_path_.join(this.projectPath, 'terraform.tfvars.json'));
     }
@@ -372328,14 +372405,16 @@ var lib_ajv_default = /*#__PURE__*/__nccwpck_require__.n(lib_ajv);
 
 
 
+
 class TFProjectManagerRemote {
     constructor(ctx) {
         this.tfOutput = '';
         this.ctx = ctx;
         this.projectPath = ctx.projectPath;
+        this.secrets = ctx.secrets;
         this.writerTerraform = new WriterTerraform(ctx.requiredProviders, ctx.backend, ctx.tfStateKey, false);
+        this.providerJsonWriter = new WriterProviderJson(ctx.inline, ctx.requiredProviders, ctx.backend, ctx.tfStateKey);
         this.tfVarsJsonWriter = new WriterTfVarsJson(ctx.values, ctx.references);
-        this.secrets = ctx.secrets;
     }
     getOutput() {
         return this.tfOutput;
@@ -372353,7 +372432,9 @@ class TFProjectManagerRemote {
         await this.__configGit();
         await this.__initFromModule();
         await this.writerTerraform.render();
-        this.writerTerraform.writeToTerraformProject(external_path_.join(this.projectPath, 'terraform.tf'));
+        this.writerTerraform.writeToTerraformProject(external_path_.join(this.projectPath, 'firestartr-terraform.tf'));
+        await this.providerJsonWriter.render();
+        this.providerJsonWriter.writeToTerraformProject(external_path_.join(this.projectPath, 'firestartr-providers.tf.json'));
         await this.tfVarsJsonWriter.render();
         this.tfVarsJsonWriter.writeToTerraformProject(external_path_.join(this.projectPath, 'terraform.tfvars.json'));
     }
@@ -373360,7 +373441,6 @@ function resolveReferences(item, deps) {
     try {
         const references = {};
         const itemReferences = item.spec.references;
-        console.dir(itemReferences);
         // if(!process.env.TONISILLO) process.exit(1)
         for (const iRef of itemReferences) {
             const ref = deps[`${iRef.ref.kind}-${iRef.ref.name}`];
@@ -374257,7 +374337,7 @@ async function tfWorkspacePlan(opts) {
         fDebug('Context built');
         const command = getCommandByStatus(status);
         fDebug('Running terraform provisioner');
-        const tfOutput = await runTerraformProvisioner(ctx, command);
+        const tfOutput = await runTerraformProvisioner(ctx, command, undefined);
         fDebug('Terraform provisioner finished');
         fDebug('Publishing plan');
         await publishPlan(cr, tfOutput, prNumber, repo, owner);

package/build/packages/cdk8s_renderer/src/claims/base/schemas/index.d.ts

@@ -887,6 +887,8 @@ declare const schemas: {
                             properties: {
                                 secretName: {
                                     type: string;
+                                    description: string;
+                                    pattern: string;
                                 };
                                 remoteRef: {
                                     type: string;
@@ -947,31 +949,27 @@ declare const schemas: {
                 description: string;
                 allOf: ({
                     $ref: string;
+                    type?: undefined;
+                    properties?: undefined;
+                    required?: undefined;
                     anyOf?: undefined;
                 } | {
-                    anyOf: ({
-                        properties: {
-                            externalSecrets: {
-                                $ref: string;
-                            };
-                            secretStore: {
-                                $ref: string;
-                            };
-                            pushSecrets?: undefined;
+                    type: string;
+                    properties: {
+                        externalSecrets: {
+                            $ref: string;
                         };
-                        required: string[];
-                    } | {
-                        properties: {
-                            pushSecrets: {
-                                $ref: string;
-                            };
-                            secretStore: {
-                                $ref: string;
-                            };
-                            externalSecrets?: undefined;
+                        secretStore: {
+                            $ref: string;
+                        };
+                        pushSecrets: {
+                            $ref: string;
                         };
+                    };
+                    required: string[];
+                    anyOf: {
                         required: string[];
-                    })[];
+                    }[];
                     $ref?: undefined;
                 })[];
             };

package/build/packages/cdk8s_renderer/src/claims/external-secrets/external-secrets.schema.d.ts

@@ -31,6 +31,8 @@ declare const _default: {
                         properties: {
                             secretName: {
                                 type: string;
+                                description: string;
+                                pattern: string;
                             };
                             remoteRef: {
                                 type: string;
@@ -91,31 +93,27 @@ declare const _default: {
             description: string;
             allOf: ({
                 $ref: string;
+                type?: undefined;
+                properties?: undefined;
+                required?: undefined;
                 anyOf?: undefined;
             } | {
-                anyOf: ({
-                    properties: {
-                        externalSecrets: {
-                            $ref: string;
-                        };
-                        secretStore: {
-                            $ref: string;
-                        };
-                        pushSecrets?: undefined;
+                type: string;
+                properties: {
+                    externalSecrets: {
+                        $ref: string;
                     };
-                    required: string[];
-                } | {
-                    properties: {
-                        pushSecrets: {
-                            $ref: string;
-                        };
-                        secretStore: {
-                            $ref: string;
-                        };
-                        externalSecrets?: undefined;
+                    secretStore: {
+                        $ref: string;
+                    };
+                    pushSecrets: {
+                        $ref: string;
                     };
+                };
+                required: string[];
+                anyOf: {
                     required: string[];
-                })[];
+                }[];
                 $ref?: undefined;
             })[];
         };

package/build/packages/cdk8s_renderer/src/claims/external-secrets/index.d.ts

@@ -31,6 +31,8 @@ export declare const SecretsSchemas: {
                         properties: {
                             secretName: {
                                 type: string;
+                                description: string;
+                                pattern: string;
                             };
                             remoteRef: {
                                 type: string;
@@ -91,31 +93,27 @@ export declare const SecretsSchemas: {
             description: string;
             allOf: ({
                 $ref: string;
+                type?: undefined;
+                properties?: undefined;
+                required?: undefined;
                 anyOf?: undefined;
             } | {
-                anyOf: ({
-                    properties: {
-                        externalSecrets: {
-                            $ref: string;
-                        };
-                        secretStore: {
-                            $ref: string;
-                        };
-                        pushSecrets?: undefined;
+                type: string;
+                properties: {
+                    externalSecrets: {
+                        $ref: string;
                     };
-                    required: string[];
-                } | {
-                    properties: {
-                        pushSecrets: {
-                            $ref: string;
-                        };
-                        secretStore: {
-                            $ref: string;
-                        };
-                        externalSecrets?: undefined;
+                    secretStore: {
+                        $ref: string;
+                    };
+                    pushSecrets: {
+                        $ref: string;
                     };
+                };
+                required: string[];
+                anyOf: {
                     required: string[];
-                })[];
+                }[];
                 $ref?: undefined;
             })[];
         };

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

@@ -2,5 +2,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, org: 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, existingRefs?: any): Promise<any>;
+export declare function loadClaim(claimRef: string, org: 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, existingRefs?: any, postValidations?: Map<string, Function[]>): Promise<any[]>;
 export declare function resetLazyLoader(): void;

package/build/packages/terraform_provisioner/src/project_tf.d.ts

@@ -1,9 +1,11 @@
 /// <reference types="node" />
 import { WriterMainTf } from './writer_main_tf';
 import { WriterTfVarsJson } from './writer_tfvars_json';
+import { WriterProviderJson } from './writer_provider_tf_json';
 import { PassThrough } from 'stream';
 export declare class TFProjectManager {
     mainTfWriter: WriterMainTf;
+    providerJsonWriter: WriterProviderJson;
     tfVarsJsonWriter: WriterTfVarsJson;
     secrets: any[];
     projectPath: string;

package/build/packages/terraform_provisioner/src/project_tf_remote.d.ts

@@ -1,9 +1,11 @@
 /// <reference types="node" />
 import { WriterTerraform } from './writer_terraform';
 import { WriterTfVarsJson } from './writer_tfvars_json';
+import { WriterProviderJson } from './writer_provider_tf_json';
 import { PassThrough } from 'stream';
 export declare class TFProjectManagerRemote {
     writerTerraform: WriterTerraform;
+    providerJsonWriter: WriterProviderJson;
     tfVarsJsonWriter: WriterTfVarsJson;
     ctx: any;
     secrets: any[];

package/build/packages/terraform_provisioner/src/writer_provider.d.ts

@@ -1,7 +1,9 @@
 import Writer from './writer';
 export declare class WriterProvider extends Writer {
     providers: any[];
+    jsonOutput: {};
     constructor(providers: any[]);
+    render(renderType?: string): Promise<string>;
     _render(): Promise<void>;
-    __renderProvider(provider: any): any;
+    __populateJsonOutput(provider: any): void;
 }

package/build/packages/terraform_provisioner/src/writer_provider_tf_json.d.ts

@@ -0,0 +1,10 @@
+import Writer from './writer';
+export declare class WriterProviderJson extends Writer {
+    providers: Array<any>;
+    mainBlock: string;
+    tfStateKey: string;
+    backend: any;
+    constructor(mainBlock: string, providers: Array<any>, backend: any, tfStateKey: string);
+    _render(): Promise<void>;
+    writeToTerraformProject(mainTfPath: string): void;
+}

package/build/packages/terraform_provisioner/src/writer_terraform.d.ts

@@ -5,5 +5,7 @@ export declare class WriterTerraform extends Writer {
     backend: any;
     tfStateKey: string;
     constructor(requiredProviders: Array<any>, backend: any, tfStateKey: string, writeRequiredProvidersBlock?: boolean);
+    render(renderType?: string): Promise<string>;
+    _renderJson(): Promise<void>;
     _render(): Promise<void>;
 }

package/package.json

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