@firestartr/cli 1.50.1-snapshot-43 → 1.50.1-snapshot-44

package/build/index.js

@@ -346931,7 +346931,6 @@ 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,
         });
@@ -358996,7 +358995,14 @@ async function loadInitializers(claim, initializersPath = config_getPath('initia
     return loadedInitializers;
 }
 function loadClaimDefaults() {
-    return catalog_common.io.fromYaml(external_fs_.readFileSync(`${config_getPath('claimsDefaults')}/claims_defaults.yaml`, 'utf-8'));
+    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);
+    }
 }
 /*
  * Using fast-json-patch, compares a claim to its kind's defaults, then patches it.
@@ -365289,12 +365295,19 @@ 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;
@@ -365416,6 +365429,20 @@ 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);
@@ -365433,19 +365460,9 @@ 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);
@@ -365504,43 +365521,7 @@ class GroupGithubDecanter extends GithubDecanter {
         return this.__validateEqual(members, this.data.members);
     }
     async __adaptInitializerBase(_claim) {
-        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);
+        return await this.__loadInitializer('defaults_github_group.yaml');
     }
     __validateKind(cr) {
         return true;
@@ -365636,12 +365617,6 @@ applyCollectionMixins(GroupCollectionGithubDecanter);
 ;// CONCATENATED MODULE: ../importer/src/decanter/gh/github_member.ts
 
 
-
-
-
-
-
-
 class MemberGithubDecanter extends GithubDecanter {
     constructor() {
         super(...arguments);
@@ -365679,43 +365654,7 @@ class MemberGithubDecanter extends GithubDecanter {
         });
     }
     async __adaptInitializerBase(_claim) {
-        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);
+        return await this.__loadInitializer('defaults_github_membership.yaml');
     }
 }
 
@@ -365748,11 +365687,6 @@ applyCollectionMixins(MemberCollectionGithubDecanter);
 
 
 
-
-
-
-
-
 const TYPE_MAP = {
     User: 'user',
     Team: 'group',
@@ -366010,74 +365944,7 @@ class RepoGithubDecanter extends GithubDecanter {
         return null;
     }
     async __adaptInitializerBase(_claim) {
-        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);
+        return await this.__loadInitializer('defaults_github_repository.yaml');
     }
     async __adaptOverriderRepo(_claim) {
         return new GithubRepositoryOverrider();
@@ -366321,22 +366188,17 @@ function compileReg(value) {
 });
 
 
-
 //  const MAP_COLLECTION_KIND_CR_KIND: any = {
 //    gh-members: 'FirestartrGithubMembership',
 //    gh-group: 'FirestartrGithubGroup',
 //    gh-repo: 'FirestartrGithubRepository',
 //  }
-async function runImporter(force, generateDefaults, skipPlan, claimsPath, crsPath, configPath, claimsDefaultsPath, org, filters, provider = AllowedProviders.all) {
+async function runImporter(force, 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) {
@@ -366372,97 +366234,6 @@ 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
 
@@ -366471,7 +366242,6 @@ const importSubcommand = {
     requiredEnv: [],
     subparameters: [
         { name: 'force', type: Boolean },
-        { name: 'generateDefaults', type: Boolean },
         { name: 'skipPlan', type: Boolean },
         { name: 'claims', type: String },
         { name: 'crs', type: String },
@@ -366482,7 +366252,7 @@ const importSubcommand = {
     ],
     run: async (options) => {
         console.table(options);
-        await runImporter(options.force, options.generateDefaults, options.skipPlan, options.claims, options.crs, options.config, options.claimsDefaults, options.org, options.filters);
+        await runImporter(options.force, options.skipPlan, options.claims, options.crs, options.config, options.claimsDefaults, options.org, options.filters);
     },
 };
 
@@ -367339,28 +367109,6 @@ 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);
@@ -367421,115 +367169,12 @@ function updateConditionByType(conditionList, type, newCondition) {
     return conditionList;
 }
 
-;// CONCATENATED MODULE: ../operator/src/syncCtl.ts
-// Machinery for syncing
-
-
+;// CONCATENATED MODULE: ../operator/src/syncer.ts
 
 
+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'
@@ -367543,50 +367188,24 @@ 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`);
-            getSyncSpecs(itemPath)
-                .then(async (itemSyncInfo) => {
+            void itemIsSyncable(itemPath).then((itemSyncInfo) => {
                 if (!itemSyncInfo.syncable) {
                     return;
                 }
-                const syncCtl = await getSyncStatus(itemPath, itemSyncInfo.item);
-                syncWatchers[itemPath] = await createWatcherForItem(itemPath, itemSyncInfo.item);
+                syncWatchers[itemPath] = {
+                    itemPath,
+                    lastRevision: setInterval(() => {
+                        syncWatchers[itemPath].needsRevision = true;
+                    }, helperCalculateRevisionTime(itemSyncInfo.period)),
+                    needsRevision: false,
+                };
                 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) {
@@ -367595,24 +367214,27 @@ async function syncer(enqueue) {
             //  return
             //}
             operator_src_logger.debug(`Updated item of path '${itemPath}' during synchronization`);
-            getSyncSpecs(itemPath)
-                .then(async (itemSyncInfo) => {
-                if (syncWatchers[itemPath]) {
-                    await destroyWatcherForItem(syncWatchers[itemPath]);
-                    delete syncWatchers[itemPath];
-                }
-                // we need to chedk if the item is not syncable anymore
+            void itemIsSyncable(itemPath).then((itemSyncInfo) => {
                 if (!itemSyncInfo.syncable) {
-                    operator_src_logger.info(`Removed item of path '${itemPath}' from synchronization`);
-                    return;
+                    if (syncWatchers[itemPath]) {
+                        clearInterval(syncWatchers[itemPath].lastRevision);
+                        delete syncWatchers[itemPath];
+                        operator_src_logger.info(`Removed item of path '${itemPath}' from synchronization`);
+                    }
+                }
+                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]}'`);
                 }
-                // 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) {
@@ -367620,15 +367242,10 @@ async function syncer(enqueue) {
                 operator_src_logger.debug(`Ignored deletion attempt for item at path '${itemPath}' as it was not found during synchronization`);
                 return;
             }
-            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}`;
-            });
+            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`);
         },
     };
 }
@@ -367638,14 +367255,23 @@ 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');
@@ -367654,7 +367280,13 @@ async function getItemIfNeededSync(watcher) {
     const isDeleting = item.status?.conditions?.find((condition) => condition.type === 'DELETING' && condition.status === 'True');
     if (isDeleting)
         return null;
-    return item;
+    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;
 }
 function fWait(segs = 1) {
     return new Promise((ok) => {
@@ -367910,7 +367542,6 @@ var WorkStatus;
 
 
 
-
 const kindsWithFinalizer = [
     'FirestartrTerraformWorkspace',
     'FirestartrGithubGroup',
@@ -368030,17 +367661,14 @@ function enqueue(pluralKind, workItem, queue, compute, syncCtl, retryCtl) {
         success: () => retryCtl.successReconciling(informer_itemPath(pluralKind, workItem.item)),
     };
     workItem.process = async function* (item, operation, handler) {
-        const needsUpdateSyncContidions = operation === OperationType.RENAMED ||
-            operation === OperationType.UPDATED ||
-            operation === OperationType.SYNC ||
-            operation === OperationType.CREATED ||
-            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');
+        if (operation === OperationType.RENAMED ||
+            operation === OperationType.UPDATED ||
+            operation === OperationType.SYNC ||
+            operation === OperationType.CREATED ||
+            operation === OperationType.RETRY) {
             syncCtl.updateItem(informer_itemPath(pluralKind, item));
         }
         else {
@@ -372166,6 +371794,13 @@ 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/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, generateDefaults: 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, 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 } from 'cdk8s_renderer';
+import { ImportInitializer, UUIDInitializer, NameNormalizer, InitializerClaimRef, InitializerDefault } from 'cdk8s_renderer';
 export default class Decanter {
     data: any;
     claimKind: string | undefined;
@@ -78,4 +78,5 @@ 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,9 +1,8 @@
 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<InitializerDefault>;
+    __adaptInitializerBase(_claim: any): Promise<import("../../../../cdk8s_renderer").InitializerDefault>;
 }

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

@@ -1,4 +1,2 @@
 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/package.json

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

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

@@ -1,26 +0,0 @@
-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>;