@firestartr/cli 2.8.0-snapshot-maps-claim-generator-3 → 2.8.0-snapshot-4

package/build/index.js

@@ -320683,6 +320683,13 @@ const GithubSchemas = [
                         module: {
                             type: 'string',
                         },
+                        variants: {
+                            type: 'array',
+                            items: {
+                                $ref: 'firestartr.dev://terraform/TerraformProviderVariant',
+                            },
+                            description: 'variant clones of this workspace — stripped before parent claim validation',
+                        },
                         context: {
                             type: 'object',
                             properties: {
@@ -320717,6 +320724,90 @@ const GithubSchemas = [
                 },
             ],
         },
+        TerraformProviderVariantOverride: {
+            $id: 'firestartr.dev://terraform/TerraformProviderVariantOverride',
+            description: 'Override fields for a variant of a TFWorkspaceClaim',
+            type: 'object',
+            properties: {
+                name: {
+                    type: 'string',
+                    description: 'override the terraform provider name',
+                },
+                values: {
+                    type: 'object',
+                    additionalProperties: true,
+                    description: 'override values',
+                },
+                context: {
+                    type: 'object',
+                    properties: {
+                        providers: {
+                            type: 'array',
+                            items: {
+                                type: 'object',
+                                properties: { name: { type: 'string' } },
+                                additionalProperties: false,
+                            },
+                        },
+                        backend: {
+                            type: 'object',
+                            properties: { name: { type: 'string' } },
+                            additionalProperties: false,
+                        },
+                    },
+                    additionalProperties: false,
+                    description: 'override context',
+                },
+                files: {
+                    $ref: 'firestartr.dev://terraform/TerraformProviderFiles',
+                },
+                policy: {
+                    type: 'string',
+                    enum: [
+                        'apply',
+                        'create-only',
+                        'create-update-only',
+                        'full-control',
+                        'observe',
+                        'observe-only',
+                    ],
+                },
+                tfStateKey: {
+                    $ref: 'firestartr.dev://common/TerraformStateKey',
+                },
+                sync: {
+                    type: 'object',
+                    properties: {
+                        enabled: { type: 'boolean' },
+                        period: { type: 'string', pattern: '^[0-9]+[smhd]$' },
+                        schedule: { type: 'string' },
+                        schedule_timezone: { type: 'string' },
+                        policy: { type: 'string' },
+                    },
+                    additionalProperties: false,
+                },
+                valuesSchema: {
+                    type: 'string',
+                },
+            },
+            additionalProperties: false,
+        },
+        TerraformProviderVariant: {
+            $id: 'firestartr.dev://terraform/TerraformProviderVariant',
+            description: 'A single variant of a TFWorkspace',
+            type: 'object',
+            properties: {
+                name: {
+                    type: 'string',
+                    description: 'name of the variant — used as claim name and CR name base',
+                },
+                overrides: {
+                    $ref: 'firestartr.dev://terraform/TerraformProviderVariantOverride',
+                },
+            },
+            additionalProperties: false,
+            required: ['name', 'overrides'],
+        },
     },
 });
 
@@ -321187,6 +321278,12 @@ async function loadClaim(claimRef, org, defaults = loadClaimDefaults(), patchCla
     try {
         const claimData = await lazyGetClaim(claimRef.split(/-/)[0], claimRef.replace(/^[^-]+-/, ''), org, cwd);
         const claim = patchClaim(catalog_common/* default.io.fromYaml */.Z.io.fromYaml(claimData), defaults);
+        let variants = [];
+        if (claim.kind === 'TFWorkspaceClaim' &&
+            claim.providers?.terraform?.variants) {
+            variants = claim.providers.terraform.variants;
+            delete claim.providers.terraform.variants;
+        }
         logger.silly(`Patched claim is:
 		 ---
 			${catalog_common/* default.io.toYaml */.Z.io.toYaml(claim)}`);
@@ -321224,6 +321321,47 @@ async function loadClaim(claimRef, org, defaults = loadClaimDefaults(), patchCla
                 result = lodash_default().merge(result, resolvedReferences);
             }
         }
+        if (variants.length > 0) {
+            const parentClaimPath = VisitedClaims[claimRef];
+            for (const variant of variants) {
+                if (!variant.name || !variant.overrides) {
+                    throw new Error(`Variant in claim ${claimRef} is missing required field 'name' or 'overrides'`);
+                }
+                const prohibitedOverrideFields = ['source', 'module'];
+                for (const field of prohibitedOverrideFields) {
+                    if (field in variant.overrides) {
+                        throw new Error(`Variant '${variant.name}' in claim ${claimRef} cannot override '${field}'`);
+                    }
+                }
+                const variantClaim = lodash_default().cloneDeep(claim);
+                variantClaim.name = variant.name;
+                variantClaim.providers.terraform = lodash_default().merge({}, claim.providers.terraform, variant.overrides);
+                if (!variant.overrides.name) {
+                    variantClaim.providers.terraform.name = variant.name;
+                }
+                if (!variantClaim.annotations) {
+                    variantClaim.annotations = {};
+                }
+                variantClaim.annotations['firestartr.dev/variant-of'] =
+                    claim.providers.terraform.name;
+                const variantRef = `TFWorkspaceClaim-${variant.name}`;
+                if (result[variantRef]) {
+                    throw new Error(`Variant name '${variant.name}' from claim '${claimRef}' conflicts with existing claim '${variantRef}'`);
+                }
+                logger.info(`Creating synthetic variant claim ${variantRef}`);
+                result[variantRef] = {};
+                result[variantRef]['claim'] = variantClaim;
+                result[variantRef]['claimPath'] = parentClaimPath;
+                result = await setNonVirtualClaimAdditionalData(result, variantClaim, variantRef, loadInitializers, loadGlobals, loadOverrides, loadNormalizers);
+                const variantReferences = extractAllRefs(catalog_common/* default.io.toYaml */.Z.io.toYaml(variantClaim));
+                for (const ref of variantReferences) {
+                    if (!result[ref]) {
+                        const [resolvedReferences] = await loadClaim(ref, org, defaults, patchClaim, loadInitializers, loadGlobals, loadOverrides, loadNormalizers, cwd, result, postValidations);
+                        result = lodash_default().merge(result, resolvedReferences);
+                    }
+                }
+            }
+        }
     }
     catch (err) {
         throw `Lazy Loading: ${err}`;
@@ -323668,47 +323806,6 @@ function sanitizeApiEntityName(name) {
         .replace(/[^a-z0-9-]/g, '-')
         .replace(/^-+|-+$/g, '');
 }
-async function generateClaimsMap(claimsPath, outputPath, sha) {
-    const map = {
-        headers: {
-            sha: sha ?? '',
-        },
-        claims: {},
-    };
-    await crawlClaimsDir(claimsPath, claimsPath, map.claims);
-    await external_fs_default().promises.writeFile(outputPath, JSON.stringify(map, null, 2), 'utf-8');
-}
-async function crawlClaimsDir(dir, basePath, claims) {
-    let entries;
-    try {
-        entries = await (0,promises_.readdir)(dir, { withFileTypes: true });
-    }
-    catch (err) {
-        throw new Error(`Reading directory ${dir}: ${err}`);
-    }
-    for (const entry of entries) {
-        const fullPath = external_path_default().join(dir, entry.name);
-        if (entry.isDirectory()) {
-            await crawlClaimsDir(fullPath, basePath, claims);
-        }
-        else if (entry.isFile() && entry.name.match(/\.yaml$|\.yml$/)) {
-            try {
-                const data = await external_fs_default().promises.readFile(fullPath, 'utf-8');
-                const claim = catalog_common/* default.io.fromYaml */.Z.io.fromYaml(data);
-                if (!('kind' in claim && 'name' in claim)) {
-                    logger.warn(`Skipping file ${fullPath}: missing kind or name`);
-                    continue;
-                }
-                const ref = `${claim.kind}-${claim.name}`;
-                const relativePath = external_path_default().relative(basePath, fullPath);
-                claims[ref] = { filePath: relativePath };
-            }
-            catch (err) {
-                throw new Error(`Error processing claim file ${fullPath}: ${err}`);
-            }
-        }
-    }
-}
 
 ;// CONCATENATED MODULE: ../cdk8s_renderer/imports/firestartr.dev.ts
 // generated by cdk8s
@@ -327713,6 +327810,9 @@ class TFWorkspaceChart extends BaseWorkspaceChart {
         return {
             metadata: {
                 name: claim.providers.terraform.name,
+                ...(claim.annotations && Object.keys(claim.annotations).length > 0
+                    ? { annotations: claim.annotations }
+                    : {}),
             },
             spec: {
                 firestartr: {
@@ -328066,6 +328166,7 @@ class SecretsChart extends BaseSecretsChart {
 
 
 
+
 function normalizeProvidesApis(providesApis) {
     if (!providesApis)
         return [];
@@ -328136,7 +328237,10 @@ async function renderClaim(catalogScope, firestartrScope, claim, patches, previo
     let catalogEntity = undefined;
     let firestartrEntity = undefined;
     const extraCharts = [];
-    const chartId = `${claim.kind}-${claim.name}`.toLowerCase();
+    const isVariant = claim.annotations?.['firestartr.dev/variant-of'] !== undefined;
+    const chartId = isVariant
+        ? `${claim.kind}-${claim.name}.variant`.toLowerCase()
+        : `${claim.kind}-${claim.name}`.toLowerCase();
     let firestartrId = null;
     if (previousCR) {
         firestartrId = previousCR?.spec?.firestartr?.tfStateKey || null;
@@ -328316,6 +328420,21 @@ async function renderClaim(catalogScope, firestartrScope, claim, patches, previo
         ],
     };
 }
+function renameVariantCrFiles(outputDir, renderedMap) {
+    for (const cr of Object.values(renderedMap)) {
+        const crJson = cr.toJson ? cr.toJson() : cr;
+        if (crJson.metadata?.annotations?.['firestartr.dev/variant-of'] &&
+            crJson.kind &&
+            crJson.metadata?.name) {
+            const oldPath = external_path_.join(outputDir, `${crJson.kind}.${crJson.metadata.name}.yaml`);
+            const newPath = external_path_.join(outputDir, `${crJson.kind}.${crJson.metadata.name}.variant.yaml`);
+            if (external_fs_.existsSync(oldPath)) {
+                external_fs_.renameSync(oldPath, newPath);
+                logger.info(`Renamed variant CR file: ${oldPath} -> ${newPath}`);
+            }
+        }
+    }
+}
 
 ;// CONCATENATED MODULE: ../cdk8s_renderer/src/validations/crossReferences.ts
 
@@ -328820,6 +328939,9 @@ async function renderFromImports(rClaims, crs = {}, catalogOutputDir = '/tmp/.ca
     });
     const result = await renderClaims(catalogScope, firestartrScope, { renderClaims: rClaims, crs, renames: [] });
     firestartrScope.synth();
+    if (crOutputDir) {
+        renameVariantCrFiles(crOutputDir, result);
+    }
     return result;
 }
 async function solver(type, value, rClaims) {
@@ -328957,8 +329079,9 @@ async function runRenderer(globalsPath, initializersPath, claimsPath, crsPath, c
         // the system takes everything defined in the claims path
         claimRefsList = await resolveClaimEntries([claimsPath]);
     }
+    let renderedMap;
     try {
-        await renderer_render(catalogApp, firestartrApp, claimRefsList);
+        renderedMap = await renderer_render(catalogApp, firestartrApp, claimRefsList);
     }
     catch (error) {
         console.log(`Rendering the system: \n ${error}`);
@@ -328966,6 +329089,7 @@ async function runRenderer(globalsPath, initializersPath, claimsPath, crsPath, c
     }
     catalogApp.synth();
     firestartrApp.synth();
+    renameVariantCrFiles(outputCrDir, renderedMap);
 }
 
 ;// CONCATENATED MODULE: ../importer/src/decanter/config.ts
@@ -342691,7 +342815,6 @@ const cdk8s_rendererSubcommands = {
         { name: 'render', alias: 'r', type: Boolean },
         { name: 'compare', type: Boolean },
         { name: 'render-plan', type: Boolean },
-        { name: 'generate-claims-map', type: Boolean },
         /**
          * Specific parameters for render functionality
          */
@@ -342748,10 +342871,6 @@ const cdk8s_rendererSubcommands = {
         { name: 'lastStatePrLink', type: String },
         { name: 'lastClaimPrLink', type: String },
         { name: 'crLocation', type: String },
-        /**
-         * Specific parameters for claims-map generation
-         */
-        { name: 'claims-map-output', alias: 'm', type: String },
     ],
     run: async (options) => {
         if (options['render']) {
@@ -342764,9 +342883,6 @@ const cdk8s_rendererSubcommands = {
         else if (options['lastStatePrLink'] && options['lastClaimPrLink']) {
             await cdk8s_renderer.addLastStateAndLastClaimAnnotations(options['crLocation'], options['lastStatePrLink'], options['lastClaimPrLink']);
         }
-        else if (options['generate-claims-map']) {
-            await generateClaimsMap(options['claims'], options['claims-map-output'], options['sha']);
-        }
     },
 };
 
@@ -521408,7 +521524,7 @@ const crsStatusSubcommand = {
 };
 
 ;// CONCATENATED MODULE: ./package.json
-const package_namespaceObject = JSON.parse('{"i8":"2.8.0-snapshot-maps-claim-generator-3"}');
+const package_namespaceObject = JSON.parse('{"i8":"2.8.0-snapshot-4"}');
 ;// CONCATENATED MODULE: ../../package.json
 const package_namespaceObject_1 = {"i8":"2.7.0"};
 ;// CONCATENATED MODULE: ./src/subcommands/index.ts

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

@@ -13,7 +13,6 @@ import { runComparer } from './src/comparer';
 import { AllowedProviders, setDefaultBranch, setPath, setRepositoryUrl } from './src/config';
 import { render } from './src/renderer/renderer';
 export { AllowedProviders, configureProvider, setDefaultBranch, setRepositoryUrl, } from './src/config';
-export { generateClaimsMap } from './src/utils/claimUtils';
 import { isCatalogEntity } from './src/validations/references';
 import { normalizeModuleContent } from './src/normalizers';
 import { loadCRs } from './src/loader/loader';

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

@@ -1192,6 +1192,13 @@ declare const schemas: {
                         module: {
                             type: string;
                         };
+                        variants: {
+                            type: string;
+                            items: {
+                                $ref: string;
+                            };
+                            description: string;
+                        };
                         context: {
                             type: string;
                             properties: {
@@ -1226,6 +1233,102 @@ declare const schemas: {
                     $ref?: undefined;
                 })[];
             };
+            TerraformProviderVariantOverride: {
+                $id: string;
+                description: string;
+                type: string;
+                properties: {
+                    name: {
+                        type: string;
+                        description: string;
+                    };
+                    values: {
+                        type: string;
+                        additionalProperties: boolean;
+                        description: string;
+                    };
+                    context: {
+                        type: string;
+                        properties: {
+                            providers: {
+                                type: string;
+                                items: {
+                                    type: string;
+                                    properties: {
+                                        name: {
+                                            type: string;
+                                        };
+                                    };
+                                    additionalProperties: boolean;
+                                };
+                            };
+                            backend: {
+                                type: string;
+                                properties: {
+                                    name: {
+                                        type: string;
+                                    };
+                                };
+                                additionalProperties: boolean;
+                            };
+                        };
+                        additionalProperties: boolean;
+                        description: string;
+                    };
+                    files: {
+                        $ref: string;
+                    };
+                    policy: {
+                        type: string;
+                        enum: string[];
+                    };
+                    tfStateKey: {
+                        $ref: string;
+                    };
+                    sync: {
+                        type: string;
+                        properties: {
+                            enabled: {
+                                type: string;
+                            };
+                            period: {
+                                type: string;
+                                pattern: string;
+                            };
+                            schedule: {
+                                type: string;
+                            };
+                            schedule_timezone: {
+                                type: string;
+                            };
+                            policy: {
+                                type: string;
+                            };
+                        };
+                        additionalProperties: boolean;
+                    };
+                    valuesSchema: {
+                        type: string;
+                    };
+                };
+                additionalProperties: boolean;
+            };
+            TerraformProviderVariant: {
+                $id: string;
+                description: string;
+                type: string;
+                properties: {
+                    name: {
+                        type: string;
+                        description: string;
+                    };
+                    overrides: {
+                        $ref: string;
+                    };
+                };
+                additionalProperties: boolean;
+                required: string[];
+            };
         };
     }[] | {
         $schema: string;

package/build/packages/cdk8s_renderer/src/claims/tfworkspaces/index.d.ts

@@ -97,6 +97,13 @@ export declare const TerraformSchemas: {
                     module: {
                         type: string;
                     };
+                    variants: {
+                        type: string;
+                        items: {
+                            $ref: string;
+                        };
+                        description: string;
+                    };
                     context: {
                         type: string;
                         properties: {
@@ -131,5 +138,101 @@ export declare const TerraformSchemas: {
                 $ref?: undefined;
             })[];
         };
+        TerraformProviderVariantOverride: {
+            $id: string;
+            description: string;
+            type: string;
+            properties: {
+                name: {
+                    type: string;
+                    description: string;
+                };
+                values: {
+                    type: string;
+                    additionalProperties: boolean;
+                    description: string;
+                };
+                context: {
+                    type: string;
+                    properties: {
+                        providers: {
+                            type: string;
+                            items: {
+                                type: string;
+                                properties: {
+                                    name: {
+                                        type: string;
+                                    };
+                                };
+                                additionalProperties: boolean;
+                            };
+                        };
+                        backend: {
+                            type: string;
+                            properties: {
+                                name: {
+                                    type: string;
+                                };
+                            };
+                            additionalProperties: boolean;
+                        };
+                    };
+                    additionalProperties: boolean;
+                    description: string;
+                };
+                files: {
+                    $ref: string;
+                };
+                policy: {
+                    type: string;
+                    enum: string[];
+                };
+                tfStateKey: {
+                    $ref: string;
+                };
+                sync: {
+                    type: string;
+                    properties: {
+                        enabled: {
+                            type: string;
+                        };
+                        period: {
+                            type: string;
+                            pattern: string;
+                        };
+                        schedule: {
+                            type: string;
+                        };
+                        schedule_timezone: {
+                            type: string;
+                        };
+                        policy: {
+                            type: string;
+                        };
+                    };
+                    additionalProperties: boolean;
+                };
+                valuesSchema: {
+                    type: string;
+                };
+            };
+            additionalProperties: boolean;
+        };
+        TerraformProviderVariant: {
+            $id: string;
+            description: string;
+            type: string;
+            properties: {
+                name: {
+                    type: string;
+                    description: string;
+                };
+                overrides: {
+                    $ref: string;
+                };
+            };
+            additionalProperties: boolean;
+            required: string[];
+        };
     };
 }[];

package/build/packages/cdk8s_renderer/src/claims/tfworkspaces/terraform.schema.d.ts

@@ -97,6 +97,13 @@ declare const _default: {
                     module: {
                         type: string;
                     };
+                    variants: {
+                        type: string;
+                        items: {
+                            $ref: string;
+                        };
+                        description: string;
+                    };
                     context: {
                         type: string;
                         properties: {
@@ -131,6 +138,102 @@ declare const _default: {
                 $ref?: undefined;
             })[];
         };
+        TerraformProviderVariantOverride: {
+            $id: string;
+            description: string;
+            type: string;
+            properties: {
+                name: {
+                    type: string;
+                    description: string;
+                };
+                values: {
+                    type: string;
+                    additionalProperties: boolean;
+                    description: string;
+                };
+                context: {
+                    type: string;
+                    properties: {
+                        providers: {
+                            type: string;
+                            items: {
+                                type: string;
+                                properties: {
+                                    name: {
+                                        type: string;
+                                    };
+                                };
+                                additionalProperties: boolean;
+                            };
+                        };
+                        backend: {
+                            type: string;
+                            properties: {
+                                name: {
+                                    type: string;
+                                };
+                            };
+                            additionalProperties: boolean;
+                        };
+                    };
+                    additionalProperties: boolean;
+                    description: string;
+                };
+                files: {
+                    $ref: string;
+                };
+                policy: {
+                    type: string;
+                    enum: string[];
+                };
+                tfStateKey: {
+                    $ref: string;
+                };
+                sync: {
+                    type: string;
+                    properties: {
+                        enabled: {
+                            type: string;
+                        };
+                        period: {
+                            type: string;
+                            pattern: string;
+                        };
+                        schedule: {
+                            type: string;
+                        };
+                        schedule_timezone: {
+                            type: string;
+                        };
+                        policy: {
+                            type: string;
+                        };
+                    };
+                    additionalProperties: boolean;
+                };
+                valuesSchema: {
+                    type: string;
+                };
+            };
+            additionalProperties: boolean;
+        };
+        TerraformProviderVariant: {
+            $id: string;
+            description: string;
+            type: string;
+            properties: {
+                name: {
+                    type: string;
+                    description: string;
+                };
+                overrides: {
+                    $ref: string;
+                };
+            };
+            additionalProperties: boolean;
+            required: string[];
+        };
     };
 };
 export default _default;

package/build/packages/cdk8s_renderer/src/renderer/claims-render.d.ts

@@ -9,3 +9,4 @@ export declare function renderClaims(catalogScope: Construct, firestartrScope: C
     renames?: IRenameResult[];
 }): Promise<RenderedCrMap>;
 export declare function renderClaim(catalogScope: Construct, firestartrScope: Construct, claim: any, patches: ICustomResourcePatch[], previousCR?: any | null, claimPath?: string): Promise<IRenderClaimResult>;
+export declare function renameVariantCrFiles(outputDir: string, renderedMap: RenderedCrMap): void;

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

@@ -5,13 +5,3 @@ export declare function resolveClaimEntries(claimRefsList: string[]): AsyncGener
 export declare function resolveClaimFileRef(claimFile: string): Promise<string>;
 export declare function getClaimsEntryAbsolutePath(claimsDir: string, entryPath: string): string;
 export declare function sanitizeApiEntityName(name: string): string;
-export interface ClaimsMapEntry {
-    filePath: string;
-}
-export interface ClaimsMap {
-    headers: {
-        sha: string;
-    };
-    claims: Record<string, ClaimsMapEntry>;
-}
-export declare function generateClaimsMap(claimsPath: string, outputPath: string, sha?: string): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@firestartr/cli",
-  "version": "2.8.0-snapshot-maps-claim-generator-3",
+  "version": "2.8.0-snapshot-4",
   "private": false,
   "description": "Commandline tool",
   "main": "build/main.js",