@firestartr/cli 2.8.0-snapshot-5 → 2.8.0-snapshot-variant-cloning-test-1

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}`;
@@ -327723,6 +327861,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: {
@@ -328076,6 +328217,7 @@ class SecretsChart extends BaseSecretsChart {
 
 
 
+
 function normalizeProvidesApis(providesApis) {
     if (!providesApis)
         return [];
@@ -328146,7 +328288,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;
@@ -328326,6 +328471,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
 
@@ -328830,6 +328990,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) {
@@ -328889,6 +329052,7 @@ async function addLastStateAndLastClaimAnnotations(filePath, lastStatePRLink, la
 
 
 
+
 
 
 /* harmony default export */ const cdk8s_renderer = ({
@@ -328967,8 +329131,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}`);
@@ -328976,6 +329141,7 @@ async function runRenderer(globalsPath, initializersPath, claimsPath, crsPath, c
     }
     catalogApp.synth();
     firestartrApp.synth();
+    renameVariantCrFiles(outputCrDir, renderedMap);
 }
 
 ;// CONCATENATED MODULE: ../importer/src/decanter/config.ts
@@ -335193,6 +335359,20 @@ ${providersString}
 
 
 const TOFU_LOCK_TIMEOUT = '-lock-timeout=60s';
+const MAX_APPLY_ATTEMPTS = 3;
+const TRANSIENT_APPLY_RETRY_DELAY_MS = 1000;
+const GITHUB_INCONSISTENT_APPLY_SIGNATURE = [
+    'Provider produced inconsistent result after apply',
+    'root object was present, but now absent',
+];
+/**
+ * Matches the known GitHub provider eventual-consistency failure only.
+ * Keep both markers so unrelated apply errors fail immediately.
+ */
+function isGitHubInconsistentApplyError(error) {
+    const text = error.message;
+    return GITHUB_INCONSISTENT_APPLY_SIGNATURE.every((line) => text.includes(line));
+}
 // ========== NEW HELPERS for workspace reuse validation ==========
 // Returns true iff the rendered provider JSON would not be empty (so the providers file should exist)
 
@@ -335299,7 +335479,25 @@ async function plan(path, secrets, format, args = ['plan'], stream, ctl) {
 }
 async function apply(path, secrets, stream, ctl) {
     terraform_provisioner_src_logger.debug(`Running terraform apply in path ${path}`);
-    return await tfExec(path, ['apply', '-auto-approve', TOFU_LOCK_TIMEOUT], secrets, ['-input=false'], stream, ctl);
+    let lastError;
+    for (let attempt = 1; attempt <= MAX_APPLY_ATTEMPTS; attempt++) {
+        try {
+            return await tfExec(path, ['apply', '-auto-approve', TOFU_LOCK_TIMEOUT], secrets, ['-input=false'], stream, ctl);
+        }
+        catch (error) {
+            lastError = error;
+            if (isGitHubInconsistentApplyError(lastError)) {
+                if (attempt < MAX_APPLY_ATTEMPTS) {
+                    terraform_provisioner_src_logger.warn(`Transient GitHub provider apply error detected (attempt ${attempt} of ${MAX_APPLY_ATTEMPTS}); retrying after ${TRANSIENT_APPLY_RETRY_DELAY_MS}ms: ${GITHUB_INCONSISTENT_APPLY_SIGNATURE.join(', ')}`);
+                    await catalog_common/* default.generic.sleep */.Z.generic.sleep(TRANSIENT_APPLY_RETRY_DELAY_MS);
+                    continue;
+                }
+                terraform_provisioner_src_logger.warn(`Transient GitHub provider apply error persisted after ${MAX_APPLY_ATTEMPTS} attempts; giving up.`);
+            }
+            throw lastError;
+        }
+    }
+    throw lastError;
 }
 async function customCommand(path, secrets, args, stream) {
     terraform_provisioner_src_logger.debug(`Running terraform customCommand in path ${path} ${args.join(',')}`);
@@ -337206,12 +337404,13 @@ function extractErrorDetails(error) {
 
 
 
-
 const TF_PROJECTS_PATH = '/tmp/tfworkspaces';
 const TF_CACHES_PATH = '/tmp/tfcaches';
+function generateSessionId() {
+    return Math.random().toString(36).substring(2, 6).padEnd(4, '0');
+}
 function processOperation(item, op, handler) {
     try {
-        clearLocalTfProject(item);
         const policy = getPolicy(item, 'firestartr.dev/policy');
         const syncPolicy = getPolicy(item, 'firestartr.dev/sync-policy');
         if (!policy || policy === 'observe' || policy === 'observe-only') {
@@ -337252,6 +337451,9 @@ async function* process_operation_observe(item, op, handler) {
 }
 async function* doPlanJSONFormat(item, op, handler, setResult = function (_r) { }) {
     let error = false;
+    let deps;
+    let terraformExecutionStarted = false;
+    const sessionId = generateSessionId();
     try {
         yield {
             item,
@@ -337274,9 +337476,9 @@ async function* doPlanJSONFormat(item, op, handler, setResult = function (_r) {
             status: 'True',
             message: 'Planning process started',
         };
-        const deps = await handler.resolveReferences();
+        deps = await handler.resolveReferences();
         operator_src_logger.info(`The Terraform processor is planning to assess dependencies for item '${item.kind}/${item.metadata.name}' with dependencies: '${deps}'.`);
-        const context = buildProvisionerContext(item, deps);
+        const context = buildProvisionerContext(item, deps, sessionId);
         let planType = 'plan-json';
         if ('deletionTimestamp' in item.metadata) {
             planType = 'plan-destroy-json';
@@ -337284,7 +337486,8 @@ async function* doPlanJSONFormat(item, op, handler, setResult = function (_r) {
         if (item.metadata.annotations['firestartr.dev/last-state-pr'] || false) {
             await addPlanStatusCheck(item.metadata.annotations['firestartr.dev/last-state-pr'], 'Terraform plan in progress...');
         }
-        const tfPlan = await runTerraformProvisioner(context, planType, null, {
+        terraformExecutionStarted = true;
+        const tfPlan = await runTerraformProvisioner(context, planType, null, undefined, {
             tfCacheDir: external_path_.join(TF_CACHES_PATH, `slot_${handler.getSlotInfo().slotId}`),
             hardTimeout: handler.recommendedTimeout(),
             processKilled: (killed) => {
@@ -337362,6 +337565,22 @@ async function* doPlanJSONFormat(item, op, handler, setResult = function (_r) {
         }
     }
     finally {
+        // Tear up the session workspace only if the project was created
+        // (Terraform execution started), regardless of its success or failure.
+        if (terraformExecutionStarted) {
+            try {
+                const tearContext = buildProvisionerContext(item, deps, sessionId);
+                await runTerraformProvisioner(tearContext, 'tear-up-project');
+            }
+            catch (tearErr) {
+                if (error) {
+                    operator_src_logger.warn(`Workspace cleanup failed after plan error: ${tearErr}`);
+                }
+                else {
+                    operator_src_logger.warn(`Workspace cleanup failed: ${tearErr}`);
+                }
+            }
+        }
         if (error) {
             if (op === OperationType.SYNC) {
                 // if there is an error on a sync we never put the state on error
@@ -337526,6 +337745,9 @@ async function* process_operation_sync(item, op, handler, syncPolicy, generalPol
 }
 async function* process_operation_markedToDeletion(item, op, handler) {
     let error = false;
+    let deps;
+    let terraformExecutionStarted = false;
+    const sessionId = generateSessionId();
     try {
         const type = 'DELETING';
         yield {
@@ -337580,9 +337802,10 @@ async function* process_operation_markedToDeletion(item, op, handler) {
         if (item.metadata.annotations['firestartr.dev/last-state-pr'] || false) {
             await addDestroyCommitStatus(item, 'pending', 'Performing destroy operation...', `Terraform Destroy ${item.metadata.name}`);
         }
-        const deps = await handler.resolveReferences();
-        const context = buildProvisionerContext(item, deps);
-        const destroyOutput = await runTerraformProvisioner(context, 'destroy', null, {
+        deps = await handler.resolveReferences();
+        const context = buildProvisionerContext(item, deps, sessionId);
+        terraformExecutionStarted = true;
+        const destroyOutput = await runTerraformProvisioner(context, 'destroy', null, undefined, {
             tfCacheDir: external_path_.join(TF_CACHES_PATH, `slot_${handler.getSlotInfo().slotId}`),
             hardTimeout: handler.recommendedTimeout(),
             processKilled: (killed) => {
@@ -337627,6 +337850,22 @@ async function* process_operation_markedToDeletion(item, op, handler) {
         void handler.error();
     }
     finally {
+        // Tear up the session workspace only if the project was created
+        // (Terraform execution started), regardless of its success or failure.
+        if (terraformExecutionStarted) {
+            try {
+                const tearContext = buildProvisionerContext(item, deps, sessionId);
+                await runTerraformProvisioner(tearContext, 'tear-up-project');
+            }
+            catch (tearErr) {
+                if (error) {
+                    operator_src_logger.warn(`Workspace cleanup failed after destroy error: ${tearErr}`);
+                }
+                else {
+                    operator_src_logger.warn(`Workspace cleanup failed: ${tearErr}`);
+                }
+            }
+        }
         if (error) {
             yield {
                 item,
@@ -337656,6 +337895,9 @@ async function* process_operation_nothing(item, op, handler) {
 async function* doApply(item, op, handler) {
     const checkRunCtl = await TFCheckRun('apply', item);
     let error = false;
+    let deps;
+    let terraformExecutionStarted = false;
+    const sessionId = generateSessionId();
     try {
         yield {
             item,
@@ -337701,10 +337943,11 @@ async function* doApply(item, op, handler) {
             status: 'True',
             message: 'Provisioning process started',
         };
-        const deps = await handler.resolveReferences();
+        deps = await handler.resolveReferences();
         operator_src_logger.info(`The Terraform processor is applying and assessing dependencies for item '${item.kind}/${item.metadata.name}' with dependencies: '${deps}'.`);
-        const context = buildProvisionerContext(item, deps);
-        const applyOutput = await runTerraformProvisioner(context, 'apply', checkRunCtl, {
+        const context = buildProvisionerContext(item, deps, sessionId);
+        terraformExecutionStarted = true;
+        const applyOutput = await runTerraformProvisioner(context, 'apply', checkRunCtl, undefined, {
             tfCacheDir: external_path_.join(TF_CACHES_PATH, `slot_${handler.getSlotInfo().slotId}`),
             hardTimeout: handler.recommendedTimeout(),
             processKilled: (killed) => {
@@ -337716,6 +337959,7 @@ async function* doApply(item, op, handler) {
                 }
             },
         });
+        context.reuseExistingProject = true;
         const terraformOutputJson = await runTerraformProvisioner(context, 'output');
         if (!terraformOutputJson) {
             throw new Error(`Terraform output is empty for ${item.kind}/${item.metadata.name}`);
@@ -337762,6 +338006,22 @@ async function* doApply(item, op, handler) {
         }
     }
     finally {
+        // Tear up the session workspace only if the project was created
+        // (Terraform execution started), regardless of its success or failure.
+        if (terraformExecutionStarted) {
+            try {
+                const tearContext = buildProvisionerContext(item, deps, sessionId);
+                await runTerraformProvisioner(tearContext, 'tear-up-project');
+            }
+            catch (tearErr) {
+                if (error) {
+                    operator_src_logger.warn(`Workspace cleanup failed after provisioning error: ${tearErr}`);
+                }
+                else {
+                    operator_src_logger.warn(`Workspace cleanup failed: ${tearErr}`);
+                }
+            }
+        }
         if (error) {
             yield {
                 item,
@@ -337847,7 +338107,7 @@ async function* errorPolicyNotAllowsOp(item, op, handler, msg) {
  * @param item  - CR to be applied
  * @param deps - Dependencies
  */
-function buildProvisionerContext(item, deps) {
+function buildProvisionerContext(item, deps, sessionId) {
     const context = {};
     context['type'] = item.spec.source;
     context['inline'] = item.spec.module;
@@ -337862,7 +338122,21 @@ function buildProvisionerContext(item, deps) {
     context['backend'] = adaptBackend(item, deps);
     context['tfStateKey'] = item.spec.firestartr.tfStateKey;
     context['references'] = resolveReferences(item, deps);
-    context['projectPath'] = external_path_.join(TF_PROJECTS_PATH, item.spec.firestartr.tfStateKey);
+    const tfStateKey = item?.spec?.firestartr?.tfStateKey;
+    if (typeof tfStateKey !== 'string' || tfStateKey.trim() === '') {
+        throw new Error(`Invalid terraform state key: ${tfStateKey}`);
+    }
+    if (sessionId) {
+        context['projectPath'] = external_path_.join(TF_PROJECTS_PATH, `${item.kind.toLowerCase()}-${item.metadata.name}-${sessionId}`);
+    }
+    else {
+        const basePath = external_path_.resolve(TF_PROJECTS_PATH);
+        const resolvedPath = external_path_.resolve(basePath, tfStateKey);
+        if (!resolvedPath.startsWith(basePath + external_path_.sep)) {
+            throw new Error(`Invalid terraform state key: ${tfStateKey}`);
+        }
+        context['projectPath'] = resolvedPath;
+    }
     return context;
 }
 function getRefContextFromCr(cr, deps) {
@@ -338001,73 +338275,6 @@ function resolveReferences(item, deps) {
         throw new Error(`resolving references: ${e}`);
     }
 }
-function getValidatedTfProjectPath(item) {
-    const tfStateKey = item?.spec?.firestartr?.tfStateKey;
-    if (typeof tfStateKey !== 'string' || tfStateKey.trim() === '') {
-        throw new Error('Invalid terraform state key');
-    }
-    if (external_path_.isAbsolute(tfStateKey)) {
-        throw new Error(`Invalid terraform state key: ${tfStateKey}`);
-    }
-    const basePath = external_path_.resolve(TF_PROJECTS_PATH);
-    const tfProjectPath = external_path_.resolve(basePath, tfStateKey);
-    const relativePath = external_path_.relative(basePath, tfProjectPath);
-    if (relativePath === '' ||
-        relativePath === '.' ||
-        relativePath.startsWith('..') ||
-        external_path_.isAbsolute(relativePath)) {
-        throw new Error(`Invalid terraform state key: ${tfStateKey}`);
-    }
-    return tfProjectPath;
-}
-function getValidatedTfProjectsRealPath() {
-    const basePath = external_path_.resolve(TF_PROJECTS_PATH);
-    external_fs_.mkdirSync(basePath, { recursive: true });
-    const realBasePath = external_fs_.realpathSync(basePath);
-    if (!external_fs_.statSync(realBasePath).isDirectory()) {
-        throw new Error(`Invalid terraform projects path: ${TF_PROJECTS_PATH}`);
-    }
-    return realBasePath;
-}
-function assertPathWithinBase(candidatePath, realBasePath) {
-    const relativePath = external_path_.relative(realBasePath, candidatePath);
-    if (relativePath === '' ||
-        relativePath === '.' ||
-        relativePath.startsWith('..') ||
-        external_path_.isAbsolute(relativePath)) {
-        throw new Error(`Invalid terraform project path: ${candidatePath}`);
-    }
-}
-function assertNoSymlinksInExistingPathComponents(realBasePath, candidatePath) {
-    const relativePath = external_path_.relative(realBasePath, candidatePath);
-    const pathSegments = relativePath
-        .split(external_path_.sep)
-        .filter((segment) => segment !== '');
-    let currentPath = realBasePath;
-    for (const pathSegment of pathSegments) {
-        currentPath = external_path_.join(currentPath, pathSegment);
-        if (!external_fs_.existsSync(currentPath)) {
-            return;
-        }
-        if (external_fs_.lstatSync(currentPath).isSymbolicLink()) {
-            throw new Error(`Invalid terraform project path: symlink component detected at ${currentPath}`);
-        }
-    }
-}
-function clearLocalTfProject(item) {
-    const tfProjectPath = getValidatedTfProjectPath(item);
-    const realBasePath = getValidatedTfProjectsRealPath();
-    assertNoSymlinksInExistingPathComponents(realBasePath, tfProjectPath);
-    let deletePath = tfProjectPath;
-    if (external_fs_.existsSync(tfProjectPath)) {
-        deletePath = external_fs_.realpathSync(tfProjectPath);
-        assertPathWithinBase(deletePath, realBasePath);
-    }
-    external_fs_.rmSync(deletePath, {
-        recursive: true,
-        force: true,
-    });
-}
 function getErrorOutputMessage(cr, key, ref) {
     if (cr.spec.source === 'Remote') {
         return `
@@ -521423,9 +521630,9 @@ const crsStatusSubcommand = {
 };
 
 ;// CONCATENATED MODULE: ./package.json
-const package_namespaceObject = JSON.parse('{"i8":"2.8.0-snapshot-5"}');
+const package_namespaceObject = JSON.parse('{"i8":"2.8.0-snapshot-variant-cloning-test-1"}');
 ;// CONCATENATED MODULE: ../../package.json
-const package_namespaceObject_1 = {"i8":"2.7.0"};
+const package_namespaceObject_1 = {"i8":"2.7.1"};
 ;// CONCATENATED MODULE: ./src/subcommands/index.ts
 
 

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/operator/src/tfworkspaces/process-operation.d.ts

@@ -1,4 +1,5 @@
 import { OperationType } from '../informer';
+export declare function generateSessionId(): string;
 export declare function processOperation(item: any, op: OperationType, handler: any): AsyncGenerator<{
     item: any;
     reason: OperationType;
@@ -6,9 +7,22 @@ export declare function processOperation(item: any, op: OperationType, handler:
     status: string;
     message: any;
 }, void, unknown>;
+/**
+ *
+ * @param {any} item - CR to be applied
+ * @param op - Operation type
+ * @param handler -
+ */
+export declare function doApply(item: any, op: OperationType, handler: any): AsyncGenerator<{
+    item: any;
+    reason: OperationType;
+    type: string;
+    status: string;
+    message: string;
+}, void, unknown>;
 /**
  * @description Adapts the CR to the format expected by the terraform provisioner
  * @param item  - CR to be applied
  * @param deps - Dependencies
  */
-export declare function buildProvisionerContext(item: any, deps: any): any;
+export declare function buildProvisionerContext(item: any, deps: any, sessionId?: string): any;

package/package.json

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