@kapeta/local-cluster-service 0.54.11 → 0.55.0

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

@@ -7,9 +7,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.parserOptions = void 0;
 const event_parser_1 = require("../../src/storm/event-parser");
 const simple_blog_events_json_1 = __importDefault(require("./simple-blog-events.json"));
-const parserOptions = {
+const predefined_user_events_json_1 = __importDefault(require("./predefined-user-events.json"));
+exports.parserOptions = {
     serviceKind: 'kapeta/block-service:local',
     serviceLanguage: 'kapeta/language-target-nodejs-ts:local',
     frontendKind: 'kapeta/block-type-frontend:local',
@@ -129,10 +131,12 @@ const events = [
     },
 ];
 describe('event-parser', () => {
-    it('it can parse events into a plan and blocks with proper layout', () => {
-        const parser = new event_parser_1.StormEventParser(parserOptions);
-        events.forEach((event) => parser.processEvent('kapeta', event));
-        const result = parser.toResult('kapeta');
+    it('it can parse events into a plan and blocks with proper layout', async () => {
+        const parser = new event_parser_1.StormEventParser(exports.parserOptions);
+        for (const event of events) {
+            await parser.processEvent('kapeta', event);
+        }
+        const result = await parser.toResult('kapeta');
         expect(result.plan.metadata.name).toBe('kapeta/my-plan');
         expect(result.plan.metadata.description).toBe('my plan description');
         expect(result.blocks.length).toBe(2);
@@ -146,10 +150,10 @@ describe('event-parser', () => {
         expect(clientResource).toBeDefined();
         expect(dbResource).toBeDefined();
         expect(pageResource).toBeDefined();
-        expect(apiResource?.kind).toBe(parserOptions.apiKind);
-        expect(clientResource?.kind).toBe(parserOptions.clientKind);
-        expect(dbResource?.kind).toBe(parserOptions.databaseKind);
-        expect(pageResource?.kind).toBe(parserOptions.webPageKind);
+        expect(apiResource?.kind).toBe(exports.parserOptions.apiKind);
+        expect(clientResource?.kind).toBe(exports.parserOptions.clientKind);
+        expect(dbResource?.kind).toBe(exports.parserOptions.databaseKind);
+        expect(pageResource?.kind).toBe(exports.parserOptions.webPageKind);
         expect(apiResource?.spec).toEqual(clientResource?.spec);
         expect(dbResource?.spec.source.value).toContain('type Entity');
         const serviceBlockInstance = result.plan.spec.blocks[0];
@@ -162,18 +166,33 @@ describe('event-parser', () => {
         expect(result.plan.spec.connections[0].provider.blockId).toBe(serviceBlockInstance.id);
         expect(result.plan.spec.connections[0].provider.resourceName).toBe(apiResource?.metadata.name);
     });
-    it('it will split api into correct provider', () => {
+    it('it will split api into correct provider', async () => {
         const events = simple_blog_events_json_1.default;
-        const parser = new event_parser_1.StormEventParser(parserOptions);
-        events.forEach((event) => parser.processEvent('kapeta', event));
-        const result = parser.toResult('kapeta');
+        const parser = new event_parser_1.StormEventParser(exports.parserOptions);
+        for (const event of events) {
+            await parser.processEvent('kapeta', event);
+        }
+        const result = await parser.toResult('kapeta');
         const blogService = result.blocks.find((block) => block.aiName === 'blog-service');
         expect(blogService).toBeDefined();
         expect(blogService?.content).toBeDefined();
         const apiProviders = blogService?.content?.spec?.providers?.filter((provider) => provider.kind === 'kapeta/block-type-api:local');
         expect(apiProviders).toBeDefined();
         expect(apiProviders.length).toBe(2);
-        expect(apiProviders["0"].spec.source.value).not.toBe('');
-        expect(apiProviders["1"].spec.source.value).not.toBe('');
+        expect(apiProviders['0'].spec.source.value).not.toBe('');
+        expect(apiProviders['1'].spec.source.value).not.toBe('');
+    });
+    it('predefined components', async () => {
+        const events = predefined_user_events_json_1.default;
+        const parser = new event_parser_1.StormEventParser(exports.parserOptions);
+        for (const event of events) {
+            await parser.processEvent('kapeta', event);
+        }
+        const result = await parser.toResult('kapeta');
+        expect(result.blocks.length).toBe(1);
+        expect(result.blocks[0].content.metadata.title).toBe('user-service');
+        expect(result.blocks[0].content.metadata.title).toBe('user-service');
+        expect(result.blocks[0].content.metadata.name).toBe('kapeta/user-service');
+        expect(result.blocks[0].archetype).toBeDefined();
     });
 });

package/dist/cjs/test/storm/predefined-user-events.json

@@ -0,0 +1,13 @@
+[
+    {
+        "type": "CREATE_BLOCK",
+        "reason": "Handles user registration, authentication, and authorization.",
+        "payload": {
+            "name": "user-service",
+            "resources": [],
+            "type": "BACKEND",
+            "archetype": "USER_SERVICE"
+        },
+        "created": 1720597268038
+    }
+]

package/dist/esm/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/esm/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/esm/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/esm/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/esm/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;
 }