@firestartr/cli 1.50.1-snapshot-44 → 1.51.1-snapshot-01

package/build/index.js

@@ -346931,6 +346931,7 @@ const DEFAULT_TIME_ZONE = 'Europe/Madrid';
 function validateCron(cronLine, tz = DEFAULT_TIME_ZONE) {
     try {
         const interval = cron_parser_dist.CronExpressionParser.parse(cronLine, {
+            // to enable the only minutes cron
             strict: false,
             tz,
         });
@@ -358187,6 +358188,7 @@ const GithubSchemas = [
                                     type: 'string',
                                 },
                             },
+                            additionalProperties: false,
                             required: ['enabled'],
                             oneOf: [
                                 {
@@ -358995,14 +358997,7 @@ async function loadInitializers(claim, initializersPath = config_getPath('initia
     return loadedInitializers;
 }
 function loadClaimDefaults() {
-    try {
-        return catalog_common.io.fromYaml(external_fs_.readFileSync(`${config_getPath('claimsDefaults')}/claims_defaults.yaml`, 'utf-8'));
-    }
-    catch (error) {
-        const errMsg = `Could not read claims defaults file in path ${config_getPath('claimsDefaults')}/claims_defaults.yaml: ${error}`;
-        cdk8s_renderer_src_logger.error(errMsg);
-        throw new Error(errMsg);
-    }
+    return catalog_common.io.fromYaml(external_fs_.readFileSync(`${config_getPath('claimsDefaults')}/claims_defaults.yaml`, 'utf-8'));
 }
 /*
  * Using fast-json-patch, compares a claim to its kind's defaults, then patches it.
@@ -365295,19 +365290,12 @@ function getConfigPath() {
     getConfigPath,
 });
 
-;// CONCATENATED MODULE: ../importer/src/logger.ts
-
-/* harmony default export */ const importer_src_logger = (catalog_common.logger);
-
 ;// CONCATENATED MODULE: ../importer/src/decanter/base.ts
 
 
 
 
 
-
-
-
 class Decanter {
     set github(githubInstance) {
         this._github = githubInstance;
@@ -365429,20 +365417,6 @@ class Decanter {
     adapt() {
         return this._adapt();
     }
-    async __loadInitializer(initDefaultPath, isAbsolute = false) {
-        let initPath;
-        try {
-            initPath = isAbsolute
-                ? initDefaultPath
-                : external_path_.join(getConfigPath(), 'resources', initDefaultPath);
-            const adapter = catalog_common.io.fromYaml(external_fs_.readFileSync(initPath, 'utf-8'));
-            return new InitializerDefault(adapter);
-        }
-        catch (e) {
-            importer_src_logger.error(`Loading ${initPath}: ${e}`);
-            throw new Error(`Loading ${initPath}: ${e}`);
-        }
-    }
 }
 Decanter.collectionKind = '';
 /* harmony default export */ const decanter_base = (Decanter);
@@ -365460,9 +365434,19 @@ class GithubDecanter extends decanter_base {
     }
 }
 
+;// CONCATENATED MODULE: ../importer/src/logger.ts
+
+/* harmony default export */ const importer_src_logger = (catalog_common.logger);
+
 ;// CONCATENATED MODULE: ../importer/src/decanter/gh/github_group.ts
 
 
+
+
+
+
+
+
 class GroupGithubDecanter extends GithubDecanter {
     constructor() {
         super(...arguments);
@@ -365521,7 +365505,43 @@ class GroupGithubDecanter extends GithubDecanter {
         return this.__validateEqual(members, this.data.members);
     }
     async __adaptInitializerBase(_claim) {
-        return await this.__loadInitializer('defaults_github_group.yaml');
+        let githubGroupDefaultsFilePath;
+        try {
+            githubGroupDefaultsFilePath = external_path_.join(getConfigPath(), 'resources', 'defaults_github_group.yaml');
+        }
+        catch (e) {
+            importer_src_logger.warn('No config path set, using built-in defaults');
+            githubGroupDefaultsFilePath = '';
+        }
+        let adapter;
+        if (githubGroupDefaultsFilePath &&
+            external_fs_.existsSync(githubGroupDefaultsFilePath)) {
+            adapter = catalog_common.io.fromYaml(external_fs_.readFileSync(githubGroupDefaultsFilePath, 'utf-8'));
+        }
+        else {
+            adapter = {
+                name: 'base',
+                apiVersion: 'firestartr.dev/v1',
+                kind: 'FirestartrGithubGroup',
+                defaultValues: {
+                    context: {
+                        backend: {
+                            ref: {
+                                kind: 'FirestartrProviderConfig',
+                                name: 'firestartr-terraform-state',
+                            },
+                        },
+                        provider: {
+                            ref: {
+                                kind: 'FirestartrProviderConfig',
+                                name: 'github-app',
+                            },
+                        },
+                    },
+                },
+            };
+        }
+        return new InitializerDefault(adapter);
     }
     __validateKind(cr) {
         return true;
@@ -365617,6 +365637,12 @@ applyCollectionMixins(GroupCollectionGithubDecanter);
 ;// CONCATENATED MODULE: ../importer/src/decanter/gh/github_member.ts
 
 
+
+
+
+
+
+
 class MemberGithubDecanter extends GithubDecanter {
     constructor() {
         super(...arguments);
@@ -365654,7 +365680,43 @@ class MemberGithubDecanter extends GithubDecanter {
         });
     }
     async __adaptInitializerBase(_claim) {
-        return await this.__loadInitializer('defaults_github_membership.yaml');
+        let githubMemberDefaultsFilePath;
+        try {
+            githubMemberDefaultsFilePath = external_path_.join(getConfigPath(), 'resources', 'defaults_github_membership.yaml');
+        }
+        catch (e) {
+            importer_src_logger.warn('No config path set, using built-in defaults');
+            githubMemberDefaultsFilePath = '';
+        }
+        let adapter;
+        if (githubMemberDefaultsFilePath &&
+            external_fs_.existsSync(githubMemberDefaultsFilePath)) {
+            adapter = catalog_common.io.fromYaml(external_fs_.readFileSync(githubMemberDefaultsFilePath, 'utf-8'));
+        }
+        else {
+            adapter = {
+                name: 'base',
+                apiVersion: 'firestartr.dev/v1',
+                kind: 'FirestartrGithubMembership',
+                defaultValues: {
+                    context: {
+                        backend: {
+                            ref: {
+                                kind: 'FirestartrProviderConfig',
+                                name: 'firestartr-terraform-state',
+                            },
+                        },
+                        provider: {
+                            ref: {
+                                kind: 'FirestartrProviderConfig',
+                                name: 'github-app',
+                            },
+                        },
+                    },
+                },
+            };
+        }
+        return new InitializerDefault(adapter);
     }
 }
 
@@ -365687,6 +365749,11 @@ applyCollectionMixins(MemberCollectionGithubDecanter);
 
 
 
+
+
+
+
+
 const TYPE_MAP = {
     User: 'user',
     Team: 'group',
@@ -365944,7 +366011,74 @@ class RepoGithubDecanter extends GithubDecanter {
         return null;
     }
     async __adaptInitializerBase(_claim) {
-        return await this.__loadInitializer('defaults_github_repository.yaml');
+        let githubRepoDefaultsFilePath;
+        try {
+            githubRepoDefaultsFilePath = external_path_.join(getConfigPath(), 'resources', 'defaults_github_repository.yaml');
+        }
+        catch (e) {
+            importer_src_logger.warn('No config path set, using built-in defaults');
+            githubRepoDefaultsFilePath = '';
+        }
+        let adapter;
+        if (githubRepoDefaultsFilePath &&
+            external_fs_.existsSync(githubRepoDefaultsFilePath)) {
+            adapter = catalog_common.io.fromYaml(external_fs_.readFileSync(githubRepoDefaultsFilePath, 'utf-8'));
+        }
+        else {
+            adapter = {
+                name: 'base',
+                apiVersion: 'firestartr.dev/v1',
+                kind: 'FirestartrGithubRepository',
+                defaultValues: {
+                    context: {
+                        backend: {
+                            ref: {
+                                kind: 'FirestartrProviderConfig',
+                                name: 'firestartr-terraform-state',
+                            },
+                        },
+                        provider: {
+                            ref: {
+                                kind: 'FirestartrProviderConfig',
+                                name: 'github-app',
+                            },
+                        },
+                    },
+                    name: this.data.repoDetails.name,
+                    description: this.data.repoDetails.description,
+                    org: this.org,
+                    firestartr: {
+                        technology: { stack: 'none', version: 'none' },
+                    },
+                    repo: {
+                        description: this.data.repoDetails.description,
+                        allowMergeCommit: this.data.repoDetails.allow_merge_commit,
+                        allowSquashMerge: this.data.repoDetails.allow_squash_merge,
+                        allowRebaseMerge: this.data.repoDetails.allow_rebase_merge,
+                        allowAutoMerge: this.data.repoDetails.allow_auto_merge,
+                        deleteBranchOnMerge: this.data.repoDetails.delete_branch_on_merge,
+                        autoInit: true,
+                        archiveOnDestroy: true,
+                        allowUpdateBranch: this.data.repoDetails.allow_update_branch,
+                        hasIssues: this.data.repoDetails.has_issues,
+                        visibility: this.data.repoDetails.visibility,
+                        defaultBranch: this.data.repoDetails.default_branch,
+                    },
+                    permissions: [],
+                    actions: {
+                        oidc: this.data.oidc.use_default
+                            ? undefined
+                            : {
+                                useDefault: this.data.oidc.use_default,
+                                includeClaimKeys: this.data.oidc.include_claim_keys
+                                    ? this.data.oidc.include_claim_keys
+                                    : [],
+                            },
+                    },
+                },
+            };
+        }
+        return new InitializerDefault(adapter);
     }
     async __adaptOverriderRepo(_claim) {
         return new GithubRepositoryOverrider();
@@ -366188,17 +366322,22 @@ function compileReg(value) {
 });
 
 
+
 //  const MAP_COLLECTION_KIND_CR_KIND: any = {
 //    gh-members: 'FirestartrGithubMembership',
 //    gh-group: 'FirestartrGithubGroup',
 //    gh-repo: 'FirestartrGithubRepository',
 //  }
-async function runImporter(force, skipPlan, claimsPath, crsPath, configPath, claimsDefaultsPath, org, filters, provider = AllowedProviders.all) {
+async function runImporter(force, generateDefaults, skipPlan, claimsPath, crsPath, configPath, claimsDefaultsPath, org, filters, provider = AllowedProviders.all) {
     configureProvider(provider);
     let generatedFilters = [];
     //gh-repo,REGEXP=.*vite.*
     cdk8s_renderer.setPath('claimsDefaults', claimsDefaultsPath);
     generatedFilters = buildFilters(filters, force, crsPath, generatedFilters);
+    if (generateDefaults) {
+        generateClaimsDefaults(org, claimsDefaultsPath);
+        generateDefaultsFn(org, configPath);
+    }
     await importGithubGitopsRepository(org, skipPlan, claimsPath, crsPath, configPath, generatedFilters);
 }
 function buildFilters(filters, force, crsPath, generatedFilters) {
@@ -366234,6 +366373,97 @@ function createSkipFilters(filters) {
     }
     return filters;
 }
+function generateDefaultsFn(org, defaultsPath) {
+    generateDefaultsForGithubGroups(org, defaultsPath);
+    generateDefaultsForGithubRepos(org, defaultsPath);
+    generateDefaultsForGithubRepos(org, defaultsPath);
+}
+function generateDefaultsForGithubGroups(org, defaultsPath) {
+    const defaultGroups = {
+        name: 'group_base',
+        apiVersion: 'firestartr.dev/v1',
+        kind: 'FirestartrGithubGroup',
+        defaultValues: {
+            org: org,
+        },
+    };
+    catalog_common.io.writeYamlFile('defaults_github_group', defaultGroups, defaultsPath);
+}
+function generateDefaultsForGithubRepos(org, defaultsPath) {
+    const defaultRepos = {
+        name: 'repo_base',
+        apiVersion: 'firestartr.dev/v1',
+        kind: 'FirestartrGithubRepository',
+        defaultValues: {
+            firestartr: {
+                technology: {
+                    stack: 'none',
+                    version: 'none',
+                },
+            },
+            repo: {
+                allowAutoMerge: true,
+                codeowners: ' - ',
+                allowMergeCommit: true,
+                allowSquashMerge: true,
+                allowRebaseMerge: true,
+                deleteBranchOnMerge: true,
+                autoInit: true,
+                archiveOnDestroy: true,
+                allowUpdateBranch: true,
+                hasIssues: true,
+            },
+        },
+    };
+    catalog_common.io.writeYamlFile('defaults_github_repository', defaultRepos, defaultsPath);
+}
+function generateClaimsDefaults(org, defaultsPath) {
+    const defaultClaims = {
+        ComponentClaim: {
+            version: '1.0',
+            type: 'service',
+            lifecycle: 'production',
+            system: 'system:firestartr-test-system',
+            maintainedBy: [],
+            platformOwner: `group:${org}-all`,
+            providers: {
+                github: {
+                    org: org,
+                    branchStrategy: {
+                        name: 'trunkBasedDevelopment',
+                        defaultBranch: 'main',
+                    },
+                    orgPermissions: 'none',
+                    visibility: 'private',
+                    technology: {
+                        stack: 'none',
+                        version: 'none',
+                    },
+                    features: [],
+                },
+            },
+        },
+        GroupClaim: {
+            providers: {
+                github: {
+                    org: org,
+                    privacy: 'closed',
+                },
+            },
+        },
+        SystemClaim: {
+            providers: {
+                catalog: null,
+            },
+        },
+        DomainClaim: {
+            providers: {
+                catalog: null,
+            },
+        },
+    };
+    catalog_common.io.writeYamlFile('claims_defaults', defaultClaims, defaultsPath);
+}
 
 ;// CONCATENATED MODULE: ./src/subcommands/importer-subcommands.ts
 
@@ -366242,6 +366472,7 @@ const importSubcommand = {
     requiredEnv: [],
     subparameters: [
         { name: 'force', type: Boolean },
+        { name: 'generateDefaults', type: Boolean },
         { name: 'skipPlan', type: Boolean },
         { name: 'claims', type: String },
         { name: 'crs', type: String },
@@ -366252,7 +366483,7 @@ const importSubcommand = {
     ],
     run: async (options) => {
         console.table(options);
-        await runImporter(options.force, options.skipPlan, options.claims, options.crs, options.config, options.claimsDefaults, options.org, options.filters);
+        await runImporter(options.force, options.generateDefaults, options.skipPlan, options.claims, options.crs, options.config, options.claimsDefaults, options.org, options.filters);
     },
 };
 
@@ -367109,6 +367340,28 @@ async function needsProvisioningOnCreate(cr) {
     operator_src_logger.debug(`Skipping the provisioning process for custom resource '${cr.kind}/${cr.metadata.name}' because its current state is not handled.`);
     return false;
 }
+async function updateSyncTransition(itemPath, reason, lastSyncTime, nextSyncTime, message, status) {
+    operator_src_logger.info(`The item at '${itemPath}' transitioned to a new SYNCHRONIZED condition of '${status}'. The reason for the change is '${reason}' with the message: '${message}'.`);
+    const k8sItem = await getItemByItemPath(itemPath);
+    if (!('status' in k8sItem))
+        k8sItem.status = {};
+    if (!('conditions' in k8sItem.status))
+        k8sItem.status.conditions = [];
+    let conditionObject = getRelevantCondition(k8sItem.status.conditions, 'SYNCHRONIZED');
+    conditionObject = {
+        ...conditionObject,
+        reason,
+        status,
+        message,
+        observedGeneration: k8sItem.metadata.generation,
+        lastSyncTime,
+        lastUpdateTime: new Date().toJSON(),
+        nextSyncTime,
+    };
+    k8sItem.status.conditions = updateConditionByType(k8sItem.status.conditions, 'SYNCHRONIZED', conditionObject);
+    const itemParameters = itemPath.split('/');
+    await writeStatus(itemParameters[1], itemParameters[0], k8sItem);
+}
 async function updateTransition(itemPath, reason, type, statusValue, message = '', updateStatusOnly = false) {
     operator_src_logger.info(`The item at '${itemPath}' transitioned to a new status of '${statusValue}' (type: '${type}'). The reason for the change is '${reason}' with the message: '${message}'. This was a status-only update: '${updateStatusOnly}'.`);
     const k8sItem = await getItemByItemPath(itemPath);
@@ -367169,12 +367422,115 @@ function updateConditionByType(conditionList, type, newCondition) {
     return conditionList;
 }
 
-;// CONCATENATED MODULE: ../operator/src/syncer.ts
+;// CONCATENATED MODULE: ../operator/src/syncCtl.ts
+// Machinery for syncing
+
+
 
 
-const syncWatchers = {};
-const FORCE_REVISION_TIME = 60 * 1000;
 const DEFAULT_REVISION_TIME = '1m';
+async function createWatcherForItem(itemPath, itemCR) {
+    const item = itemCR ?? await getItemByItemPath(itemPath);
+    const syncStatus = await getSyncStatus(itemPath, item);
+    let nextTimeoutInMS = syncStatus.nextTimeoutInMS;
+    // we have lapsed last interval
+    // we calculate from the lastSyncTime
+    if (syncStatus.intervalLapsed) {
+        operator_src_logger.debug(`Next sync interval have been lapsed for ${itemPath}`);
+        if (syncStatus.syncMode === 'Period') {
+            operator_src_logger.debug(`Next sync interval have been lapsed for ${itemPath} the sync will start now`);
+            nextTimeoutInMS = -1;
+        }
+    }
+    const watcher = {
+        itemPath,
+        lastRevision: setTimeout(() => {
+            operator_src_logger.debug(`Item ${itemPath} needs revision`);
+            watcher.needsRevision = true;
+        }, nextTimeoutInMS),
+        needsRevision: false,
+    };
+    return watcher;
+}
+async function destroyWatcherForItem(watcher) {
+    clearTimeout(watcher.lastRevision);
+    operator_src_logger.debug(`Disabled SyncWatcher for ${watcher.itemPath}`);
+}
+async function getSyncSpecs(itemPath, itemCR) {
+    const item = itemCR ?? await getItemByItemPath(itemPath);
+    return {
+        item,
+        syncable: item.metadata.annotations &&
+            item.metadata.annotations['firestartr.dev/sync-enabled'] &&
+            item.metadata.annotations['firestartr.dev/sync-enabled'] === 'true',
+        period: item.metadata.annotations['firestartr.dev/sync-period'] ||
+            DEFAULT_REVISION_TIME,
+        schedule: item.metadata.annotations['firestartr.dev/sync-schedule'] || false,
+        scheduleTZ: item.metadata.annotations['firestartr.dev/sync-schedule-timezone'] ||
+            'Europe/Madrid',
+    };
+}
+async function getSyncStatus(itemPath, itemCR) {
+    const item = itemCR ?? await getItemByItemPath(itemPath);
+    const syncCondition = getConditionByType(item.status?.conditions ?? [], 'SYNCHRONIZED');
+    // no sync condition present
+    if (!syncCondition) {
+        return {
+            syncStatusPresent: false,
+        };
+    }
+    else {
+        const nextSyncDate = new Date(syncCondition.nextSyncTime);
+        const isLapsed = Date.now() >= nextSyncDate.getTime();
+        const mode = (await getSyncSpecs(itemPath, item)).schedule
+            ? 'Scheduled'
+            : 'Period';
+        return {
+            itemPath,
+            syncMode: mode,
+            conditions: [syncCondition],
+            syncStatusPresent: true,
+            nextTimeoutInMS: isLapsed ? -1 : nextSyncDate.getTime() - Date.now(),
+            intervalLapsed: isLapsed,
+        };
+    }
+}
+async function setSyncStatus(itemPath, reason, status, message) {
+    const item = await getItemByItemPath(itemPath);
+    const machinery = assessSyncCalculationMachinery(item);
+    const syncStatus = await machinery(item, reason, status, message);
+    syncStatus.itemPath = itemPath;
+    syncStatus.syncStatusPresent = true;
+    operator_src_logger.info(`Setting sync status for ${itemPath}: ${JSON.stringify(syncStatus)}`);
+    const syncTransition = syncStatus.conditions[0];
+    await updateSyncTransition(itemPath, syncTransition.reason, syncTransition.lastSyncTime, syncTransition.nextSyncTime, syncTransition.message, syncTransition.status);
+    return syncStatus;
+}
+function assessSyncCalculationMachinery(item) {
+    if (item.metadata.annotations['firestartr.dev/sync-schedule'] ?? false) {
+        return processScheduledSync;
+    }
+    else {
+        return processPeriodSync;
+    }
+}
+async function processPeriodSync(item, reason, status, message) {
+    const period = item.metadata.annotations['firestartr.dev/sync-period'];
+    const periodMS = helperCalculateRevisionTime(period);
+    return {
+        syncMode: 'Period',
+        conditions: [
+            {
+                reason,
+                type: 'SYNCHRONIZED',
+                message,
+                status,
+                lastSyncTime: new Date().toISOString(),
+                nextSyncTime: new Date(Date.now() + periodMS).toISOString(),
+            },
+        ],
+    };
+}
 function helperCalculateRevisionTime(period) {
     const [_, scalar, dimension] = period.split(/(\d+)/);
     const multiplier = dimension === 's'
@@ -367188,24 +367544,50 @@ function helperCalculateRevisionTime(period) {
                     : 1;
     return Number(scalar) * multiplier * 1000;
 }
+async function processScheduledSync(item, reason, status, message) {
+    const nextPeriod = catalog_common.cron.getCronNextInterval(item.metadata.annotations['firestartr.dev/sync-schedule'], item.metadata.annotations['firestartr.dev/sync-schedule-timezone'] ||
+        undefined);
+    const nextPeriodDate = new Date(nextPeriod);
+    return {
+        syncMode: 'Scheduled',
+        conditions: [
+            {
+                reason,
+                type: 'SYNCHRONIZED',
+                message,
+                status,
+                lastSyncTime: new Date().toISOString(),
+                nextSyncTime: nextPeriodDate.toISOString(),
+            },
+        ],
+    };
+}
+
+;// CONCATENATED MODULE: ../operator/src/syncer.ts
+
+
+
+const syncWatchers = {};
+const FORCE_REVISION_TIME = (/* unused pure expression or super */ null && (60 * 1000));
 async function syncer(enqueue) {
     // fork
     void loop(enqueue);
     return {
         addItem(itemPath) {
             operator_src_logger.info(`Added item of path '${itemPath}' for synchronization`);
-            void itemIsSyncable(itemPath).then((itemSyncInfo) => {
+            getSyncSpecs(itemPath)
+                .then(async (itemSyncInfo) => {
                 if (!itemSyncInfo.syncable) {
                     return;
                 }
-                syncWatchers[itemPath] = {
-                    itemPath,
-                    lastRevision: setInterval(() => {
-                        syncWatchers[itemPath].needsRevision = true;
-                    }, helperCalculateRevisionTime(itemSyncInfo.period)),
-                    needsRevision: false,
-                };
+                const syncCtl = await getSyncStatus(itemPath, itemSyncInfo.item);
+                syncWatchers[itemPath] = await createWatcherForItem(itemPath, itemSyncInfo.item);
                 operator_src_logger.info(`Configured synchronization for item at path '${itemPath}'`);
+                operator_src_logger.debug(`Sync information for '${itemPath}': ${JSON.stringify({ ...itemSyncInfo, item: null }, null)}`);
+            })
+                .catch((err) => {
+                operator_src_logger.error(`Error on sync [add item]: ${err}`);
+                throw `Error on sync [add item]: ${err}`;
             });
         },
         updateItem(itemPath) {
@@ -367214,27 +367596,24 @@ async function syncer(enqueue) {
             //  return
             //}
             operator_src_logger.debug(`Updated item of path '${itemPath}' during synchronization`);
-            void itemIsSyncable(itemPath).then((itemSyncInfo) => {
-                if (!itemSyncInfo.syncable) {
-                    if (syncWatchers[itemPath]) {
-                        clearInterval(syncWatchers[itemPath].lastRevision);
-                        delete syncWatchers[itemPath];
-                        operator_src_logger.info(`Removed item of path '${itemPath}' from synchronization`);
-                    }
+            getSyncSpecs(itemPath)
+                .then(async (itemSyncInfo) => {
+                if (syncWatchers[itemPath]) {
+                    await destroyWatcherForItem(syncWatchers[itemPath]);
+                    delete syncWatchers[itemPath];
                 }
-                else {
-                    if (itemSyncInfo.syncable && syncWatchers[itemPath]) {
-                        clearInterval(syncWatchers[itemPath].lastRevision);
-                    }
-                    syncWatchers[itemPath] = {
-                        itemPath,
-                        lastRevision: setInterval(() => {
-                            syncWatchers[itemPath].needsRevision = true;
-                        }, helperCalculateRevisionTime(itemSyncInfo.period)),
-                        needsRevision: false,
-                    };
-                    operator_src_logger.debug(`Configured synchronization for item at path '${itemPath}' with watcher '${syncWatchers[itemPath]}'`);
+                // we need to chedk if the item is not syncable anymore
+                if (!itemSyncInfo.syncable) {
+                    operator_src_logger.info(`Removed item of path '${itemPath}' from synchronization`);
+                    return;
                 }
+                // if it is syncable we need to recalculate everything
+                syncWatchers[itemPath] = await createWatcherForItem(itemPath);
+                operator_src_logger.info(`Configured synchronization for item at path '${itemPath}' with watcher`);
+            })
+                .catch((err) => {
+                operator_src_logger.error(`Error on sync [updateItem]: ${err}`);
+                throw `Error on sync [updateItem]: ${err}`;
             });
         },
         deleteItem(itemPath) {
@@ -367242,10 +367621,15 @@ async function syncer(enqueue) {
                 operator_src_logger.debug(`Ignored deletion attempt for item at path '${itemPath}' as it was not found during synchronization`);
                 return;
             }
-            operator_src_logger.debug(`Deleted item of path '${itemPath}' during synchronization`);
-            clearInterval(syncWatchers[itemPath].lastRevision);
-            delete syncWatchers[itemPath];
-            operator_src_logger.debug(`Successfully deleted item at path '${itemPath}' during synchronization`);
+            destroyWatcherForItem(syncWatchers[itemPath])
+                .then(() => {
+                operator_src_logger.debug(`Deleted item of path '${itemPath}' during synchronization`);
+                delete syncWatchers[itemPath];
+            })
+                .catch((err) => {
+                operator_src_logger.error(`Error deleting item of path ${itemPath} for synchronization: ${err}`);
+                throw `Error deleting item of path ${itemPath} for synchronization: ${err}`;
+            });
         },
     };
 }
@@ -367255,23 +367639,14 @@ async function loop(enqueueIfNeeded) {
         const needRevisionItems = Object.values(syncWatchers).filter((watcher) => watcher.needsRevision);
         for (const watcher of needRevisionItems) {
             const item = await getItemIfNeededSync(watcher);
+            operator_src_logger.debug(`Item needs revision ${watcher.itemPath}`);
             if (item !== null) {
                 enqueueIfNeeded(item);
-                watcher.needsRevision = false;
             }
+            watcher.needsRevision = false;
         }
     }
 }
-async function itemIsSyncable(itemPath) {
-    const item = await getItemByItemPath(itemPath);
-    return {
-        syncable: item.metadata.annotations &&
-            item.metadata.annotations['firestartr.dev/sync-enabled'] &&
-            item.metadata.annotations['firestartr.dev/sync-enabled'] === 'true',
-        period: item.metadata.annotations['firestartr.dev/sync-period'] ||
-            DEFAULT_REVISION_TIME,
-    };
-}
 async function getItemIfNeededSync(watcher) {
     const item = await getItemByItemPath(watcher.itemPath);
     const isProvisioning = item.status?.conditions?.find((condition) => condition.type === 'PROVISIONING' && condition.status === 'True');
@@ -367280,13 +367655,7 @@ async function getItemIfNeededSync(watcher) {
     const isDeleting = item.status?.conditions?.find((condition) => condition.type === 'DELETING' && condition.status === 'True');
     if (isDeleting)
         return null;
-    const synchronizedCondition = item.status?.conditions?.find((condition) => condition.type === 'SYNCHRONIZED' && condition.status === 'True');
-    if (!synchronizedCondition)
-        return item;
-    const lastSync = new Date(synchronizedCondition.lastUpdateTime).getTime();
-    if (lastSync <= Date.now() - FORCE_REVISION_TIME)
-        return item;
-    return null;
+    return item;
 }
 function fWait(segs = 1) {
     return new Promise((ok) => {
@@ -367542,6 +367911,7 @@ var WorkStatus;
 
 
 
+
 const kindsWithFinalizer = [
     'FirestartrTerraformWorkspace',
     'FirestartrGithubGroup',
@@ -367661,14 +368031,17 @@ function enqueue(pluralKind, workItem, queue, compute, syncCtl, retryCtl) {
         success: () => retryCtl.successReconciling(informer_itemPath(pluralKind, workItem.item)),
     };
     workItem.process = async function* (item, operation, handler) {
-        for await (const transition of compute(item, operation, handler)) {
-            yield transition;
-        }
-        if (operation === OperationType.RENAMED ||
+        const needsUpdateSyncContidions = operation === OperationType.RENAMED ||
             operation === OperationType.UPDATED ||
             operation === OperationType.SYNC ||
             operation === OperationType.CREATED ||
-            operation === OperationType.RETRY) {
+            operation === OperationType.RETRY;
+        await setSyncStatus(workItem.handler.itemPath(), operation, 'False', 'Sync process started');
+        for await (const transition of compute(item, operation, handler)) {
+            yield transition;
+        }
+        if (needsUpdateSyncContidions) {
+            await setSyncStatus(workItem.handler.itemPath(), operation, operation === OperationType.SYNC ? 'True' : 'False', 'Sync process finished');
             syncCtl.updateItem(informer_itemPath(pluralKind, item));
         }
         else {
@@ -371794,13 +372167,6 @@ function isDestroyRetry(item) {
     return false;
 }
 async function* process_operation_sync(item, op, handler, syncPolicy, generalPolicy) {
-    yield {
-        item,
-        reason: op,
-        type: 'SYNCHRONIZED',
-        status: 'False',
-        message: 'Sync process started',
-    };
     if (!syncPolicy) {
         operator_src_logger.debug(`The Terraform processor is only observing item '${item.kind}/${item.metadata.name}' because no sync policy was found for operation '${op}'.`);
         yield* doPlanJSONFormat(item, op, handler);

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

@@ -686,6 +686,7 @@ declare const schemas: {
                                     type: string;
                                 };
                             };
+                            additionalProperties: boolean;
                             required: string[];
                             oneOf: ({
                                 required: string[];

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

@@ -41,6 +41,7 @@ export declare const TerraformSchemas: {
                                 type: string;
                             };
                         };
+                        additionalProperties: boolean;
                         required: string[];
                         oneOf: ({
                             required: string[];

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

@@ -41,6 +41,7 @@ declare const _default: {
                                 type: string;
                             };
                         };
+                        additionalProperties: boolean;
                         required: string[];
                         oneOf: ({
                             required: string[];

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

@@ -6,4 +6,4 @@ declare const _default: {
 };
 export default _default;
 import { AllowedProviders } from 'cdk8s_renderer';
-export declare function runImporter(force: boolean, skipPlan: boolean, claimsPath: string, crsPath: string, configPath: string, claimsDefaultsPath: string, org: string, filters: string[], provider?: AllowedProviders): Promise<void>;
+export declare function runImporter(force: boolean, generateDefaults: boolean, skipPlan: boolean, claimsPath: string, crsPath: string, configPath: string, claimsDefaultsPath: string, org: string, filters: string[], provider?: AllowedProviders): Promise<void>;

package/build/packages/importer/src/decanter/base.d.ts

@@ -1,4 +1,4 @@
-import { ImportInitializer, UUIDInitializer, NameNormalizer, InitializerClaimRef, InitializerDefault } from 'cdk8s_renderer';
+import { ImportInitializer, UUIDInitializer, NameNormalizer, InitializerClaimRef } from 'cdk8s_renderer';
 export default class Decanter {
     data: any;
     claimKind: string | undefined;
@@ -78,5 +78,4 @@ export default class Decanter {
             normalizers: NameNormalizer[];
         };
     }>;
-    __loadInitializer(initDefaultPath: string, isAbsolute?: boolean): Promise<InitializerDefault>;
 }

package/build/packages/importer/src/decanter/gh/github_member.d.ts

@@ -1,8 +1,9 @@
 import { GithubDecanter } from './base';
+import { InitializerDefault } from 'cdk8s_renderer';
 export default class MemberGithubDecanter extends GithubDecanter {
     claimKind: string;
     __decantStart(): void;
     __gatherRoleInOrg(): Promise<void>;
     __decantProviders(): void;
-    __adaptInitializerBase(_claim: any): Promise<import("../../../../cdk8s_renderer").InitializerDefault>;
+    __adaptInitializerBase(_claim: any): Promise<InitializerDefault>;
 }

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

@@ -1,2 +1,4 @@
 export declare function needsProvisioningOnCreate(cr: any): Promise<boolean>;
+export declare function updateSyncTransition(itemPath: string, reason: string, lastSyncTime: string, nextSyncTime: string, message: string, status: string): Promise<void>;
 export declare function updateTransition(itemPath: string, reason: string, type: string, statusValue: string, message?: string, updateStatusOnly?: boolean): Promise<void>;
+export declare function getConditionByType(conditionList: Array<any>, type: string): any;

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

@@ -0,0 +1,26 @@
+export type Condition = {
+    type: string;
+    status: 'True' | 'False' | 'Unknown';
+    reason: string;
+    message: string;
+    lastSyncTime?: string;
+    nextSyncTime?: string;
+};
+export type SyncStatus = {
+    itemPath?: string;
+    conditions?: Condition[];
+    nextTimeoutInMS?: number;
+    syncStatusPresent?: boolean;
+    intervalLapsed?: boolean;
+    syncMode?: 'Scheduled' | 'Period';
+};
+export type SyncWatcher = {
+    itemPath: string;
+    lastRevision: any;
+    needsRevision: boolean;
+};
+export declare function createWatcherForItem(itemPath: string, itemCR?: any): Promise<SyncWatcher>;
+export declare function destroyWatcherForItem(watcher: SyncWatcher): Promise<void>;
+export declare function getSyncSpecs(itemPath: string, itemCR?: any): Promise<any>;
+export declare function getSyncStatus(itemPath: string, itemCR?: any): Promise<SyncStatus>;
+export declare function setSyncStatus(itemPath: string, reason: string, status: 'True' | 'False' | 'Unknown', message: string): Promise<SyncStatus>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@firestartr/cli",
-  "version": "1.50.1-snapshot-44",
+  "version": "1.51.1-snapshot-01",
   "private": false,
   "description": "Commandline tool",
   "main": "build/main.js",