@firestartr/cli 1.43.2-snapshot-6 → 1.43.2-snapshot-8

package/build/index.js

@@ -165787,7 +165787,7 @@ const Comparator = __nccwpck_require__(14435)
 const Range = __nccwpck_require__(34189)
 const satisfies = __nccwpck_require__(74432)
 const toComparators = __nccwpck_require__(90453)
-const maxSatisfying = __nccwpck_require__(49939)
+const maxSatisfying = __nccwpck_require__(46253)
 const minSatisfying = __nccwpck_require__(59276)
 const minVersion = __nccwpck_require__(97241)
 const validRange = __nccwpck_require__(65493)
@@ -166213,7 +166213,7 @@ module.exports = ltr
 
 /***/ }),
 
-/***/ 49939:
+/***/ 46253:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 const SemVer = __nccwpck_require__(87048)
@@ -281289,6 +281289,12 @@ class FirestartrAllClaim {
                             type: 'string',
                             enum: ['private', 'public', 'internal'],
                         },
+                        features: {
+                            type: 'array',
+                            items: {
+                                $ref: 'firestartr.dev://github/GithubComponentFeatureClaim',
+                            },
+                        },
                     },
                     required: ['visibility', 'org'],
                 },
@@ -281349,14 +281355,58 @@ 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,
 ];
@@ -284112,59 +284162,83 @@ 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: ../features_preparer/src/installer.ts
+;// 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);
+        await (0,promises_namespaceObject.writeFile)(filePath, stream);
+    }
+    catch (err) {
+        throw new Error(`Downloading feature's zip: ${err.message}`);
+    }
+}
 
+;// CONCATENATED MODULE: ../features_preparer/src/installer.ts
 
 
 
 
-//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 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);
+}
 async function getFeatureConfig(featureName, version, featureOwner, // -> cr
 featureArgs = {}, repo = 'features', owner = 'prefapp') {
-    await downloadFeatureZip(repo, featureName, version, owner);
-    const ref = buildRef(featureName, version);
+    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);
     featureArgs['traceability'] = {
-        version,
+        version: reference,
         owner,
         repo,
         name: featureName,
-        ref,
-        url: `https://github.com/${owner}/${repo}/tree/${ref}/packages/${featureName}`,
+        ref: reference,
+        url: `https://github.com/${owner}/${repo}/tree/${reference}/packages/${featureName}`,
     };
-    return renderFeature(featureName, version, featureOwner, '/tmp', featureArgs);
+    return renderFeature(featureName, reference, featureOwner, '/tmp', featureArgs);
 }
 async function prepareFeature(featureName, version, repo = 'features', owner = 'prefapp') {
     await downloadFeatureZip(repo, featureName, version, owner);
 }
-async function downloadFeatureZip(repo, featureName, version, owner = 'prefapp') {
+async function downloadFeatureZip(repo, featureName, reference, owner = 'prefapp') {
     try {
-        const ref = buildRef(featureName, version);
         const octokit = await github_0.getOctokitForOrg(owner);
-        const zipballExtractPath = catalog_common.features.tarballs.getFeaturesExtractPath(featureName, version, { createIfNotExists: true });
+        const zipballExtractPath = catalog_common.features.tarballs.getFeaturesExtractPath(featureName, reference, { 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/{ref}', {
+        const response = await octokit.request('GET /repos/{owner}/{repo}/zipball/{reference}', {
             request: {
                 parseSuccessResponseBody: false,
             },
             owner,
             repo,
-            ref,
+            reference,
         });
         const randomZipTmpPath = `/tmp/${catalog_common.generic.randomString(20)}.zip`;
-        console.log(`Downloading feature ${featureName} version ${version} to ${randomZipTmpPath}`);
+        console.log(`Downloading feature ${featureName} version ${reference} 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 ${version} to ${randomExtractPath}`);
+        console.log(`Extracting feature ${featureName} version ${reference} to ${randomExtractPath}`);
         external_fs_.rmSync(randomExtractPath, { recursive: true, force: true });
         await downloadZipBall(response.url, randomZipTmpPath);
         const zip = new (adm_zip_default())(randomZipTmpPath);
@@ -284180,30 +284254,11 @@ async function downloadFeatureZip(repo, featureName, version, owner = 'prefapp')
     }
     catch (error) {
         console.error(error);
-        throw new Error(`Error for feature with tag ${featureName}-v${version}: ${error}. GitHub response: ${error}`);
-    }
-}
-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);
-        await (0,promises_namespaceObject.writeFile)(filePath, stream);
-    }
-    catch (err) {
-        throw new Error(`Downloading feature's zip: ${err.message}`);
+        throw new Error(`Error for feature with tag ${reference}: ${error}. GitHub response: ${error}`);
     }
 }
 function buildRef(featureName, version) {
-    if (IS_SEMVER_REF.test(version)) {
-        return `${featureName}-v${version}`;
-    }
-    else {
-        return `${version}`;
-    }
+    return `${featureName}-v${version}`;
 }
 
 ;// CONCATENATED MODULE: ../features_preparer/src/index.ts
@@ -284211,6 +284266,7 @@ function buildRef(featureName, version) {
 
 /* harmony default export */ const features_preparer_src = ({
     renderFeature: renderFeature,
+    getFeatureConfigFromRef: getFeatureConfigFromRef,
     getFeatureConfig: getFeatureConfig,
     prepareFeature: prepareFeature,
 });
@@ -284222,6 +284278,7 @@ function buildRef(featureName, version) {
     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
@@ -284266,13 +284323,17 @@ async function utils_renderFeature(featureName, featureVersion, featureOutputObj
 
 
 class FeaturesOverrider extends OverriderPatches {
-    constructor(featureName, featureVersion, featureConfig, featureArgs) {
+    constructor(featureName, featureVersion, featureConfig, featureArgs, featureRef, featureRepo) {
         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;
         }
@@ -284280,7 +284341,21 @@ class FeaturesOverrider extends OverriderPatches {
     getFeatureConfig(cr) {
         if (this.featureConfig)
             return this.featureConfig;
-        return features_preparer.getFeatureConfig(this.featureName, this.featureVersion, this.featureArgs, cr, 'features', 'prefapp');
+        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, this.featureArgs, cr, repo, owner);
     }
     async __validate() {
         return true;
@@ -284289,6 +284364,9 @@ class FeaturesOverrider extends OverriderPatches {
         const featureName = this.featureName;
         const featureVersion = this.featureVersion;
         const featureArgs = this.featureArgs;
+        const fSetUpAndRunRenderer = function (cr) {
+            return this.setUpAndRunRenderer(cr);
+        }.bind(this);
         let renderedFeatureConfig = null;
         return [
             {
@@ -284296,7 +284374,7 @@ class FeaturesOverrider extends OverriderPatches {
                     return true;
                 },
                 async apply(cr) {
-                    renderedFeatureConfig = await features_preparer.getFeatureConfig(featureName, featureVersion, cr, featureArgs, 'features', 'prefapp');
+                    renderedFeatureConfig = await fSetUpAndRunRenderer(cr);
                     return cr;
                 },
                 identify() {
@@ -284342,7 +284420,7 @@ async function generateFeaturesPatches(claim) {
     return patches;
 }
 async function createRenderFeaturePatch(claim, feature) {
-    const featureOverrider = new FeaturesOverrider(feature.name, feature.version, false, feature.args);
+    const featureOverrider = new FeaturesOverrider(feature.name, feature.version, false, feature.args, feature.ref, feature.repo);
     return featureOverrider.patches(claim, null);
 }
 

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

@@ -343,6 +343,47 @@ 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;
@@ -367,6 +408,12 @@ 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,6 +22,12 @@ 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/feature.schema.d.ts

@@ -0,0 +1,43 @@
+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/cdk8s_renderer/src/claims/github/index.d.ts

@@ -59,6 +59,47 @@ 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;
@@ -83,6 +124,12 @@ 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,7 +13,9 @@ export interface IGithubRepositoryFeatureClaim extends IClaim {
     context: any;
     feature: {
         name: string;
-        version: string;
+        version?: string;
+        ref?: string;
+        repo?: string;
     };
     repositoryTarget: FirestartrGithubRepositoryFeatureSpecRepositoryTarget;
     files: Array<IGithubRepositoryFeatureFileClaim>;

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

@@ -5,8 +5,11 @@ export declare class FeaturesOverrider extends OverriderPatches {
     private featureVersion;
     private featureConfig;
     private featureArgs;
-    constructor(featureName: string, featureVersion: string, featureConfig?: any, featureArgs?: any);
+    private featureRepo;
+    private featureRef;
+    constructor(featureName: string, featureVersion: string, featureConfig?: any, featureArgs?: any, featureRef?: string, featureRepo?: string);
     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,5 +3,6 @@ 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,7 +1,8 @@
-import { getFeatureConfig, prepareFeature } from './installer';
+import { getFeatureConfigFromRef, 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,4 +1,6 @@
+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, version: string, owner?: string): Promise<string>;
+export declare function downloadFeatureZip(repo: string, featureName: string, reference: string, owner?: string): Promise<string>;

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

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

package/package.json

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