@firestartr/cli 1.54.0-snapshot-14 → 1.55.0-snapshot-0

package/build/index.js

@@ -151708,7 +151708,7 @@ module.exports = exports.default;
 
 /***/ }),
 
-/***/ 89323:
+/***/ 60762:
 /***/ ((module, exports) => {
 
 
@@ -151775,7 +151775,7 @@ var _isArrayLike = __nccwpck_require__(10860);
 
 var _isArrayLike2 = _interopRequireDefault(_isArrayLike);
 
-var _getIterator = __nccwpck_require__(89323);
+var _getIterator = __nccwpck_require__(60762);
 
 var _getIterator2 = _interopRequireDefault(_getIterator);
 
@@ -358145,10 +358145,26 @@ const external_node_child_process_namespaceObject = __WEBPACK_EXTERNAL_createReq
                             type: 'string',
                             description: 'The github organization name',
                         },
+                        name: {
+                            type: 'string',
+                            description: 'The github repo name',
+                        },
+                        orgPermissions: {
+                            type: 'string',
+                            description: 'The level of org Permission',
+                        },
+                        archiveOnDestroy: {
+                            type: 'boolean',
+                            description: 'whether this repo should be archived when the claim is deleted',
+                        },
                         visibility: {
                             type: 'string',
                             enum: ['private', 'public', 'internal'],
                         },
+                        description: {
+                            type: 'string',
+                            description: 'The purpose of this repo',
+                        },
                         features: {
                             type: 'array',
                             items: {
@@ -359648,6 +359664,13 @@ var ajv_default = /*#__PURE__*/__nccwpck_require__.n(dist_ajv);
                         },
                     },
                 },
+                filesTemplates: {
+                    type: 'array',
+                    description: 'a list of references to a different file where files key is filled by an expanded template',
+                    items: {
+                        type: 'string',
+                    },
+                },
             },
             required: ['args', 'feature_name', 'files', 'patches'],
             title: 'root',
@@ -359667,7 +359690,7 @@ var ajv_default = /*#__PURE__*/__nccwpck_require__.n(dist_ajv);
             additionalProperties: false,
             properties: {
                 $lit: {
-                    type: 'string',
+                    type: ['string', 'boolean'],
                 },
                 $ref: {
                     type: 'array',
@@ -359679,7 +359702,7 @@ var ajv_default = /*#__PURE__*/__nccwpck_require__.n(dist_ajv);
                     type: 'string',
                 },
                 $default: {
-                    type: ['string', 'array'],
+                    type: ['string', 'array', 'boolean'],
                 },
             },
         },
@@ -359759,7 +359782,9 @@ function __validateFeatureConfig(featurePath) {
     }
 }
 function __validateFeatureConfigData(configData) {
-    const ajv = new (ajv_default())();
+    const ajv = new (ajv_default())({
+        allowUnionTypes: true,
+    });
     const validate = ajv.compile(src_schema);
     const valid = validate(configData);
     if (!valid) {
@@ -360593,10 +360618,14 @@ function addTraceabilityStamp(context, content) {
 
 
 
+
 function render(featurePath, featureRenderPath, entity, firestartrConfig = {}, featureArgs = {}) {
     const configData = validate_validate(featurePath);
     const context = buildContext(entity, configData.args, firestartrConfig, featureArgs);
     context.config = JSON.parse(renderContent(JSON.stringify(configData), context));
+    if ('filesTemplates' in context.config) {
+        expandFiles(featurePath, configData, context);
+    }
     const output = { files: [] };
     context.config.files.forEach((file) => {
         const { src, dest } = file;
@@ -360654,6 +360683,22 @@ function buildContext(entity, args, firestartrConfig, featureArgs) {
     context.traceability = featureArgs['traceability'] || {};
     return context;
 }
+function expandFiles(featurePath, configData, context) {
+    let files = [];
+    for (const tpl of configData.filesTemplates) {
+        const addToFiles = expandFilesTemplate(featurePath, tpl, context);
+        files = files.concat(addToFiles).flat(Infinity);
+    }
+    context.config.files = context.config.files.concat(files).flat(Infinity);
+}
+function expandFilesTemplate(featurePath, tplPath, context) {
+    const template = external_fs_default().readFileSync(external_path_default().join(featurePath, tplPath)).toString();
+    const renderedTemplate = renderContent(template, context);
+    const data = catalog_common.io.fromYaml(renderedTemplate) || { files: [] };
+    if (!data.files)
+        data.files = [];
+    return data.files.filter((file) => file);
+}
 function renderContent(template, ctx) {
     return mustache_mustache.render(template, ctx, {}, ['{{|', '|}}']);
 }
@@ -360723,7 +360768,7 @@ function loadAndValidateRenderTests(featurePath) {
         throw new Error(`render_tests.yaml is required but not found at ${file}`);
     }
     const raw = loadYaml(file);
-    const ajv = new (ajv_default())({ allErrors: true, strict: true });
+    const ajv = new (ajv_default())({ allErrors: true, strict: true, allowUnionTypes: true });
     const validate = ajv.compile(renderTestsSchema);
     const ok = validate(raw);
     if (!ok) {
@@ -367240,6 +367285,9 @@ const kindPluralMap = {
     providerconfigs: 'FirestartrProviderConfig',
     externalsecrets: 'ExternalSecret',
     secrets: 'Secret',
+    fsdummiesa: 'FirestartrDummyA',
+    fsdummiesb: 'FirestartrDummyB',
+    fsdummiesc: 'FirestartrDummyC',
 };
 function getKindFromPlural(plural) {
     return kindPluralMap[plural];
@@ -368535,6 +368583,9 @@ var WorkStatus;
 
 
 const kindsWithFinalizer = [
+    'FirestartrDummyA',
+    'FirestartrDummyB',
+    'FirestartrDummyC',
     'FirestartrTerraformWorkspace',
     'FirestartrGithubGroup',
     'FirestartrGithubMembership',
@@ -368543,6 +368594,11 @@ const kindsWithFinalizer = [
     'FirestartrGithubOrgWebhook',
     'FirestartrGithubRepositorySecretsSection',
 ];
+const kindsWithDependants = [
+    'FirestartrDummyA',
+    'FirestartrDummyB',
+    'FirestartrGithubRepository',
+];
 /**
  * Observe whenever a new item is added, modified or deleted in a given kind
  * @param {string} pluralKind - Kind to observe
@@ -368653,6 +368709,28 @@ function enqueue(pluralKind, workItem, queue, compute, syncCtl, retryCtl) {
         itemPath: () => informer_itemPath(pluralKind, workItem.item),
         error: () => retryCtl.errorReconciling(informer_itemPath(pluralKind, workItem.item)),
         success: () => retryCtl.successReconciling(informer_itemPath(pluralKind, workItem.item)),
+        needsBlocking: (item) => {
+            if (kindsWithDependants.indexOf(item.kind) === -1) {
+                return false;
+            }
+            if (item.metadata.finalizers &&
+                item.metadata.finalizers.indexOf('foregroundDeletion') !== -1) {
+                // it will block for five seconds
+                workItem.isBlocked = true;
+                const tTimeout = setTimeout(() => {
+                    workItem.isBlocked = false;
+                }, 1000 * 5);
+                workItem.fUnblock = () => {
+                    clearTimeout(tTimeout);
+                    workItem.isBlocked = false;
+                };
+                return true;
+            }
+            else {
+                workItem.isBlocked = false;
+                return false;
+            }
+        },
     };
     workItem.process = async function* (item, operation, handler) {
         const needsUpdateSyncConditions = operation === OperationType.RENAMED ||
@@ -368681,6 +368759,7 @@ function enqueue(pluralKind, workItem, queue, compute, syncCtl, retryCtl) {
             operator_src_logger.debug(`The informer received an item with an operation type of '${operation}', which is not a specific operation.`);
         }
     };
+    workItem.isBlocked = false;
     queue(workItem);
 }
 function informer_itemPath(kind, item) {
@@ -368904,6 +368983,327 @@ function dummy_fWait(ms) {
     });
 }
 
+;// CONCATENATED MODULE: ../operator/src/ownership.ts
+
+
+
+async function getOwnerReferences(item) {
+    return item.metadata?.ownerReferences || [];
+}
+async function setOwnerReference(itemPath, namespace, ownerKind, ownerName, blockOwnerDeletion = true) {
+    let item = null;
+    try {
+        // we need to search for the owner's uuid
+        const owner = await getItemByItemPath(`${namespace}/${ownerKind}/${ownerName}`);
+        const ownerReference = {
+            apiVersion: owner.apiVersion,
+            kind: owner.kind,
+            name: ownerName,
+            controller: true,
+            blockOwnerDeletion,
+            uid: owner.metadata.uid,
+        };
+        // we get the item (to prevent race conditions)
+        item = await getItemByItemPath(itemPath);
+        const ownerReferences = item.metadata.ownerReferences ?? [];
+        const existingRefIndex = ownerReferences.findIndex((ref) => ref.uid === ownerReference.uid);
+        if (existingRefIndex === -1) {
+            // Reference does not exist, add it
+            ownerReferences.push(ownerReference);
+        }
+        else {
+            ownerReferences[existingRefIndex] = ownerReference;
+        }
+        await writeOwnerReferences(definitions_getPluralFromKind(item.kind), item.metadata.namespace, item, ownerReferences);
+    }
+    catch (err) {
+        operator_src_logger.error(err);
+        throw `Setting OwnerReferences to ${item.kind}/${item.metadata.name}: ${err}`;
+    }
+}
+async function writeOwnerReferences(kind, namespace, item, ownerReferences) {
+    operator_src_logger.debug(`The ctl is setting the ownerReferences for '${kind}/${item.metadata.name}' in namespace '${namespace}'.`);
+    const { kc, opts } = await ctl_getConnection();
+    const url = `${kc.getCurrentCluster().server}/apis/firestartr.dev/v1/namespaces/${namespace}/${kind}/${item.metadata.name}`;
+    opts.headers['Content-Type'] = 'application/json-patch+json';
+    opts.headers['Accept'] = '*';
+    const patch = {
+        op: 'replace',
+        path: '/metadata/ownerReferences',
+        value: ownerReferences,
+    };
+    const r = await fetch(url, {
+        method: 'PATCH',
+        headers: opts.headers,
+        body: JSON.stringify([patch]),
+    });
+    if (!r.ok) {
+        throw `Error on setOwnerReferences: ${namespace}/${kind}/${item['metadata']['name']}: ${r.statusText}`;
+    }
+    return r.json();
+}
+
+;// CONCATENATED MODULE: ../operator/fdummies/index.ts
+
+
+
+
+
+function processFirestartrDummies(item, op, handler) {
+    operator_src_logger.info(`FirestartrDummies Processor: ${op}`);
+    try {
+        switch (op) {
+            case OperationType.UPDATED:
+                return updated(item, op, handler);
+            case OperationType.CREATED:
+                return created(item, op, handler);
+            case OperationType.RENAMED:
+                return renamed();
+            case OperationType.MARKED_TO_DELETION:
+                return marked(item, op, handler);
+            case OperationType.RETRY:
+                return fdummies_retry();
+            case OperationType.NOTHING:
+                return nothing();
+            default:
+                throw new Error(`Operation ${op} not supported`);
+        }
+    }
+    catch (e) {
+        operator_src_logger.error(`The Dummy processor encountered an error during operation '${op}': '${e}'.`);
+        throw e;
+    }
+}
+async function* updated(item, op, handler) {
+    operator_src_logger.info(`Updated op in ${item.kind}/${item.metadata.name}`);
+    for await (const transition of doRun(item, op, handler)) {
+        yield transition;
+    }
+    await handleOwnerReferences(item, handler);
+}
+async function* created(item, op, handler) {
+    for await (const transition of doRun(item, op, handler)) {
+        yield transition;
+    }
+    await handleOwnerReferences(item, handler);
+}
+async function handleOwnerReferences(item, handler) {
+    if ('needs' in item.spec) {
+        const needs = item.spec.needs;
+        await setOwnerReference(handler.itemPath(), item.metadata.namespace, definitions_getPluralFromKind(needs.kind), needs.name);
+    }
+}
+async function renamed() {
+    throw new Error('Renamed operation not prepared');
+}
+async function* sync(item, op, handler) {
+    for await (const transition of doRun(item, op, handler)) {
+        yield transition;
+    }
+}
+async function* marked(item, op, handler) {
+    for await (const transition of markedToDeletion(item, op, handler)) {
+        yield transition;
+    }
+}
+async function* fdummies_retry() { }
+async function* nothing() { }
+async function* markedToDeletion(item, op, handler) {
+    let error = false;
+    try {
+        const type = 'DELETING';
+        yield {
+            item,
+            reason: op,
+            type: 'PROVISIONING',
+            status: 'False',
+            message: 'markedToDeletion',
+        };
+        yield {
+            item,
+            reason: op,
+            type: 'DELETED',
+            status: 'False',
+            message: 'markedToDeletion',
+        };
+        yield {
+            item,
+            reason: op,
+            type: 'PLANNING',
+            status: 'False',
+            message: 'markedToDeletion',
+        };
+        yield {
+            item,
+            reason: op,
+            type: 'OUT_OF_SYNC',
+            status: 'False',
+            message: 'markedToDeletion',
+        };
+        yield {
+            item,
+            reason: op,
+            type: 'ERROR',
+            status: 'False',
+            message: 'doApply',
+        };
+        yield {
+            item,
+            reason: op,
+            type: 'PROVISIONED',
+            status: 'False',
+            message: 'Synth CDKTF',
+        };
+        yield {
+            item,
+            reason: op,
+            type,
+            status: 'True',
+            message: 'Destroying process started',
+        };
+        await handler.resolveReferences();
+        await processDummy(item, op);
+        yield {
+            item,
+            reason: op,
+            type,
+            status: 'False',
+            message: 'Destroying process finished',
+        };
+        yield {
+            item,
+            reason: op,
+            type: 'DELETED',
+            status: 'True',
+            message: 'destroyed',
+        };
+        await handler.finalize(handler.pluralKind, item.metadata.namespace, item, 'firestartr.dev/finalizer');
+        void handler.success();
+    }
+    catch (e) {
+        error = true;
+        void handler.error();
+    }
+    finally {
+        if (error) {
+            yield {
+                item,
+                reason: op,
+                type: 'ERROR',
+                status: 'True',
+                message: DESTROY_DEFAULT_ERROR_MESSAGE,
+            };
+        }
+    }
+}
+async function* doRun(item, op, handler) {
+    let error = false;
+    try {
+        yield {
+            item,
+            reason: op,
+            type: 'DELETED',
+            status: 'False',
+            message: 'markedToDeletion',
+        };
+        yield {
+            item,
+            reason: op,
+            type: 'ERROR',
+            status: 'False',
+            message: 'doRun',
+        };
+        yield {
+            item,
+            reason: op,
+            type: 'PROVISIONED',
+            status: 'False',
+            message: 'Run processor',
+        };
+        //let output = '';
+        const type = 'PROVISIONING';
+        yield {
+            item,
+            reason: op,
+            type,
+            status: 'True',
+            message: 'Provisioning process started',
+        };
+        const deps = await handler.resolveReferences();
+        operator_src_logger.info(`The dummy processor is applying and assessing dependencies for item '${item.kind}/${item.metadata.name}' with dependencies: '${deps}'.`);
+        await processDummy(item, op);
+        yield {
+            item,
+            reason: op,
+            type,
+            status: 'False',
+            message: 'Dummy Processor apply finished',
+        };
+        yield {
+            item,
+            reason: op,
+            type: 'PROVISIONED',
+            status: 'True',
+            message: 'Dummy Processor apply finished',
+        };
+        yield {
+            item,
+            reason: op,
+            type: 'ERROR',
+            status: 'False',
+            message: 'doApply',
+        };
+        await handler.success();
+    }
+    catch (e) {
+        error = true;
+        console.error(e);
+        operator_src_logger.error(`The Dummy processor encountered an error during operation '${op}' for item '${item.kind}/${item.metadata.name}': '${e}'.`);
+        await handler.error();
+    }
+    finally {
+        if (error) {
+            yield {
+                item,
+                reason: op,
+                type: 'ERROR',
+                status: 'True',
+                message: APPLY_DEFAULT_ERROR_MESSAGE,
+            };
+            yield {
+                item,
+                reason: op,
+                type: 'PROVISIONED',
+                status: 'False',
+                message: APPLY_DEFAULT_ERROR_MESSAGE,
+            };
+            yield {
+                item,
+                reason: op,
+                type: 'PROVISIONING',
+                status: 'False',
+                message: APPLY_DEFAULT_ERROR_MESSAGE,
+            };
+        }
+    }
+}
+async function processDummy(item, op) {
+    const s = op === OperationType.MARKED_TO_DELETION
+        ? item.spec?.computation?.numberOfSecondsToDestroy
+        : item.spec?.computation?.numberOfSeconds;
+    operator_src_logger.info(`Processing dummy (op = ${op}) ${item.kind}/${item.metadata.name}: computing for ${s} seconds`);
+    if (!s)
+        throw new Error('Unprocessable dummy: no seconds section');
+    await fdummies_fWait(s * 1000);
+}
+function fdummies_fWait(ms) {
+    return new Promise((resolve) => {
+        setTimeout(() => {
+            resolve();
+        }, ms);
+    });
+}
+
 ;// CONCATENATED MODULE: ../operator/src/processItem.debug.ts
 
 
@@ -368926,7 +369326,8 @@ async function writeDownQueueStatus(queue) {
     let output = '';
     for (const workItem of queue) {
         const item = workItem.item;
-        output += `${item.kind}/${item.metadata.name} - ${workItem.workStatus} - ${workItem.operation} - (upsert ${formatElapsedTimeWithDate(workItem.upsertTime)})\n`;
+        const blockedText = workItem.isBlocked ? '[BLOCKED]' : '';
+        output += `${item.kind}/${item.metadata.name} - ${workItem.workStatus} - ${workItem.operation} ${blockedText} - (upsert ${formatElapsedTimeWithDate(workItem.upsertTime)})\n`;
     }
     return new Promise((ok, ko) => {
         external_fs_.writeFile('/tmp/queue', output, (err) => {
@@ -369119,7 +369520,9 @@ async function processItem(workItem) {
  * @returns {void}
  */
 async function processItem_loop() {
-    const nextWorkItem = () => sortQueue(queue).find((w) => w.workStatus === WorkStatus.PENDING);
+    const nextWorkItem = () => sortQueue(queue)
+        .filter((w) => !w.isBlocked)
+        .find((w) => w.workStatus === WorkStatus.PENDING);
     loopWorkItemDebug(queue);
     while (1) {
         const w = nextWorkItem();
@@ -369183,6 +369586,14 @@ async function runWorkItem(workItem) {
         return;
     try {
         const item = await workItem.getItem();
+        // we check if the workItem needs blocking
+        // if it does need it we return because we cannot
+        // process this item
+        if ('needsBlocking' in workItem.handler &&
+            workItem.handler.needsBlocking(item)) {
+            operator_src_logger.debug(`Item ${item.kind}/${item.metadata.namespace} needs blocking`);
+            return;
+        }
         workItem.workStatus = WorkStatus.PROCESSING;
         for await (const condition of workItem.process(item, workItem.operation, workItem.handler)) {
             if (workItem.handler === undefined)
@@ -369469,7 +369880,7 @@ function provisionRepository(scope, fsGithubRepository) {
         allowAutoMerge: fsGithubRepository.spec.repo.allowAutoMerge,
         deleteBranchOnMerge: fsGithubRepository.spec.repo.deleteBranchOnMerge,
         autoInit: fsGithubRepository.spec.repo.autoInit,
-        archiveOnDestroy: true,
+        archiveOnDestroy: fsGithubRepository.spec.repo.archiveOnDestroy,
         allowUpdateBranch: fsGithubRepository.spec.repo.allowUpdateBranch,
         hasIssues: fsGithubRepository.spec.repo.hasIssues,
         visibility: fsGithubRepository.spec.repo.visibility,
@@ -371392,6 +371803,33 @@ function helperCreateCheckRunName(cmd, item) {
     return `${item.kind} - ${cmd}`;
 }
 
+;// CONCATENATED MODULE: ../operator/src/cdktf/ownership.ts
+
+
+
+const kindsWithFirestartrGithubRepositoryDependence = [
+    'FirestartrGithubRepositorySecretsSection',
+    'FirestartrGithubRepositoryFeature',
+];
+async function manageOwnershipReferences(item, handler, op) {
+    if (kindsWithFirestartrGithubRepositoryDependence.indexOf(item.kind) !== -1) {
+        await manageOwnershipReferencesForRepo(item, handler, op);
+    }
+}
+async function manageOwnershipReferencesForRepo(item, handler, op) {
+    try {
+        const repositoryTarget = item.spec?.repositoryTarget?.ref;
+        if (!repositoryTarget) {
+            throw `Item ${item.kind}/${item.metadata.namespace} is not correct: it does not have a repositoryTarget`;
+        }
+        await setOwnerReference(handler.itemPath(), item.metadata.namespace, definitions_getPluralFromKind(repositoryTarget.kind), repositoryTarget.name);
+    }
+    catch (err) {
+        operator_src_logger.error(`Handling ownership for ${item.kind}/${item.metadata.name}: ${err}`);
+        throw new Error(`Handling ownership for ${item.kind}/${item.metadata.name}: ${err}`);
+    }
+}
+
 ;// CONCATENATED MODULE: ../operator/cdktf.ts
 
 
@@ -371402,24 +371840,25 @@ function helperCreateCheckRunName(cmd, item) {
 
 
 
+
 function processOperation(item, op, handler) {
     operator_src_logger.info(`Processing operation ${op} on ${item.kind}/${item.metadata?.name}`);
     try {
         switch (op) {
             case OperationType.UPDATED:
-                return updated(item, op, handler);
+                return cdktf_updated(item, op, handler);
             case OperationType.CREATED:
-                return created(item, op, handler);
+                return cdktf_created(item, op, handler);
             case OperationType.RENAMED:
-                return renamed(item, op, handler);
+                return cdktf_renamed(item, op, handler);
             case OperationType.SYNC:
-                return sync(item, op, handler);
+                return cdktf_sync(item, op, handler);
             case OperationType.MARKED_TO_DELETION:
-                return markedToDeletion(item, op, handler);
+                return cdktf_markedToDeletion(item, op, handler);
             case OperationType.RETRY:
                 return cdktf_retry(item, op, handler);
             case OperationType.NOTHING:
-                return nothing(item, op, handler);
+                return cdktf_nothing(item, op, handler);
             default:
                 throw new Error(`Operation ${op} not supported`);
         }
@@ -371429,24 +371868,27 @@ function processOperation(item, op, handler) {
         throw e;
     }
 }
-async function* created(item, op, handler) {
+async function* cdktf_created(item, op, handler) {
     for await (const transition of doApply(item, op, handler)) {
         yield transition;
     }
+    await manageOwnershipReferences(item, handler, op);
 }
-async function* renamed(item, op, handler) {
+async function* cdktf_renamed(item, op, handler) {
     for await (const transition of doApply(item, op, handler)) {
         yield transition;
     }
+    await manageOwnershipReferences(item, handler, op);
 }
-async function* updated(item, op, handler) {
+async function* cdktf_updated(item, op, handler) {
     for await (const transition of doApply(item, op, handler)) {
         yield transition;
     }
+    await manageOwnershipReferences(item, handler, op);
 }
 async function* cdktf_retry(item, op, handler) {
     if ('deletionTimestamp' in item.metadata) {
-        for await (const transition of markedToDeletion(item, op, handler)) {
+        for await (const transition of cdktf_markedToDeletion(item, op, handler)) {
             yield transition;
         }
     }
@@ -371456,7 +371898,7 @@ async function* cdktf_retry(item, op, handler) {
         }
     }
 }
-async function* sync(item, op, handler) {
+async function* cdktf_sync(item, op, handler) {
     yield {
         item,
         reason: op,
@@ -371475,7 +371917,7 @@ async function* sync(item, op, handler) {
         message: 'terraform execution finished',
     };
 }
-async function* markedToDeletion(item, op, handler) {
+async function* cdktf_markedToDeletion(item, op, handler) {
     // here we store the current callbacks that
     // are being used (synth|tf-apply...)
     let checkRunCtl;
@@ -371574,7 +372016,7 @@ async function* markedToDeletion(item, op, handler) {
         }
     }
 }
-async function* nothing(item, op, handler) {
+async function* cdktf_nothing(item, op, handler) {
     yield {
         item,
         reason: op,
@@ -372383,8 +372825,7 @@ class WriterAdditionalFiles extends writer {
         super();
         this.files = files;
     }
-    // this writer does not "write" anything per se
-    // it just complies with the abstract class it inherits from
+    // This writer complies with the abstract Writer class but does not render content in the traditional sense.
     async _render() {
         return '';
     }
@@ -374996,6 +375437,7 @@ async function tfLocal(cr, namespace, cmd = 'plan') {
 
 
 
+
 let importModeActive = false;
 let withMetricsMode = false;
 
@@ -375070,6 +375512,11 @@ function getProvisionImplementation(plural) {
         case 'githubrepositorysecretssections':
             implementation = processOperation;
             break;
+        case 'fsdummiesa':
+        case 'fsdummiesb':
+        case 'fsdummiesc':
+            implementation = processFirestartrDummies;
+            break;
     }
     if (!implementation)
         throw new Error(`No implementation found for ${plural}`);

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

@@ -489,10 +489,26 @@ declare const schemas: {
                             type: string;
                             description: string;
                         };
+                        name: {
+                            type: string;
+                            description: string;
+                        };
+                        orgPermissions: {
+                            type: string;
+                            description: string;
+                        };
+                        archiveOnDestroy: {
+                            type: string;
+                            description: string;
+                        };
                         visibility: {
                             type: string;
                             enum: string[];
                         };
+                        description: {
+                            type: string;
+                            description: string;
+                        };
                         features: {
                             type: string;
                             items: {

package/build/packages/cdk8s_renderer/src/claims/github/component.schema.d.ts

@@ -19,10 +19,26 @@ declare const _default: {
                         type: string;
                         description: string;
                     };
+                    name: {
+                        type: string;
+                        description: string;
+                    };
+                    orgPermissions: {
+                        type: string;
+                        description: string;
+                    };
+                    archiveOnDestroy: {
+                        type: string;
+                        description: string;
+                    };
                     visibility: {
                         type: string;
                         enum: string[];
                     };
+                    description: {
+                        type: string;
+                        description: string;
+                    };
                     features: {
                         type: string;
                         items: {

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

@@ -124,10 +124,26 @@ export declare const GithubSchemas: ({
                         type: string;
                         description: string;
                     };
+                    name: {
+                        type: string;
+                        description: string;
+                    };
+                    orgPermissions: {
+                        type: string;
+                        description: string;
+                    };
+                    archiveOnDestroy: {
+                        type: string;
+                        description: string;
+                    };
                     visibility: {
                         type: string;
                         enum: string[];
                     };
+                    description: {
+                        type: string;
+                        description: string;
+                    };
                     features: {
                         type: string;
                         items: {

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

@@ -1,3 +1,4 @@
 export default function render(featurePath: string, featureRenderPath: string, entity: any, firestartrConfig?: any, featureArgs?: any): any;
 export declare function buildContext(entity: any, args: any, firestartrConfig: any, featureArgs: any): any;
+export declare function expandFiles(featurePath: string, configData: any, context: any): void;
 export declare function renderContent(template: string, ctx: any): string;

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

@@ -29,6 +29,13 @@ declare const _default: {
                         };
                     };
                 };
+                filesTemplates: {
+                    type: string;
+                    description: string;
+                    items: {
+                        type: string;
+                    };
+                };
             };
             required: string[];
             title: string;
@@ -48,7 +55,7 @@ declare const _default: {
             additionalProperties: boolean;
             properties: {
                 $lit: {
-                    type: string;
+                    type: string[];
                 };
                 $ref: {
                     type: string;

package/build/packages/operator/fdummies/index.d.ts

@@ -0,0 +1,8 @@
+import { OperationType } from '../src/informer';
+export declare function processFirestartrDummies(item: any, op: string, handler: any): Promise<void> | AsyncGenerator<{
+    item: any;
+    reason: OperationType;
+    type: string;
+    status: string;
+    message: string;
+}, void, unknown>;

package/build/packages/operator/src/cdktf/ownership.d.ts

@@ -0,0 +1,2 @@
+import { OperationType } from '../informer';
+export declare function manageOwnershipReferences(item: any, handler: any, op: OperationType): Promise<void>;

package/build/packages/operator/src/informer.d.ts

@@ -23,6 +23,8 @@ export type WorkItem = {
     process?: Function;
     upsertTime?: number;
     isDeadLetter?: boolean;
+    isBlocked?: boolean;
+    fUnblock?: Function;
 };
 type HandlerFinalizerFn = (kind: string, namespace: string, item: any | string, finalizer: string) => Promise<any>;
 type HandlerInformPlanFn = (prUrl: string, planText: string) => Promise<void>;
@@ -44,6 +46,9 @@ export type WorkItemHandler = {
     itemPath: ItemPathFn;
     error: ErrorFn;
     success: SuccessFn;
+    isBlocked?: boolean;
+    needsBlocking?: (item: any) => boolean;
+    fUnblock?: Function;
 };
 /**
  * Observe whenever a new item is added, modified or deleted in a given kind

package/build/packages/operator/src/ownership.d.ts

@@ -0,0 +1,4 @@
+import { OwnerReference } from './types';
+export declare function getOwnerReferences(item: any): Promise<OwnerReference[]>;
+export declare function setOwnerReference(itemPath: string, namespace: string, ownerKind: string, ownerName: string, blockOwnerDeletion?: boolean): Promise<void>;
+export declare function writeOwnerReferences(kind: string, namespace: string, item: any, ownerReferences: OwnerReference[]): Promise<any>;

package/build/packages/operator/src/types.d.ts

@@ -0,0 +1,8 @@
+export interface OwnerReference {
+    apiVersion: string;
+    kind: string;
+    name: string;
+    uid: string;
+    controller?: boolean;
+    blockOwnerDeletion?: boolean;
+}

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

@@ -1,6 +1,17 @@
 import Writer from './writer';
+/**
+ * Represents a file to be written to the Terraform workspace.
+ * @property content The file contents, base64-encoded. This will be decoded before writing to disk.
+ * @property path The relative path (from the project root) where the file should be written.
+ */
 export interface FirestartrTerraformWorkspaceSpecFile {
+    /**
+     * The file contents, base64-encoded. This will be decoded before writing to disk.
+     */
     content: string;
+    /**
+     * The relative path (from the project root) where the file should be written.
+     */
     path: string;
 }
 type FirestartrTerraformWorkspaceSpecFiles = FirestartrTerraformWorkspaceSpecFile[];

package/package.json

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