@firestartr/cli 1.54.0-snapshot-13 → 1.54.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: {
@@ -367240,6 +367256,9 @@ const kindPluralMap = {
     providerconfigs: 'FirestartrProviderConfig',
     externalsecrets: 'ExternalSecret',
     secrets: 'Secret',
+    fsdummiesa: 'FirestartrDummyA',
+    fsdummiesb: 'FirestartrDummyB',
+    fsdummiesc: 'FirestartrDummyC',
 };
 function getKindFromPlural(plural) {
     return kindPluralMap[plural];
@@ -368535,6 +368554,9 @@ var WorkStatus;
 
 
 const kindsWithFinalizer = [
+    'FirestartrDummyA',
+    'FirestartrDummyB',
+    'FirestartrDummyC',
     'FirestartrTerraformWorkspace',
     'FirestartrGithubGroup',
     'FirestartrGithubMembership',
@@ -368904,6 +368926,255 @@ function dummy_fWait(ms) {
     });
 }
 
+;// 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;
+    }
+}
+async function* created(item, op, handler) {
+    for await (const transition of doRun(item, op, handler)) {
+        yield transition;
+    }
+}
+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);
+        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);
+        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) {
+    const s = item.spec?.computation?.numberOfSeconds;
+    operator_src_logger.info(`Processing dummy ${item.kind}/${item.metadata.name}: computing for ${s} seconds`);
+    if (!s)
+        throw new Error('Unprocessable dummy: missing 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
 
 
@@ -369469,7 +369740,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,
@@ -371407,19 +371678,19 @@ function processOperation(item, op, handler) {
     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 +371700,24 @@ 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;
     }
 }
-async function* renamed(item, op, handler) {
+async function* cdktf_renamed(item, op, handler) {
     for await (const transition of doApply(item, op, handler)) {
         yield transition;
     }
 }
-async function* updated(item, op, handler) {
+async function* cdktf_updated(item, op, handler) {
     for await (const transition of doApply(item, op, handler)) {
         yield transition;
     }
 }
 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 +371727,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 +371746,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 +371845,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 +372654,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 +375266,7 @@ async function tfLocal(cr, namespace, cmd = 'plan') {
 
 
 
+
 let importModeActive = false;
 let withMetricsMode = false;
 
@@ -375070,6 +375341,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/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/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-13",
+  "version": "1.54.0",
   "private": false,
   "description": "Commandline tool",
   "main": "build/main.js",