@kapeta/local-cluster-service 0.54.12 → 0.55.1

package/CHANGELOG.md

@@ -1,3 +1,25 @@
+## [0.55.1](https://github.com/kapetacom/local-cluster-service/compare/v0.55.0...v0.55.1) (2024-07-12)
+
+
+### Bug Fixes
+
+* include full path for files in cloned predefined source ([dba3151](https://github.com/kapetacom/local-cluster-service/commit/dba3151ab365281396ee8b3c9e0dd1f44f88b3f6))
+* more tests ([6c61030](https://github.com/kapetacom/local-cluster-service/commit/6c61030c243dc2d23da257b587ab4dfe2e2966f4))
+
+# [0.55.0](https://github.com/kapetacom/local-cluster-service/compare/v0.54.12...v0.55.0) (2024-07-11)
+
+
+### Bug Fixes
+
+* change test ([218f7d0](https://github.com/kapetacom/local-cluster-service/commit/218f7d0b485a5d045b59d52956fed9e09ed6e243))
+* license ([0d3ff1b](https://github.com/kapetacom/local-cluster-service/commit/0d3ff1b4a6377fb874a1183465ff59bbca7ccae1))
+* review comments ([094a5db](https://github.com/kapetacom/local-cluster-service/commit/094a5db73a70740cd7cddced0c9ff2094a723018))
+
+
+### Features
+
+* support archetypes/predefined blocks in event parsing/codegen ([7929413](https://github.com/kapetacom/local-cluster-service/commit/7929413b90e901e7960be46efc5a1b3473935ddd))
+
 ## [0.54.12](https://github.com/kapetacom/local-cluster-service/compare/v0.54.11...v0.54.12) (2024-07-10)
 
 

package/definitions.d.ts

@@ -37,3 +37,14 @@ declare module '@kapeta/nodejs-registry-utils' {
         YAMLHandler: ArtifactHandlerFactory;
     };
 }
+
+declare module 'download-git-repo' {
+    function download(
+        url: string,
+        dest: string,
+        opts?: RequestOptions & { clone?: boolean },
+        callback?: RequestCallback
+    ): void;
+
+    export = download;
+}

package/dist/cjs/src/storm/archetype.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+import { PredefinedBlock } from './predefined';
+import { GeneratedResult } from '@kapeta/codegen';
+export declare class Archetype {
+    cloneRepository(predefinedBlock: PredefinedBlock, targetDir: string, basePath: string): Promise<GeneratedResult>;
+    private copyToBasePathAndRemoveDownload;
+    private convertToGeneratedResult;
+    private downloadRepo;
+}

package/dist/cjs/src/storm/archetype.js

@@ -0,0 +1,98 @@
+"use strict";
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Archetype = void 0;
+const download_git_repo_1 = __importDefault(require("download-git-repo"));
+const fs = __importStar(require("node:fs"));
+const path_1 = __importDefault(require("path"));
+class Archetype {
+    async cloneRepository(predefinedBlock, targetDir, basePath) {
+        const downloadDirectory = `${targetDir}/download`;
+        await this.downloadRepo(predefinedBlock.getGitRepo().owner + '/' + predefinedBlock.getGitRepo().repo, downloadDirectory);
+        await this.copyToBasePathAndRemoveDownload(downloadDirectory, predefinedBlock.getGitRepo().path, basePath);
+        return this.convertToGeneratedResult(basePath);
+    }
+    async copyToBasePathAndRemoveDownload(downloadDirectory, subPath, targetDir) {
+        const fullSourcePath = path_1.default.resolve(`${downloadDirectory}/${subPath}`);
+        const fullDestinationPath = path_1.default.resolve(targetDir);
+        try {
+            await fs.promises.cp(fullSourcePath, fullDestinationPath, { recursive: true });
+            console.log(`Directory copied: ${fullSourcePath} -> ${fullDestinationPath}`);
+        }
+        catch (err) {
+            console.error(`Error copying directory: ${err}`);
+        }
+        finally {
+            await fs.promises.rm(downloadDirectory, { recursive: true, force: true });
+        }
+    }
+    async convertToGeneratedResult(basePath) {
+        const generatedFiles = [];
+        async function traverse(currentPath, basePath) {
+            const files = await fs.promises.readdir(currentPath, { withFileTypes: true });
+            for (const file of files) {
+                const fullPath = path_1.default.join(currentPath, file.name);
+                if (file.isFile()) {
+                    const stats = await fs.promises.stat(fullPath);
+                    const mode = stats.mode.toString(8);
+                    const permissions = stats.mode.toString(8).slice(-3);
+                    const content = await fs.promises.readFile(fullPath);
+                    const generatedFile = {
+                        filename: fullPath.replace(basePath + '/', ''),
+                        content: content.toString(),
+                        mode: mode,
+                        permissions: permissions,
+                    };
+                    generatedFiles.push(generatedFile);
+                }
+                else if (file.isDirectory()) {
+                    await traverse(fullPath, basePath);
+                }
+            }
+        }
+        await traverse(basePath, basePath);
+        return { files: generatedFiles };
+    }
+    downloadRepo(url, dest) {
+        return new Promise((resolve, reject) => {
+            (0, download_git_repo_1.default)(url, dest, function (err) {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    }
+}
+exports.Archetype = Archetype;

package/dist/cjs/src/storm/codegen.d.ts

@@ -26,6 +26,7 @@ export declare class StormCodegen {
      * Generates the code for a block and sends it to the AI
      */
     private processBlockCode;
+    private emitBlockStatusDone;
     private emitBlockStatus;
     private verifyAndFixCode;
     private tryToFixFile;
@@ -55,5 +56,6 @@ export declare class StormCodegen {
      * Generates the code using codegen for a given block.
      */
     private generateBlock;
+    private cloneArchetype;
     abort(): void;
 }

package/dist/cjs/src/storm/codegen.js

@@ -44,6 +44,9 @@ const path_2 = __importStar(require("path"));
 const node_os_1 = __importDefault(require("node:os"));
 const fs_1 = require("fs");
 const yaml_1 = __importDefault(require("yaml"));
+const predefined_1 = require("./predefined");
+const archetype_1 = require("./archetype");
+const lodash_1 = __importDefault(require("lodash"));
 const SIMULATED_DELAY = 1000;
 const ENABLE_SIMULATED_DELAY = false;
 class SimulatedFileDelay {
@@ -106,7 +109,12 @@ class StormCodegen {
     }
     async process() {
         const promises = this.blocks.map((block) => {
-            return this.processBlockCode(block);
+            if (block.archetype) {
+                return this.cloneArchetype(block);
+            }
+            else {
+                return this.processBlockCode(block);
+            }
         });
         await Promise.all(promises);
         this.out.end();
@@ -391,11 +399,14 @@ class StormCodegen {
         const blockRef = block.uri;
         this.emitBlockStatus(blockUri, block.aiName, events_1.StormEventBlockStatusType.QA);
         /* TODO: temporarily disabled - enable again when codegen is more stable
-                        const filesToBeFixed = serviceFiles.concat(contextFiles).concat(screenFilesConverted);
-                        const codeGenerator = new BlockCodeGenerator(blockDefinition);
-        */
+                const filesToBeFixed = serviceFiles.concat(contextFiles).concat(screenFilesConverted);
+                const codeGenerator = new BlockCodeGenerator(blockDefinition);
+*/
         this.emitBlockStatus(blockUri, block.aiName, events_1.StormEventBlockStatusType.BUILDING);
         //        await this.verifyAndFixCode(blockUri, block.aiName, codeGenerator, basePath, filesToBeFixed, allFiles);
+        this.emitBlockStatusDone(basePath, block, blockRef);
+    }
+    emitBlockStatusDone(basePath, block, blockRef) {
         this.out.emit('data', {
             type: 'BLOCK_READY',
             reason: 'Block ready',
@@ -784,6 +795,19 @@ class StormCodegen {
         new codegen_1.CodeWriter(basePath).write(generatedResult);
         return generatedResult;
     }
+    async cloneArchetype(block) {
+        const predefinedBlock = predefined_1.PREDEFINED_BLOCKS.get(block.archetype);
+        let blockDefinition = await predefinedBlock.getBlockDefinition();
+        const kapetaURI = new nodejs_utils_1.KapetaURI(block.uri);
+        lodash_1.default.set(blockDefinition, ['metadata', 'name'], kapetaURI.fullName);
+        lodash_1.default.set(blockDefinition, ['metadata', 'title'], kapetaURI.name);
+        const basePath = this.getBasePath(blockDefinition.metadata.name);
+        let archetype = new archetype_1.Archetype();
+        const generatedResult = await archetype.cloneRepository(predefinedBlock, this.tmpDir, basePath);
+        await this.emitStaticFiles(kapetaURI, block.aiName, this.toStormFiles(generatedResult));
+        const blockRef = block.uri;
+        this.emitBlockStatusDone(basePath, block, blockRef);
+    }
     abort() {
         this.out.abort();
     }

package/dist/cjs/src/storm/event-parser.d.ts

@@ -9,6 +9,7 @@ export interface BlockDefinitionInfo {
     uri: string;
     content: BlockDefinition;
     aiName: string;
+    archetype?: string;
 }
 export interface StormDefinitions {
     plan: Plan;
@@ -61,18 +62,20 @@ export declare class StormEventParser {
     /**
      * Builds plan and block definitions - and enriches events with relevant refs and ids
      */
-    processEvent(handle: string, evt: StormEvent): StormDefinitions;
+    processEvent(handle: string, evt: StormEvent): Promise<StormDefinitions>;
     getEvents(): StormEvent[];
     isValid(): boolean;
     getError(): string;
-    toResult(handle: string): StormDefinitions;
-    toBlockDefinitions(handle: string): {
+    toResult(handle: string): Promise<StormDefinitions>;
+    toBlockDefinitions(handle: string): Promise<{
         [key: string]: BlockDefinitionInfo;
-    };
+    }>;
+    private createBlockDefinitionInfo;
     private toResourceKind;
     private toBlockKind;
     private toConnectionMapping;
     private toPortType;
     private toBlockTarget;
     private toBlockTargetKind;
+    private resolveArchetypeBlockDefinition;
 }