@kapeta/local-cluster-service 0.54.12 → 0.55.0

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+# [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) {
+            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: file.name,
+                        content: content.toString(),
+                        mode: mode,
+                        permissions: permissions,
+                    };
+                    generatedFiles.push(generatedFile);
+                }
+                else if (file.isDirectory()) {
+                    await traverse(fullPath);
+                }
+            }
+        }
+        await traverse(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;
 }

package/dist/cjs/src/storm/event-parser.js

@@ -3,12 +3,17 @@
  * Copyright 2023 Kapeta Inc.
  * SPDX-License-Identifier: BUSL-1.1
  */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StormEventParser = exports.resolveOptions = exports.createPhaseEvent = exports.createPhaseEndEvent = exports.createPhaseStartEvent = void 0;
 const nodejs_utils_1 = require("@kapeta/nodejs-utils");
 const kaplang_core_1 = require("@kapeta/kaplang-core");
 const uuid_1 = require("uuid");
 const definitionsManager_1 = require("../definitionsManager");
+const predefined_1 = require("./predefined");
+const lodash_1 = __importDefault(require("lodash"));
 function prettifyKaplang(source) {
     if (!source || !source.trim()) {
         return '';
@@ -156,7 +161,7 @@ class StormEventParser {
     /**
      * Builds plan and block definitions - and enriches events with relevant refs and ids
      */
-    processEvent(handle, evt) {
+    async processEvent(handle, evt) {
         let blockInfo;
         this.events.push(evt);
         switch (evt.type) {
@@ -222,7 +227,7 @@ class StormEventParser {
                 });
                 break;
         }
-        return this.toResult(handle);
+        return await this.toResult(handle);
     }
     getEvents() {
         return this.events;
@@ -236,9 +241,9 @@ class StormEventParser {
     getError() {
         return this.error;
     }
-    toResult(handle) {
+    async toResult(handle) {
         const planRef = StormEventParser.toRef(handle, this.planName || 'undefined');
-        const blockDefinitions = this.toBlockDefinitions(handle);
+        const blockDefinitions = await this.toBlockDefinitions(handle);
         const refIdMap = {};
         const blocks = Object.entries(blockDefinitions).map(([ref, block]) => {
             // Create a deterministic uuid
@@ -354,180 +359,190 @@ class StormEventParser {
             blocks: Object.values(blockDefinitions),
         };
     }
-    toBlockDefinitions(handle) {
+    async toBlockDefinitions(handle) {
         const result = {};
-        Object.entries(this.blocks).forEach(([, blockInfo]) => {
+        for (const [, blockInfo] of Object.entries(this.blocks)) {
             const blockRef = StormEventParser.toRef(handle, blockInfo.name);
-            const blockDefinitionInfo = {
-                uri: blockRef.toNormalizedString(),
-                aiName: blockInfo.name,
-                content: {
-                    kind: this.toBlockKind(blockInfo.type),
-                    metadata: {
-                        title: blockInfo.name,
-                        name: blockRef.fullName,
-                        description: blockInfo.description,
+            let blockDefinitionInfo;
+            if (blockInfo.archetype) {
+                blockDefinitionInfo = await this.resolveArchetypeBlockDefinition(blockRef, blockInfo);
+            }
+            else {
+                blockDefinitionInfo = this.createBlockDefinitionInfo(blockRef, blockInfo, handle);
+            }
+            result[blockRef.toNormalizedString()] = blockDefinitionInfo;
+        }
+        return result;
+    }
+    createBlockDefinitionInfo(blockRef, blockInfo, handle) {
+        const blockDefinitionInfo = {
+            uri: blockRef.toNormalizedString(),
+            aiName: blockInfo.name,
+            content: {
+                kind: this.toBlockKind(blockInfo.type),
+                metadata: {
+                    title: blockInfo.name,
+                    name: blockRef.fullName,
+                    description: blockInfo.description,
+                },
+                spec: {
+                    entities: {
+                        types: [],
+                        source: {
+                            type: kaplang_core_1.KAPLANG_ID,
+                            version: kaplang_core_1.KAPLANG_VERSION,
+                            value: '',
+                        },
                     },
-                    spec: {
-                        entities: {
-                            types: [],
+                    target: this.toBlockTarget(handle, blockInfo.type),
+                    providers: [],
+                    consumers: [],
+                },
+            },
+        };
+        const blockSpec = blockDefinitionInfo.content.spec;
+        const apiResources = {};
+        let dbResource = undefined;
+        (blockInfo.resources || []).forEach((resource) => {
+            const port = {
+                type: this.toPortType(resource.type),
+            };
+            switch (resource.type) {
+                case 'API': {
+                    const apiResource = {
+                        kind: this.toResourceKind(resource.type),
+                        metadata: {
+                            name: resource.name,
+                            description: resource.description,
+                        },
+                        spec: {
+                            port,
+                            methods: {},
                             source: {
                                 type: kaplang_core_1.KAPLANG_ID,
                                 version: kaplang_core_1.KAPLANG_VERSION,
                                 value: '',
                             },
                         },
-                        target: this.toBlockTarget(handle, blockInfo.type),
-                        providers: [],
-                        consumers: [],
-                    },
-                },
-            };
-            const blockSpec = blockDefinitionInfo.content.spec;
-            const apiResources = {};
-            let dbResource = undefined;
-            (blockInfo.resources || []).forEach((resource) => {
-                const port = {
-                    type: this.toPortType(resource.type),
-                };
-                switch (resource.type) {
-                    case 'API': {
-                        const apiResource = {
-                            kind: this.toResourceKind(resource.type),
-                            metadata: {
-                                name: resource.name,
-                                description: resource.description,
-                            },
-                            spec: {
-                                port,
-                                methods: {},
-                                source: {
-                                    type: kaplang_core_1.KAPLANG_ID,
-                                    version: kaplang_core_1.KAPLANG_VERSION,
-                                    value: '',
-                                },
+                    };
+                    apiResources[resource.name] = apiResource;
+                    blockSpec.providers.push(apiResource);
+                    break;
+                }
+                case 'CLIENT':
+                    blockSpec.consumers.push({
+                        kind: this.toResourceKind(resource.type),
+                        metadata: {
+                            name: resource.name,
+                            description: resource.description,
+                        },
+                        spec: {
+                            port,
+                            methods: {},
+                            source: {
+                                type: kaplang_core_1.KAPLANG_ID,
+                                version: kaplang_core_1.KAPLANG_VERSION,
+                                value: '',
                             },
-                        };
-                        apiResources[resource.name] = apiResource;
-                        blockSpec.providers.push(apiResource);
+                        },
+                    });
+                    break;
+                case 'EXTERNAL_API':
+                    break;
+                case 'EXCHANGE':
+                    break;
+                case 'PUBLISHER':
+                    break;
+                case 'QUEUE':
+                    break;
+                case 'SUBSCRIBER':
+                    break;
+                case 'JWTPROVIDER':
+                case 'WEBPAGE':
+                    blockSpec.providers.push({
+                        kind: this.toResourceKind(resource.type),
+                        metadata: {
+                            name: resource.name,
+                            description: resource.description,
+                        },
+                        spec: {
+                            port,
+                        },
+                    });
+                    break;
+                case 'DATABASE':
+                    if (dbResource) {
                         break;
                     }
-                    case 'CLIENT':
-                        blockSpec.consumers.push({
-                            kind: this.toResourceKind(resource.type),
-                            metadata: {
-                                name: resource.name,
-                                description: resource.description,
-                            },
-                            spec: {
-                                port,
-                                methods: {},
-                                source: {
-                                    type: kaplang_core_1.KAPLANG_ID,
-                                    version: kaplang_core_1.KAPLANG_VERSION,
-                                    value: '',
-                                },
-                            },
-                        });
-                        break;
-                    case 'EXTERNAL_API':
-                        break;
-                    case 'EXCHANGE':
-                        break;
-                    case 'PUBLISHER':
-                        break;
-                    case 'QUEUE':
-                        break;
-                    case 'SUBSCRIBER':
-                        break;
-                    case 'JWTPROVIDER':
-                    case 'WEBPAGE':
-                        blockSpec.providers.push({
-                            kind: this.toResourceKind(resource.type),
-                            metadata: {
-                                name: resource.name,
-                                description: resource.description,
-                            },
-                            spec: {
-                                port,
-                            },
-                        });
-                        break;
-                    case 'DATABASE':
-                        if (dbResource) {
-                            break;
-                        }
-                        dbResource = {
-                            kind: this.toResourceKind(resource.type),
-                            metadata: {
-                                name: resource.name,
-                                description: resource.description,
-                            },
-                            spec: {
-                                port,
-                                models: [],
-                                source: {
-                                    type: kaplang_core_1.KAPLANG_ID,
-                                    version: kaplang_core_1.KAPLANG_VERSION,
-                                    value: '',
-                                },
-                            },
-                        };
-                        blockSpec.consumers.push(dbResource);
-                        break;
-                    case 'JWTCONSUMER':
-                    case 'WEBFRAGMENT':
-                    case 'SMTPCLIENT':
-                        blockSpec.consumers.push({
-                            kind: this.toResourceKind(resource.type),
-                            metadata: {
-                                name: resource.name,
-                                description: resource.description,
-                            },
-                            spec: {
-                                port,
+                    dbResource = {
+                        kind: this.toResourceKind(resource.type),
+                        metadata: {
+                            name: resource.name,
+                            description: resource.description,
+                        },
+                        spec: {
+                            port,
+                            models: [],
+                            source: {
+                                type: kaplang_core_1.KAPLANG_ID,
+                                version: kaplang_core_1.KAPLANG_VERSION,
+                                value: '',
                             },
-                        });
-                }
+                        },
+                    };
+                    blockSpec.consumers.push(dbResource);
+                    break;
+                case 'JWTCONSUMER':
+                case 'WEBFRAGMENT':
+                case 'SMTPCLIENT':
+                    blockSpec.consumers.push({
+                        kind: this.toResourceKind(resource.type),
+                        metadata: {
+                            name: resource.name,
+                            description: resource.description,
+                        },
+                        spec: {
+                            port,
+                        },
+                    });
+            }
+        });
+        blockInfo.apis.forEach((api) => {
+            const dslApi = kaplang_core_1.DSLAPIParser.parse(api, {
+                ignoreSemantics: true,
             });
-            blockInfo.apis.forEach((api) => {
-                const dslApi = kaplang_core_1.DSLAPIParser.parse(api, {
-                    ignoreSemantics: true,
-                });
-                let exactMatch = false;
-                if (dslApi[0] && dslApi[0].type == kaplang_core_1.DSLEntityType.CONTROLLER) {
-                    const name = dslApi[0].name.toLowerCase();
-                    const apiResourceName = Object.keys(apiResources).find((key) => key.indexOf(name) > -1);
-                    if (apiResourceName) {
-                        const exactResource = apiResources[apiResourceName];
-                        exactResource.spec.source.value += api + '\n\n';
-                        exactMatch = true;
-                    }
+            let exactMatch = false;
+            if (dslApi[0] && dslApi[0].type == kaplang_core_1.DSLEntityType.CONTROLLER) {
+                const name = dslApi[0].name.toLowerCase();
+                const apiResourceName = Object.keys(apiResources).find((key) => key.indexOf(name) > -1);
+                if (apiResourceName) {
+                    const exactResource = apiResources[apiResourceName];
+                    exactResource.spec.source.value += api + '\n\n';
+                    exactMatch = true;
                 }
-                if (!exactMatch) {
-                    // if we couldn't place the given api on the exact resource we just park it on the first
-                    // available rest resource
-                    const firstKey = Object.keys(apiResources)[0];
-                    const firstEntry = apiResources[firstKey];
-                    if (firstEntry) {
-                        firstEntry.spec.source.value += api + '\n\n';
-                    }
-                    else {
-                        console.warn('Unable to find resource for API', api);
-                    }
+            }
+            if (!exactMatch) {
+                // if we couldn't place the given api on the exact resource we just park it on the first
+                // available rest resource
+                const firstKey = Object.keys(apiResources)[0];
+                const firstEntry = apiResources[firstKey];
+                if (firstEntry) {
+                    firstEntry.spec.source.value += api + '\n\n';
+                }
+                else {
+                    console.warn('Unable to find resource for API', api);
                 }
-            });
-            blockInfo.types.forEach((type) => {
-                blockSpec.entities.source.value += type + '\n';
-            });
-            if (dbResource) {
-                blockInfo.models.forEach((model) => {
-                    dbResource.spec.source.value += model + '\n';
-                });
             }
-            result[blockRef.toNormalizedString()] = blockDefinitionInfo;
         });
-        return result;
+        blockInfo.types.forEach((type) => {
+            blockSpec.entities.source.value += type + '\n';
+        });
+        if (dbResource) {
+            blockInfo.models.forEach((model) => {
+                dbResource.spec.source.value += model + '\n';
+            });
+        }
+        return blockDefinitionInfo;
     }
     toResourceKind(type) {
         //TODO: Handle support for multiple resource types and versions
@@ -663,5 +678,20 @@ class StormEventParser {
         }
         return undefined;
     }
+    async resolveArchetypeBlockDefinition(blockRef, blockInfo) {
+        const predefinedBlock = predefined_1.PREDEFINED_BLOCKS.get(blockInfo.archetype);
+        if (!predefinedBlock) {
+            throw new Error('Predefined block not found for archetype [' + blockInfo.archetype + ']');
+        }
+        const blockDefinition = await predefinedBlock.getBlockDefinition();
+        lodash_1.default.set(blockDefinition, ['metadata', 'name'], blockRef.fullName);
+        lodash_1.default.set(blockDefinition, ['metadata', 'title'], blockRef.name);
+        return {
+            uri: blockRef.toNormalizedString(),
+            aiName: blockInfo.name,
+            content: blockDefinition,
+            archetype: blockInfo.archetype,
+        };
+    }
 }
 exports.StormEventParser = StormEventParser;