@kapeta/local-cluster-service 0.55.2 → 0.56.0

package/dist/esm/test/storm/codegen.test.js

@@ -26,8 +26,8 @@ describe('codegen', () => {
         await codegen.process();
         const stormEvents = await codegenPromise;
         expect(stormEvents.filter((event) => event.type === 'FILE_DONE').length).toBeGreaterThan(1);
-        expect(stormEvents.filter((event) => event.type === 'FILE_DONE' && event.payload.filename.endsWith('UserDTO.java')).length)
-            .toBe(1);
+        expect(stormEvents.filter((event) => event.type === 'FILE_DONE' && event.payload.filename.endsWith('UserDTO.java'))
+            .length).toBe(1);
         expect(stormEvents.at(-1).type).toBe('BLOCK_READY');
     });
 });

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

@@ -11,9 +11,10 @@ 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 predefined_user_events_json_1 = __importDefault(require("./predefined-user-events.json"));
+const blog_events_json_1 = __importDefault(require("./blog-events.json"));
 exports.parserOptions = {
     serviceKind: 'kapeta/block-service:local',
-    serviceLanguage: 'kapeta/language-target-nodejs-ts:local',
+    serviceLanguage: 'kapeta/language-target-java-spring-boot:local',
     frontendKind: 'kapeta/block-type-frontend:local',
     frontendLanguage: 'kapeta/language-target-react-ts:local',
     cliKind: 'kapeta/block-type-cli:local',
@@ -27,7 +28,7 @@ exports.parserOptions = {
     publisherKind: 'kapeta/resource-type-publisher:local',
     subscriberKind: 'kapeta/resource-type-subscriber:local',
     databaseKind: 'kapeta/block-type-database:local',
-    apiKind: 'kapeta/block-type-api:local',
+    apiKind: 'kapeta/resource-type-rest-api:local',
     clientKind: 'kapeta/block-type-client:local',
     webPageKind: 'kapeta/block-type-web-page:local',
     webFragmentKind: 'kapeta/block-type-web-fragment:local',
@@ -176,7 +177,7 @@ describe('event-parser', () => {
         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');
+        const apiProviders = blogService?.content?.spec?.providers?.filter((provider) => provider.kind === 'kapeta/resource-type-rest-api:local');
         expect(apiProviders).toBeDefined();
         expect(apiProviders.length).toBe(2);
         expect(apiProviders['0'].spec.source.value).not.toBe('');
@@ -190,9 +191,26 @@ describe('event-parser', () => {
         }
         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();
+        const block = result.blocks[0];
+        expect(block.content.metadata.title).toBe('user-service');
+        expect(block.content.metadata.title).toBe('user-service');
+        expect(block.content.metadata.name).toBe('kapeta/user-service');
+        expect(block.archetype).toBeDefined();
+        expect(block.content.spec.target?.options).toBeDefined();
+        expect(block.content.spec.target?.options.groupId).toBe('ai.kapeta');
+        expect(block.content.spec.target?.options.artifactId).toBe('blogplatform');
+        expect(block.content.spec.target?.options.basePackage).toBe('ai.kapeta.blogplatform');
+    });
+    it('ensure post-service has api', async () => {
+        const events = blog_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', true);
+        const postService = result.blocks.find((block) => block.aiName === 'post-service');
+        expect(postService).toBeDefined();
+        expect(postService?.content?.spec?.providers?.length).toBe(1);
+        expect(postService?.content?.spec?.providers[0].spec.source.value.startsWith('controller')).toBeTruthy();
     });
 });

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

@@ -1,4 +1,13 @@
 [
+    {
+        "type": "CREATE_PLAN_PROPERTIES",
+        "reason": "Define the properties for the plan itself",
+        "payload": {
+            "description": "A blogging platform with user management, post management, and comment management functionalities.",
+            "name": "Blog Platform"
+        },
+        "created": 1720768973436
+    },
     {
         "type": "CREATE_BLOCK",
         "reason": "Handles user registration, authentication, and authorization.",

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@kapeta/local-cluster-service",
-    "version": "0.55.2",
+    "version": "0.56.0",
     "description": "Manages configuration, ports and service discovery for locally running Kapeta systems",
     "type": "commonjs",
     "exports": {

package/src/storm/codegen.ts

@@ -106,7 +106,7 @@ export class StormCodegen {
     private readonly blocks: BlockDefinitionInfo[];
     private readonly out = new StormStream();
     private readonly events: StormEvent[];
-    private readonly tmpDir: string;
+    private tmpDir: string;
     private readonly conversationId: string;
 
     constructor(conversationId: string, userPrompt: string, blocks: BlockDefinitionInfo[], events: StormEvent[]) {
@@ -117,6 +117,10 @@ export class StormCodegen {
         this.conversationId = conversationId;
     }
 
+    public setTmpDir(tmpDir: string) {
+        this.tmpDir = tmpDir;
+    }
+
     public async process() {
         const promises = this.blocks.map((block) => {
             if (block.archetype) {
@@ -273,7 +277,7 @@ export class StormCodegen {
                     payload: {
                         filename: data.payload.filename,
                         path: join(this.getBasePath(blockUri.fullName), data.payload.filename),
-                        content: data.payload.content,
+                        content: data.payload.content.replace(/\\n/g, '\n'),
                         blockRef: ref,
                         instanceId: StormEventParser.toInstanceIdFromRef(ref),
                     },
@@ -320,6 +324,7 @@ export class StormCodegen {
                 file.type !== AIFileTypes.WEB_ROUTER
         );
         const uiTemplates = allFiles.filter((file) => file.type === AIFileTypes.WEB_SCREEN);
+
         const screenFiles: StormEventFileDone[] = [];
 
         let filteredEvents = [] as StormEvent[];

package/src/storm/event-parser.ts

@@ -76,6 +76,7 @@ export interface StormOptions {
     desktopKind: string;
     desktopLanguage: string;
     gatewayKind: string;
+    [key: string]: string;
 }
 
 function prettifyKaplang(source: string) {
@@ -288,7 +289,7 @@ export class StormEventParser {
                 this.blocks[evt.payload.name] = {
                     ...evt.payload,
                     apis: apis ?? [],
-                    models: models ??[],
+                    models: models ?? [],
                     types: types ?? [],
                 };
                 evt.payload.blockRef = StormEventParser.toRef(handle, evt.payload.name).toNormalizedString();
@@ -364,7 +365,7 @@ export class StormEventParser {
         return this.error;
     }
 
-    public async toResult(handle: string): Promise<StormDefinitions> {
+    public async toResult(handle: string, warn: boolean = false): Promise<StormDefinitions> {
         const planRef = StormEventParser.toRef(handle, this.planName || 'undefined');
         const blockDefinitions = await this.toBlockDefinitions(handle);
         const refIdMap: { [key: string]: string } = {};
@@ -409,12 +410,14 @@ export class StormEventParser {
                 );
 
                 if (!apiResource) {
-                    console.warn(
-                        'API resource not found: %s on %s',
-                        apiConnection.fromResource,
-                        apiProviderRef.toNormalizedString(),
-                        apiConnection
-                    );
+                    if (warn) {
+                        console.warn(
+                            'API resource not found: %s on %s',
+                            apiConnection.fromResource,
+                            apiProviderRef.toNormalizedString(),
+                            apiConnection
+                        );
+                    }
                     return;
                 }
 
@@ -428,12 +431,14 @@ export class StormEventParser {
                 });
 
                 if (!clientResource) {
-                    console.warn(
-                        'Client resource not found: %s on %s',
-                        apiConnection.toResource,
-                        clientConsumerRef.toNormalizedString(),
-                        apiConnection
-                    );
+                    if (warn) {
+                        console.warn(
+                            'Client resource not found: %s on %s',
+                            apiConnection.toResource,
+                            clientConsumerRef.toNormalizedString(),
+                            apiConnection
+                        );
+                    }
                     return;
                 }
 
@@ -487,7 +492,7 @@ export class StormEventParser {
                     blockId: refIdMap[fromRef.toNormalizedString()],
                     resourceName: connection.fromResource,
                 },
-                mapping: this.toConnectionMapping(handle, connection, blockDefinitions),
+                mapping: this.toConnectionMapping(handle, connection, blockDefinitions, warn),
             } satisfies Connection;
         });
 
@@ -521,7 +526,7 @@ export class StormEventParser {
             let blockDefinitionInfo: BlockDefinitionInfo;
 
             if (blockInfo.archetype) {
-                blockDefinitionInfo = await this.resolveArchetypeBlockDefinition(blockRef, blockInfo);
+                blockDefinitionInfo = await this.resolveArchetypeBlockDefinition(blockRef, blockInfo, handle);
             } else {
                 blockDefinitionInfo = this.createBlockDefinitionInfo(blockRef, blockInfo, handle);
             }
@@ -697,7 +702,7 @@ export class StormEventParser {
                 if (firstEntry) {
                     firstEntry.spec.source.value += api + '\n\n';
                 } else {
-                    console.warn('Unable to find resource for API', api);
+                    // this might be ok as we might receive api and types before resources from the ai-service
                 }
             }
         });
@@ -770,7 +775,8 @@ export class StormEventParser {
     private toConnectionMapping(
         handle: string,
         connection: StormConnection,
-        blockDefinitions: { [key: string]: BlockDefinitionInfo }
+        blockDefinitions: { [key: string]: BlockDefinitionInfo },
+        warn: boolean
     ): any {
         if (connection.fromResourceType !== 'API') {
             return;
@@ -789,12 +795,14 @@ export class StormEventParser {
         );
 
         if (!apiResource) {
-            console.warn(
-                'API resource not found: %s on %s',
-                connection.fromResource,
-                fromRef.toNormalizedString(),
-                connection
-            );
+            if (warn) {
+                console.warn(
+                    'API resource not found: %s on %s',
+                    connection.fromResource,
+                    fromRef.toNormalizedString(),
+                    connection
+                );
+            }
             return;
         }
 
@@ -888,16 +896,43 @@ export class StormEventParser {
 
     private async resolveArchetypeBlockDefinition(
         blockRef: KapetaURI,
-        blockInfo: StormBlockInfoFilled
+        blockInfo: StormBlockInfoFilled,
+        handle: string
     ): Promise<BlockDefinitionInfo> {
         const predefinedBlock = PREDEFINED_BLOCKS.get(blockInfo.archetype!);
         if (!predefinedBlock) {
             throw new Error('Predefined block not found for archetype [' + blockInfo.archetype + ']');
         }
 
+        const target = this.toBlockTarget(handle, blockInfo.type);
+
         const blockDefinition = await predefinedBlock.getBlockDefinition();
         _.set(blockDefinition!, ['metadata', 'name'], blockRef.fullName);
         _.set(blockDefinition!, ['metadata', 'title'], blockRef.name);
+        _.set(blockDefinition!, ['spec', 'target', 'options'], target?.options);
+
+        const options: StormOptions = this.options;
+
+        function getKind(kind: string): string | undefined {
+            for (const prop in options) {
+                if (options.hasOwnProperty(prop)) {
+                    const value = options[prop];
+                    if (value.startsWith(kind)) {
+                        return value;
+                    }
+                }
+            }
+        }
+
+        blockDefinition!.kind = getKind(parseKapetaUri(blockDefinition!.kind).fullName) ?? blockDefinition!.kind;
+        for (const provider of blockDefinition!.spec.providers ?? []) {
+            provider.kind = getKind(parseKapetaUri(provider.kind).fullName) ?? provider.kind;
+        }
+        for (const consumer of blockDefinition!.spec.consumers ?? []) {
+            consumer.kind = getKind(parseKapetaUri(consumer.kind).fullName) ?? consumer.kind;
+        }
+        blockDefinition!.spec.target!.kind =
+            getKind(parseKapetaUri(blockDefinition!.spec.target!.kind).fullName) ?? blockDefinition!.spec.target!.kind;
 
         return {
             uri: blockRef.toNormalizedString(),

package/src/storm/routes.ts

@@ -6,10 +6,12 @@
 import Router from 'express-promise-router';
 import FS from 'fs-extra';
 import { Response } from 'express';
+import Path from 'path';
+import _ from 'lodash';
 import { corsHandler } from '../middleware/cors';
 import { stringBody } from '../middleware/stringBody';
 import { KapetaBodyRequest } from '../types';
-import { StormContextRequest, StormCreateBlockRequest, StormStream } from './stream';
+import { StormCodegenRequest, StormContextRequest, StormCreateBlockRequest, StormStream } from './stream';
 import { ConversationIdHeader, stormClient } from './stormClient';
 import { StormEvent, StormEventPhaseType } from './events';
 import {
@@ -21,8 +23,6 @@ import {
 } from './event-parser';
 import { StormCodegen } from './codegen';
 import { assetManager } from '../assetManager';
-import Path from 'path';
-import _ from 'lodash';
 
 const router = Router();
 
@@ -103,12 +103,13 @@ router.post('/:handle/all', async (req: KapetaBodyRequest, res: Response) => {
             return;
         }
 
-        const result = await eventParser.toResult(handle);
+        const result = await eventParser.toResult(handle, true);
 
         if (metaStream.isAborted()) {
             return;
         }
-
+        // Cancel debounce, we don't need to send the plan again
+        sendUpdatedPlan.cancel();
         sendDefinitions(res, result);
 
         if (!req.query.skipCodegen) {
@@ -169,6 +170,31 @@ router.post('/block/create', async (req: KapetaBodyRequest, res: Response) => {
     }
 });
 
+router.post('/block/codegen', async (req: KapetaBodyRequest, res: Response) => {
+    const body: StormCodegenRequest = JSON.parse(req.stringBody ?? '{}');
+    console.log('Codegen request', body);
+    const conversationId = req.headers[ConversationIdHeader.toLowerCase()] as string | undefined;
+    try {
+        const stormCodegen = new StormCodegen(conversationId ?? '', body.prompt, [body.block], body.events || []);
+        stormCodegen.setTmpDir(body.outDir);
+
+        onRequestAborted(req, res, () => {
+            stormCodegen.abort();
+        });
+
+        const codegenPromise = streamStormPartialResponse(stormCodegen.getStream(), res);
+
+        await stormCodegen.process();
+
+        await codegenPromise;
+
+        sendDone(res);
+    } catch (err: any) {
+        console.error('Failed to generate code', err);
+        res.status(500).send({ error: err.message });
+    }
+});
+
 function sendDefinitions(res: Response, result: StormDefinitions) {
     sendEvent(res, {
         type: 'DEFINITION_CHANGE',
@@ -228,10 +254,7 @@ function sendEvent(res: Response, evt: StormEvent) {
 }
 
 function onRequestAborted(req: KapetaBodyRequest, res: Response, onAborted: () => void) {
-    req.on('close', () => {
-        onAborted();
-    });
-    res.on('close', () => {
+    req.socket.on('close', () => {
         onAborted();
     });
 }

package/src/storm/stream.ts

@@ -6,6 +6,7 @@ import { EventEmitter } from 'node:events';
 import { StormEvent } from './events';
 import { AIFileTypes, GeneratedFile } from '@kapeta/codegen';
 import { BlockDefinition } from '@kapeta/schemas';
+import { BlockDefinitionInfo } from './event-parser';
 
 export class StormStream extends EventEmitter {
     private conversationId: string = '';
@@ -106,6 +107,13 @@ export interface StormCreateBlockRequest {
     newPath: string;
 }
 
+export interface StormCodegenRequest {
+    block: BlockDefinitionInfo;
+    prompt: string;
+    events: StormEvent[];
+    outDir: string;
+}
+
 export interface StormFileInfo extends GeneratedFile {
     type: AIFileTypes;
 }