@firestartr/cli 1.43.1 → 1.43.2-snapshot-2

package/build/index.js

@@ -271394,7 +271394,7 @@ function fromYaml(data) {
     return result;
 }
 function toYaml(data, opts = {}) {
-    messageLog('opts', opts);
+    console.log('opts', opts);
     const result = yaml_dist.stringify(data);
     return result;
 }
@@ -273032,20 +273032,20 @@ const fullMembersTeam = getFromEnvironmentWithDefault(envVars.fullOrgGroup, `${o
 
 const tarballs_messageLog = src_default()('firestartr:catalog_common:features:tarballs');
 function getFeatureZipDownloadPath(featureName, version) {
-    const featureDownloadPath = `/tmp/${featureName}-${version}-zipball.zip`;
-    tarballs_messageLog('Feature tarball download path %s', featureDownloadPath);
-    return featureDownloadPath;
+    const featureTarballDownloadPath = `/tmp/${featureName}-${version}-zipball.zip`;
+    tarballs_messageLog('Feature tarball download path %s', featureTarballDownloadPath);
+    return featureTarballDownloadPath;
 }
 function removeFeatureTarball(featureName, version) {
-    const featurePath = getFeatureZipDownloadPath(featureName, version);
-    tarballs_messageLog('Removing feature tarball %s', featurePath);
-    external_fs_.unlinkSync(featurePath);
-    tarballs_messageLog(`Removed tarball for feature ${featureName} and version ${version}: ${featurePath}`);
+    const tarballPath = getFeatureZipDownloadPath(featureName, version);
+    tarballs_messageLog('Removing feature tarball %s', tarballPath);
+    external_fs_.unlinkSync(tarballPath);
+    tarballs_messageLog(`Removed tarball for feature ${featureName} and version ${version}: ${tarballPath}`);
 }
 function featureTarballExists(featureName, version) {
-    const featurePath = getFeatureZipDownloadPath(featureName, version);
-    const exists = external_fs_.existsSync(featurePath);
-    tarballs_messageLog(`Tarball ${featurePath} exists? ${exists}`);
+    const tarballPath = getFeatureZipDownloadPath(featureName, version);
+    const exists = external_fs_.existsSync(tarballPath);
+    tarballs_messageLog(`Tarball ${tarballPath} exists? ${exists}`);
     return exists;
 }
 function getFeaturesExtractPath(featureName, version, options = {}) {
@@ -281289,12 +281289,6 @@ class FirestartrAllClaim {
                             type: 'string',
                             enum: ['private', 'public', 'internal'],
                         },
-                        features: {
-                            type: 'array',
-                            items: {
-                                $ref: 'firestartr.dev://github/GithubComponentFeatureClaim',
-                            },
-                        },
                     },
                     required: ['visibility', 'org'],
                 },
@@ -281355,58 +281349,14 @@ class FirestartrAllClaim {
     },
 });
 
-;// CONCATENATED MODULE: ../cdk8s_renderer/src/claims/github/feature.schema.ts
-/* harmony default export */ const feature_schema = ({
-    $schema: 'http://json-schema.org/draft-07/schema#',
-    $id: 'GithubComponentFeatureClaim',
-    definitions: {
-        GithubComponentFeatureClaim: {
-            $id: 'firestartr.dev://github/GithubComponentFeatureClaim',
-            description: 'A feature for a GithubComponentClaim',
-            properties: {
-                name: {
-                    type: 'string',
-                    description: 'The name of the feature',
-                },
-                version: {
-                    type: 'string',
-                    description: 'The semver of the feature',
-                },
-                ref: {
-                    type: 'string',
-                    description: 'A github reference (commit, tag, branch)',
-                },
-                args: {
-                    type: 'object',
-                    properties: {},
-                    additionalProperties: true,
-                },
-                repo: {
-                    type: 'string',
-                    description: 'A repo where the feature exists, format: owner/repository',
-                    pattern: '^[a-zA-Z0-9-._]+/[a-zA-Z0-9-._]+$',
-                },
-            },
-            required: ['name'],
-            oneOf: [
-                { required: ['ref'], not: { required: ['version'] } },
-                { required: ['version'], not: { required: ['ref'] } },
-            ],
-            additionalProperties: false,
-        },
-    },
-});
-
 ;// CONCATENATED MODULE: ../cdk8s_renderer/src/claims/github/index.ts
 
 
 
 
-
 const GithubSchemas = [
     github_group_schema,
     github_user_schema,
-    feature_schema,
     github_component_schema,
     github_orgwebhook_schema,
 ];
@@ -281858,9 +281808,6 @@ const deploy_schema = 'firestartr.dev://common/ArgoDeployClaim';
 ;// CONCATENATED MODULE: ../cdk8s_renderer/src/claims/base/orgWebhook.ts
 const orgWebhook_schema = 'firestartr.dev://common/OrgWebhookClaim';
 
-;// CONCATENATED MODULE: ../cdk8s_renderer/src/claims/base/secrets.ts
-const base_secrets_schema = 'firestartr.dev://common/SecretsClaim';
-
 ;// CONCATENATED MODULE: ../cdk8s_renderer/src/claims/base/index.ts
 
 
@@ -281870,7 +281817,6 @@ const base_secrets_schema = 'firestartr.dev://common/SecretsClaim';
 
 
 
-
 /* harmony default export */ const base = ({
     UserClaimSchema: schema,
     GroupClaimSchema: base_group_schema,
@@ -281880,7 +281826,6 @@ const base_secrets_schema = 'firestartr.dev://common/SecretsClaim';
     TFWorkspaceClaimSchema: workspace_schema,
     ArgoDeployClaimSchema: deploy_schema,
     OrgWebhookClaimSchema: orgWebhook_schema,
-    SecretsClaimSchema: base_secrets_schema,
 });
 
 ;// CONCATENATED MODULE: ../cdk8s_renderer/src/normalizers/refValues.ts
@@ -282290,58 +282235,36 @@ const external_node_child_process_namespaceObject = __WEBPACK_EXTERNAL_createReq
 
 
 
-
-
-
-
 const lazy_loader_log = src_default()('firestartr:renderer:lazy_loader');
-async function loadClaim(claimRef, org, defaults = loadClaimDefaults(), patchClaim = loader_patchClaim, loadInitializers, loadGlobals, loadOverrides, loadNormalizers, cwd, existingRefs = {}) {
+async function loadClaim(claimRef, org, defaults, patchClaim, loadInitializers, loadGlobals, loadOverrides, loadNormalizers, cwd, existingRefs = {}) {
     let result = existingRefs;
     lazy_loader_log(`Load reference ${claimRef}`);
     initVirtualClaims(org);
     lazy_loader_log(`Load reference (parts) ${claimRef.split(/-/)[0]} ${claimRef.replace(/^[^-]+-/, '')}`);
     // cargas datos con grep
-    try {
-        const claimData = await lazyGetClaim(claimRef.split(/-/)[0], claimRef.replace(/^[^-]+-/, ''), org, cwd);
-        const claim = patchClaim(catalog_common.io.fromYaml(claimData), defaults);
-        try {
-            validateClaim(claim, base[`${claim.kind}Schema`]);
-            await optionalValidation(claim);
-        }
-        catch (error) {
-            let errorMsg = '';
-            for (const data of error) {
-                errorMsg = `${errorMsg}
-- ${data.dataPath}: ${data.message}`;
-            }
-            throw new Error(`Error when validating claim ${claimRef}: ${errorMsg}`);
-        }
-        result[claimRef] = {};
-        result[claimRef]['claim'] = claim;
-        result[claimRef]['claimPath'] = VisitedClaims[claimRef];
-        if (VisitedClaims[claimRef] === 'virtual') {
-            result = await setVirtualClaimAdditionalData(result, claim, claimRef);
-        }
-        else {
-            result = await setNonVirtualClaimAdditionalData(result, claim, claimRef, loadInitializers, loadGlobals, loadOverrides, loadNormalizers);
-        }
-        const claimKind = claim.kind;
-        const references = extractAllRefs(catalog_common.io.toYaml(claim));
-        for (const ref of references) {
-            if (!result[ref]) {
-                const resolvedReferences = await loadClaim(ref, org, defaults, patchClaim, loadInitializers, loadGlobals, loadOverrides, loadNormalizers, cwd, result);
-                result = lodash_default().merge(result, resolvedReferences);
-            }
-        }
+    const claimData = await lazyGetClaim(claimRef.split(/-/)[0], claimRef.replace(/^[^-]+-/, ''), org, cwd);
+    const claim = patchClaim(catalog_common.io.fromYaml(claimData), defaults);
+    result[claimRef] = {};
+    result[claimRef]['claim'] = claim;
+    result[claimRef]['claimPath'] = VisitedClaims[claimRef];
+    if (VisitedClaims[claimRef] === 'virtual') {
+        result = await setVirtualClaimAdditionalData(result, claim, claimRef);
     }
-    catch (err) {
-        throw `Lazy Loading: ${err}`;
+    else {
+        result = await setNonVirtualClaimAdditionalData(result, claim, claimRef, loadInitializers, loadGlobals, loadOverrides, loadNormalizers);
+    }
+    const claimKind = claim.kind;
+    const references = extractAllRefs(catalog_common.io.toYaml(claim));
+    for (const ref of references) {
+        if (!result[ref]) {
+            const resolvedReferences = await loadClaim(ref, org, defaults, patchClaim, loadInitializers, loadGlobals, loadOverrides, loadNormalizers, cwd, result);
+            result = lodash_default().merge(result, resolvedReferences);
+        }
     }
     return result;
 }
 const LoadedClaims = {};
 const VisitedClaims = {};
-const DuplicatedClaims = {};
 async function lazyGetClaim(kind, name, org, cwd) {
     const indice = `${kind}-${name}`;
     lazy_loader_log(`Lazy loading ${kind}-${name} with index ${indice}`);
@@ -282384,14 +282307,14 @@ async function getClaimsByName(name, cwd = '.') {
             }
         });
         handler.on('close', () => {
-            return Promise.all(entradas.map((entrada) => {
+            Promise.all(entradas.map((entrada) => {
                 return loadRawClaim(entrada);
             }))
                 .then(() => {
                 ok();
             })
-                .catch((err) => {
-                ko(err);
+                .catch(() => {
+                ko();
             });
         });
     });
@@ -282405,17 +282328,9 @@ async function loadRawClaim(entry) {
             if (!('kind' in claim && 'name' in claim)) {
                 lazy_loader_log(`Invalid claim file ${entry}`);
             }
-            else {
-                const claimKey = `${claim.kind}-${claim.name}`;
-                if (Object.keys(DuplicatedClaims).includes(claimKey) &&
-                    DuplicatedClaims[claimKey] !== entry) {
-                    return ko(`Duplicated claim ${claimKey} found files: ${DuplicatedClaims[claimKey]} and ${entry}`);
-                }
-                LoadedClaims[claimKey] = data;
-                VisitedClaims[claimKey] = entry;
-                DuplicatedClaims[claimKey] = entry;
-                ok();
-            }
+            LoadedClaims[`${claim.kind}-${claim.name}`] = data;
+            VisitedClaims[`${claim.kind}-${claim.name}`] = entry;
+            ok();
         });
     });
 }
@@ -282637,7 +282552,7 @@ async function loadClaims(claimsPath = config_getPath('claims')) {
     await crawler_crawl(claimsPath, (entry) => {
         return isYamlFile.test(entry);
     }, async (entry, data) => {
-        const claim = loader_patchClaim(catalog_common.io.fromYaml(data), defaultsClaims);
+        const claim = patchClaim(catalog_common.io.fromYaml(data), defaultsClaims);
         if (!('kind' in claim && 'name' in claim)) {
             throw new Error(`Invalid claim file ${entry}`);
         }
@@ -282674,7 +282589,7 @@ function loadClaimDefaults() {
  * - The patched claim
  *
  */
-function loader_patchClaim(claim, defaultsClaims) {
+function patchClaim(claim, defaultsClaims) {
     if (defaultsClaims[claim.kind]) {
         const jsonPatchOps = fast_json_patch.compare(claim, defaultsClaims[claim.kind])
             .filter((jp) => {
@@ -282818,7 +282733,7 @@ async function loadClaimsList(claimRefList, claimsPath = config_getPath('claims'
     };
     const defaults = loadClaimDefaults();
     for (const claimRef of claimRefList) {
-        const renderedClaimData = await loadClaim(claimRef, getOrg(), defaults, loader_patchClaim, loadInitializers, loadGlobals, loadOverrides, loadNormalizers, claimsPath);
+        const renderedClaimData = await loadClaim(claimRef, getOrg(), defaults, patchClaim, loadInitializers, loadGlobals, loadOverrides, loadNormalizers, claimsPath);
         data.renderClaims = lodash_default().merge(data.renderClaims, renderedClaimData);
     }
     const crClaimReferences = [];
@@ -284195,91 +284110,59 @@ function renderFeature(featureName, version, featureOwner, renderPath = '/tmp',
 // EXTERNAL MODULE: ../../node_modules/adm-zip/adm-zip.js
 var adm_zip = __nccwpck_require__(7993);
 var adm_zip_default = /*#__PURE__*/__nccwpck_require__.n(adm_zip);
-// EXTERNAL MODULE: external "node:stream"
-var external_node_stream_ = __nccwpck_require__(84492);
-;// CONCATENATED MODULE: external "node:stream/promises"
-const external_node_stream_promises_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:stream/promises");
-;// CONCATENATED MODULE: ../features_preparer/src/zip.ts
-
-
-
-async function downloadZipBall(url, filePath) {
-    try {
-        const zipResponse = await fetch(url);
-        if (!zipResponse.ok) {
-            throw new Error(`Failed to download ZIP: ${zipResponse.statusText}`);
-        }
-        const webStream = zipResponse.body;
-        const stream = external_node_stream_.Readable.fromWeb(webStream);
-        const writableStream = external_fs_.createWriteStream(filePath);
-        await (0,external_node_stream_promises_namespaceObject.pipeline)(stream, writableStream);
-    }
-    catch (err) {
-        throw new Error(`Downloading feature's zip: ${err.message}`);
-    }
-}
-
 ;// CONCATENATED MODULE: ../features_preparer/src/installer.ts
 
 
 
 
 
-
-async function getFeatureConfigFromRef(featureName, featureRef, featureOwner, // -> cr
-featureArgs = {}, repo = 'features', owner = 'prefapp') {
-    // reference is the featureRef directly
-    const reference = `${featureRef}`;
-    return processFeature(featureName, reference, featureOwner, featureArgs, repo, owner);
-}
+//const IS_COMMIT_REF = new RegExp(/\b[0-9a-f]{40}/g);
+const IS_SEMVER_REF = new RegExp(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([\da-zA-Z-]+(?:\.[\da-zA-Z-]+)*))?(?:\+([\da-zA-Z-]+(?:\.[\da-zA-Z-]+)*))?$/);
 async function getFeatureConfig(featureName, version, featureOwner, // -> cr
 featureArgs = {}, repo = 'features', owner = 'prefapp') {
-    const reference = `${featureName}-v${version}`;
-    return processFeature(featureName, reference, featureOwner, featureArgs, repo, owner);
-}
-async function processFeature(featureName, reference, featureOwner, // -> cr
-featureArgs = {}, repo = 'features', owner = 'prefapp') {
-    await downloadFeatureZip(repo, featureName, reference, owner);
+    await downloadFeatureZip(repo, featureName, version, owner);
+    const ref = buildRef(featureName, version);
     featureArgs['traceability'] = {
-        version: reference,
+        version,
         owner,
         repo,
         name: featureName,
-        ref: reference,
-        url: `https://github.com/${owner}/${repo}/tree/${reference}/packages/${featureName}`,
+        ref,
+        url: `https://github.com/${owner}/${repo}/tree/${ref}/packages/${featureName}`,
     };
-    return renderFeature(featureName, reference, featureOwner, '/tmp', featureArgs);
+    return renderFeature(featureName, version, featureOwner, '/tmp', featureArgs);
 }
 async function prepareFeature(featureName, version, repo = 'features', owner = 'prefapp') {
     await downloadFeatureZip(repo, featureName, version, owner);
 }
-async function downloadFeatureZip(repo, featureName, reference, owner = 'prefapp') {
+async function downloadFeatureZip(repo, featureName, version, owner = 'prefapp') {
     try {
+        const ref = buildRef(featureName, version);
         const octokit = await github_0.getOctokitForOrg(owner);
-        const zipballExtractPath = catalog_common.features.tarballs.getFeaturesExtractPath(featureName, reference, { createIfNotExists: true });
+        const zipballExtractPath = catalog_common.features.tarballs.getFeaturesExtractPath(featureName, version, { createIfNotExists: true });
         console.log(`Zipball extract path: ${zipballExtractPath}`);
         if (external_fs_.existsSync(zipballExtractPath)) {
             console.log(`Zipball extract path ${zipballExtractPath} already exists, removing it.`);
             external_fs_.rmSync(zipballExtractPath, { recursive: true });
         }
-        const response = await octokit.request('GET /repos/{owner}/{repo}/zipball/{reference}', {
+        const response = await octokit.request('GET /repos/{owner}/{repo}/zipball/{ref}', {
             request: {
                 parseSuccessResponseBody: false,
             },
             owner,
             repo,
-            reference,
+            ref,
         });
         const randomZipTmpPath = `/tmp/${catalog_common.generic.randomString(20)}.zip`;
-        console.log(`Downloading feature ${featureName} version ${reference} to ${randomZipTmpPath}`);
+        console.log(`Downloading feature ${featureName} version ${version} to ${randomZipTmpPath}`);
         if (external_fs_.existsSync(randomZipTmpPath)) {
             console.log(`Temporary zip file ${randomZipTmpPath} already exists, removing it.`);
             external_fs_.unlinkSync(randomZipTmpPath);
         }
         const randomExtractPath = `/tmp/${catalog_common.generic.randomString(20)}`;
-        console.log(`Extracting feature ${featureName} version ${reference} to ${randomExtractPath}`);
-        external_fs_.rmSync(randomExtractPath, { recursive: true, force: true });
-        await downloadZipBall(response.url, randomZipTmpPath);
+        console.log(`Extracting feature ${featureName} version ${version} to ${randomExtractPath}`);
+        await response.data;
+        external_fs_.rmSync(randomZipTmpPath, { recursive: true, force: true });
         const zip = new (adm_zip_default())(randomZipTmpPath);
         const mainEntry = zip.getEntries()[0].entryName;
         console.log(`Main entry in zip: ${mainEntry}`);
@@ -284293,7 +284176,15 @@ async function downloadFeatureZip(repo, featureName, reference, owner = 'prefapp
     }
     catch (error) {
         console.error(error);
-        throw new Error(`Error for feature with tag ${reference}: ${error}. GitHub response: ${error}`);
+        throw new Error(`Error for feature with tag ${featureName}-v${version}: ${error}. GitHub response: ${error}`);
+    }
+}
+function buildRef(featureName, version) {
+    if (IS_SEMVER_REF.test(version)) {
+        return `${featureName}-v${version}`;
+    }
+    else {
+        return `${version}`;
     }
 }
 
@@ -284302,7 +284193,6 @@ async function downloadFeatureZip(repo, featureName, reference, owner = 'prefapp
 
 /* harmony default export */ const features_preparer_src = ({
     renderFeature: renderFeature,
-    getFeatureConfigFromRef: getFeatureConfigFromRef,
     getFeatureConfig: getFeatureConfig,
     prepareFeature: prepareFeature,
 });
@@ -284314,7 +284204,6 @@ async function downloadFeatureZip(repo, featureName, reference, owner = 'prefapp
     prepareFeature: features_preparer_src.prepareFeature,
     renderFeature: features_preparer_src.renderFeature,
     getFeatureConfig: features_preparer_src.getFeatureConfig,
-    getFeatureConfigFromRef: features_preparer_src.getFeatureConfigFromRef,
 });
 
 ;// CONCATENATED MODULE: ../cdk8s_renderer/src/overriders/utils.ts
@@ -284359,17 +284248,13 @@ async function utils_renderFeature(featureName, featureVersion, featureOutputObj
 
 
 class FeaturesOverrider extends OverriderPatches {
-    constructor(featureName, featureVersion, featureConfig, featureArgs, featureRef, featureRepo) {
+    constructor(featureName, featureVersion, featureConfig, featureArgs) {
         super();
         this.applicableProviders = ['github'];
         this.featureConfig = false;
-        this.featureRepo = '';
-        this.featureRef = '';
         this.featureName = featureName;
         this.featureVersion = featureVersion;
         this.featureArgs = featureArgs || {};
-        this.featureRef = featureRef || '';
-        this.featureRepo = featureRepo || '';
         if (featureConfig) {
             this.featureConfig = featureConfig;
         }
@@ -284377,32 +284262,15 @@ class FeaturesOverrider extends OverriderPatches {
     getFeatureConfig(cr) {
         if (this.featureConfig)
             return this.featureConfig;
-        return this.setUpAndRunRenderer(cr);
-    }
-    setUpAndRunRenderer(cr) {
-        let repo = 'features';
-        let owner = 'prefapp';
-        let versionOrRef = this.featureVersion;
-        let renderer = 'getFeatureConfig';
-        if (this.featureRepo) {
-            [owner, repo] = this.featureRepo.split(/\//);
-        }
-        if (this.featureRef) {
-            versionOrRef = this.featureRef;
-            renderer = 'getFeatureConfigFromRef';
-        }
-        return features_preparer[renderer](this.featureName, versionOrRef, cr, this.featureArgs, repo, owner);
+        return features_preparer.getFeatureConfig(this.featureName, this.featureVersion, this.featureArgs, cr, 'features', 'prefapp');
     }
     async __validate() {
         return true;
     }
     async __patches(claim, _previousCR) {
         const featureName = this.featureName;
-        const featureVersion = this.featureVersion || this.featureRef;
+        const featureVersion = this.featureVersion;
         const featureArgs = this.featureArgs;
-        const fSetUpAndRunRenderer = function (cr) {
-            return this.setUpAndRunRenderer(cr);
-        }.bind(this);
         let renderedFeatureConfig = null;
         return [
             {
@@ -284410,7 +284278,7 @@ class FeaturesOverrider extends OverriderPatches {
                     return true;
                 },
                 async apply(cr) {
-                    renderedFeatureConfig = await fSetUpAndRunRenderer(cr);
+                    renderedFeatureConfig = await features_preparer.getFeatureConfig(featureName, featureVersion, cr, featureArgs, 'features', 'prefapp');
                     return cr;
                 },
                 identify() {
@@ -284456,7 +284324,7 @@ async function generateFeaturesPatches(claim) {
     return patches;
 }
 async function createRenderFeaturePatch(claim, feature) {
-    const featureOverrider = new FeaturesOverrider(feature.name, feature.version, false, feature.args, feature.ref, feature.repo);
+    const featureOverrider = new FeaturesOverrider(feature.name, feature.version, false, feature.args);
     return featureOverrider.patches(claim, null);
 }
 

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

@@ -36,6 +36,5 @@ declare const _default: {
     TFWorkspaceClaimSchema: string;
     ArgoDeployClaimSchema: string;
     OrgWebhookClaimSchema: string;
-    SecretsClaimSchema: string;
 };
 export default _default;

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

@@ -343,47 +343,6 @@ declare const schemas: {
                 })[];
             };
         };
-    } | {
-        $schema: string;
-        $id: string;
-        definitions: {
-            GithubComponentFeatureClaim: {
-                $id: string;
-                description: string;
-                properties: {
-                    name: {
-                        type: string;
-                        description: string;
-                    };
-                    version: {
-                        type: string;
-                        description: string;
-                    };
-                    ref: {
-                        type: string;
-                        description: string;
-                    };
-                    args: {
-                        type: string;
-                        properties: {};
-                        additionalProperties: boolean;
-                    };
-                    repo: {
-                        type: string;
-                        description: string;
-                        pattern: string;
-                    };
-                };
-                required: string[];
-                oneOf: {
-                    required: string[];
-                    not: {
-                        required: string[];
-                    };
-                }[];
-                additionalProperties: boolean;
-            };
-        };
     } | {
         $schema: string;
         $id: string;
@@ -408,12 +367,6 @@ declare const schemas: {
                             type: string;
                             enum: string[];
                         };
-                        features: {
-                            type: string;
-                            items: {
-                                $ref: string;
-                            };
-                        };
                     };
                     required: string[];
                     $ref?: undefined;

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

@@ -22,12 +22,6 @@ declare const _default: {
                         type: string;
                         enum: string[];
                     };
-                    features: {
-                        type: string;
-                        items: {
-                            $ref: string;
-                        };
-                    };
                 };
                 required: string[];
                 $ref?: undefined;

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

@@ -59,47 +59,6 @@ export declare const GithubSchemas: ({
             })[];
         };
     };
-} | {
-    $schema: string;
-    $id: string;
-    definitions: {
-        GithubComponentFeatureClaim: {
-            $id: string;
-            description: string;
-            properties: {
-                name: {
-                    type: string;
-                    description: string;
-                };
-                version: {
-                    type: string;
-                    description: string;
-                };
-                ref: {
-                    type: string;
-                    description: string;
-                };
-                args: {
-                    type: string;
-                    properties: {};
-                    additionalProperties: boolean;
-                };
-                repo: {
-                    type: string;
-                    description: string;
-                    pattern: string;
-                };
-            };
-            required: string[];
-            oneOf: {
-                required: string[];
-                not: {
-                    required: string[];
-                };
-            }[];
-            additionalProperties: boolean;
-        };
-    };
 } | {
     $schema: string;
     $id: string;
@@ -124,12 +83,6 @@ export declare const GithubSchemas: ({
                         type: string;
                         enum: string[];
                     };
-                    features: {
-                        type: string;
-                        items: {
-                            $ref: string;
-                        };
-                    };
                 };
                 required: string[];
                 $ref?: undefined;

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

@@ -13,9 +13,7 @@ export interface IGithubRepositoryFeatureClaim extends IClaim {
     context: any;
     feature: {
         name: string;
-        version?: string;
-        ref?: string;
-        repo?: string;
+        version: string;
     };
     repositoryTarget: FirestartrGithubRepositoryFeatureSpecRepositoryTarget;
     files: Array<IGithubRepositoryFeatureFileClaim>;

package/build/packages/cdk8s_renderer/src/overriders/featureOverride.d.ts

@@ -5,11 +5,8 @@ export declare class FeaturesOverrider extends OverriderPatches {
     private featureVersion;
     private featureConfig;
     private featureArgs;
-    private featureRepo;
-    private featureRef;
-    constructor(featureName: string, featureVersion: string, featureConfig?: any, featureArgs?: any, featureRef?: string, featureRepo?: string);
+    constructor(featureName: string, featureVersion: string, featureConfig?: any, featureArgs?: any);
     getFeatureConfig(cr: any): any;
-    setUpAndRunRenderer(cr: any): any;
     __validate(): Promise<boolean>;
     __patches(claim: any, _previousCR: any): Promise<({
         validate(_cr: any): boolean;

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

@@ -3,6 +3,5 @@ declare const _default: {
     prepareFeature: typeof import("./src/installer").prepareFeature;
     renderFeature: typeof import("./src/renderer").renderFeature;
     getFeatureConfig: typeof import("./src/installer").getFeatureConfig;
-    getFeatureConfigFromRef: typeof import("./src/installer").getFeatureConfigFromRef;
 };
 export default _default;

package/build/packages/features_preparer/src/index.d.ts

@@ -1,8 +1,7 @@
-import { getFeatureConfigFromRef, getFeatureConfig, prepareFeature } from './installer';
+import { getFeatureConfig, prepareFeature } from './installer';
 import { renderFeature } from './renderer';
 declare const _default: {
     renderFeature: typeof renderFeature;
-    getFeatureConfigFromRef: typeof getFeatureConfigFromRef;
     getFeatureConfig: typeof getFeatureConfig;
     prepareFeature: typeof prepareFeature;
 };

package/build/packages/features_preparer/src/installer.d.ts

@@ -1,6 +1,4 @@
-export declare function getFeatureConfigFromRef(featureName: string, featureRef: string, featureOwner: any, // -> cr
-featureArgs?: any, repo?: string, owner?: string): Promise<any>;
 export declare function getFeatureConfig(featureName: string, version: string, featureOwner: any, // -> cr
 featureArgs?: any, repo?: string, owner?: string): Promise<any>;
 export declare function prepareFeature(featureName: string, version: string, repo?: string, owner?: string): Promise<void>;
-export declare function downloadFeatureZip(repo: string, featureName: string, reference: string, owner?: string): Promise<string>;
+export declare function downloadFeatureZip(repo: string, featureName: string, version: string, owner?: string): Promise<string>;

package/build/packages/github/src/branches.d.ts

@@ -428,7 +428,7 @@ export declare function getBranch(repo: string, branch: string, owner?: string):
                 verified_at: string;
             };
         };
-        author: {
+        author: Record<string, never> | {
             name?: string;
             email?: string;
             login: string;
@@ -451,8 +451,8 @@ export declare function getBranch(repo: string, branch: string, owner?: string):
             site_admin: boolean;
             starred_at?: string;
             user_view_type?: string;
-        } | Record<string, never>;
-        committer: {
+        };
+        committer: Record<string, never> | {
             name?: string;
             email?: string;
             login: string;
@@ -475,7 +475,7 @@ export declare function getBranch(repo: string, branch: string, owner?: string):
             site_admin: boolean;
             starred_at?: string;
             user_view_type?: string;
-        } | Record<string, never>;
+        };
         parents: {
             sha: string;
             url: string;

package/package.json

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

package/build/packages/cdk8s_renderer/src/claims/base/secrets.d.ts

@@ -1,9 +0,0 @@
-import { IClaim } from '../base';
-export interface ISecretsClaim extends IClaim {
-    type: string;
-    lifecycle: string;
-    system: string;
-    name: string;
-    providers: any;
-}
-export declare const schema = "firestartr.dev://common/SecretsClaim";

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

@@ -1,43 +0,0 @@
-declare const _default: {
-    $schema: string;
-    $id: string;
-    definitions: {
-        GithubComponentFeatureClaim: {
-            $id: string;
-            description: string;
-            properties: {
-                name: {
-                    type: string;
-                    description: string;
-                };
-                version: {
-                    type: string;
-                    description: string;
-                };
-                ref: {
-                    type: string;
-                    description: string;
-                };
-                args: {
-                    type: string;
-                    properties: {};
-                    additionalProperties: boolean;
-                };
-                repo: {
-                    type: string;
-                    description: string;
-                    pattern: string;
-                };
-            };
-            required: string[];
-            oneOf: {
-                required: string[];
-                not: {
-                    required: string[];
-                };
-            }[];
-            additionalProperties: boolean;
-        };
-    };
-};
-export default _default;

package/build/packages/features_preparer/src/zip.d.ts

@@ -1 +0,0 @@
-export declare function downloadZipBall(url: string, filePath: string): Promise<void>;