@kapeta/local-cluster-service 0.54.11 → 0.55.0

package/dist/esm/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/esm/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/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@kapeta/local-cluster-service",
-    "version": "0.54.11",
+    "version": "0.55.0",
     "description": "Manages configuration, ports and service discovery for locally running Kapeta systems",
     "type": "commonjs",
     "exports": {
@@ -67,14 +67,17 @@
         "async-lock": "^1.4.0",
         "chokidar": "^3.5.3",
         "dockerode": "^3.3.5",
+        "download-git-repo": "^3.0.2",
         "express": "4.17.1",
         "express-promise-router": "^4.1.1",
         "fs-extra": "^11.1.0",
         "glob": "^7.1.6",
         "gunzip-maybe": "^1.4.2",
+        "js-yaml": "^4.1.0",
         "lodash": "^4.17.15",
         "md5": "2.2.1",
         "node-cache": "^5.1.2",
+        "node-fetch": "^3.3.2",
         "node-uuid": "^1.4.8",
         "parse-data-uri": "^0.2.0",
         "qs": "^6.11.2",
@@ -96,9 +99,11 @@
         "@types/glob": "^8.1.0",
         "@types/gunzip-maybe": "^1.4.0",
         "@types/jest": "^29.5.4",
+        "@types/js-yaml": "^4.0.9",
         "@types/lodash": "^4.14.195",
         "@types/md5": "^2.3.2",
         "@types/node": "^20.5.8",
+        "@types/node-fetch": "^2.6.11",
         "@types/node-uuid": "^0.0.29",
         "@types/request": "^2.48.8",
         "@types/tar-stream": "^2.2.2",

package/src/storm/archetype.ts

@@ -0,0 +1,85 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+
+import download from 'download-git-repo';
+import { PredefinedBlock } from './predefined';
+import * as fs from 'node:fs';
+import path from 'path';
+import { GeneratedFile, GeneratedResult } from '@kapeta/codegen';
+
+export class Archetype {
+    public async cloneRepository(
+        predefinedBlock: PredefinedBlock,
+        targetDir: string,
+        basePath: string
+    ): Promise<GeneratedResult> {
+        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);
+    }
+
+    private async copyToBasePathAndRemoveDownload(downloadDirectory: string, subPath: string, targetDir: string) {
+        const fullSourcePath = path.resolve(`${downloadDirectory}/${subPath}`);
+        const fullDestinationPath = path.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 });
+        }
+    }
+
+    private async convertToGeneratedResult(basePath: string): Promise<GeneratedResult> {
+        const generatedFiles: GeneratedFile[] = [];
+
+        async function traverse(currentPath: string): Promise<void> {
+            const files = await fs.promises.readdir(currentPath, { withFileTypes: true });
+
+            for (const file of files) {
+                const fullPath = path.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: 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 } as GeneratedResult;
+    }
+
+    private downloadRepo(url: string, dest: string): Promise<void> {
+        return new Promise<void>((resolve, reject) => {
+            download(url, dest, function (err: Error) {
+                if (err) {
+                    reject(err);
+                } else {
+                    resolve();
+                }
+            });
+        });
+    }
+}

package/src/storm/codegen.ts

@@ -36,6 +36,9 @@ import Path, { join } from 'path';
 import os from 'node:os';
 import { readFileSync, writeFileSync, existsSync } from 'fs';
 import YAML from 'yaml';
+import { PREDEFINED_BLOCKS } from './predefined';
+import { Archetype } from './archetype';
+import _ from 'lodash';
 
 type ImplementationGenerator<T = StormFileImplementationPrompt> = (
     prompt: T,
@@ -116,7 +119,11 @@ export class StormCodegen {
 
     public 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();
@@ -480,14 +487,17 @@ export class StormCodegen {
 
         this.emitBlockStatus(blockUri, block.aiName, StormEventBlockStatusType.QA);
 
-/* TODO: temporarily disabled - enable again when codegen is more stable
+        /* TODO: temporarily disabled - enable again when codegen is more stable
                 const filesToBeFixed = serviceFiles.concat(contextFiles).concat(screenFilesConverted);
                 const codeGenerator = new BlockCodeGenerator(blockDefinition);
 */
 
         this.emitBlockStatus(blockUri, block.aiName, StormEventBlockStatusType.BUILDING);
-//        await this.verifyAndFixCode(blockUri, block.aiName, codeGenerator, basePath, filesToBeFixed, allFiles);
+        //        await this.verifyAndFixCode(blockUri, block.aiName, codeGenerator, basePath, filesToBeFixed, allFiles);
+        this.emitBlockStatusDone(basePath, block, blockRef);
+    }
 
+    private emitBlockStatusDone(basePath: string, block: BlockDefinitionInfo, blockRef: string) {
         this.out.emit('data', {
             type: 'BLOCK_READY',
             reason: 'Block ready',
@@ -977,7 +987,7 @@ export class StormCodegen {
     /**
      * Generates the code using codegen for a given block.
      */
-    private async generateBlock(yamlContent: Definition) {
+    private async generateBlock(yamlContent: Definition): Promise<GeneratedResult | undefined> {
         if (this.isAborted()) {
             return;
         }
@@ -998,6 +1008,26 @@ export class StormCodegen {
         return generatedResult;
     }
 
+    private async cloneArchetype(block: BlockDefinitionInfo): Promise<void> {
+        const predefinedBlock = PREDEFINED_BLOCKS.get(block.archetype!)!;
+
+        let blockDefinition = await predefinedBlock.getBlockDefinition();
+        const kapetaURI = new KapetaURI(block.uri);
+        _.set(blockDefinition!, ['metadata', 'name'], kapetaURI.fullName);
+        _.set(blockDefinition!, ['metadata', 'title'], kapetaURI.name);
+
+        const basePath = this.getBasePath(blockDefinition.metadata.name);
+
+        let archetype = new 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();
     }