@kapeta/local-cluster-service 0.60.2 → 0.61.0

package/src/storm/routes.ts

@@ -13,7 +13,7 @@ import { stringBody } from '../middleware/stringBody';
 import { KapetaBodyRequest } from '../types';
 import { StormCodegenRequest, StormContextRequest, StormCreateBlockRequest, StormStream } from './stream';
 import { ConversationIdHeader, stormClient, UIPagePrompt, UIPageEditPrompt, UIPageEditRequest } from './stormClient';
-import { Page, StormEvent, StormEventPage, StormEventPhaseType } from './events';
+import { Page, StormEvent, StormEventPage, StormEventPhaseType, UIShell, UserJourneyScreen } from './events';
 import {
     createPhaseEndEvent,
     createPhaseStartEvent,
@@ -132,7 +132,9 @@ router.post('/:handle/ui', async (req: KapetaBodyRequest, res: Response) => {
 
         const aiRequest: StormContextRequest = JSON.parse(req.stringBody ?? '{}');
 
+        // Get user journeys
         const userJourneysStream = await stormClient.createUIUserJourneys(aiRequest.prompt, conversationId);
+        const outerConversationId = userJourneysStream.getConversationId();
 
         onRequestAborted(req, res, () => {
             userJourneysStream.abort();
@@ -140,23 +142,12 @@ router.post('/:handle/ui', async (req: KapetaBodyRequest, res: Response) => {
 
         res.set('Content-Type', 'application/x-ndjson');
         res.set('Access-Control-Expose-Headers', ConversationIdHeader);
-        res.set(ConversationIdHeader, userJourneysStream.getConversationId());
+        res.set(ConversationIdHeader, outerConversationId);
 
-        const promises: { [key: string]: Promise<void> } = {};
+        const uniqueUserJourneyScreens: Record<string, UserJourneyScreen> = {};
 
-        const queue = new PromiseQueue(5);
-        onRequestAborted(req, res, () => {
-            queue.cancel();
-        });
-
-        const systemId = userJourneysStream.getConversationId();
-
-        UI_SERVERS[systemId] = new UIServer(systemId);
-        await UI_SERVERS[systemId].start();
-
-        userJourneysStream.on('data', async (data: StormEvent) => {
+        userJourneysStream.on('data', (data: StormEvent) => {
             try {
-                console.log('Processing user journey event', data);
                 sendEvent(res, data);
                 if (data.type !== 'USER_JOURNEY') {
                     return;
@@ -167,54 +158,139 @@ router.post('/:handle/ui', async (req: KapetaBodyRequest, res: Response) => {
                 }
 
                 data.payload.screens.forEach((screen) => {
-                    if (screen.name in promises) {
-                        return;
+                    if (!uniqueUserJourneyScreens[screen.name]) {
+                        uniqueUserJourneyScreens[screen.name] = screen;
                     }
-                    promises[screen.name] = queue.add(
-                        () =>
-                            new Promise(async (resolve, reject) => {
-                                try {
-                                    const innerConversationId = uuid.v4();
-                                    const screenStream = await stormClient.createUIPage(
-                                        {
-                                            prompt: screen.requirements,
-                                            method: screen.method,
-                                            path: screen.path,
-                                            description: screen.requirements,
-                                            name: screen.name,
-                                            title: screen.title,
-                                            filename: screen.filename,
-                                            storage_prefix: userJourneysStream.getConversationId() + '_',
-                                        },
-                                        innerConversationId
-                                    );
-                                    const promises: Promise<void>[] = [];
-                                    screenStream.on('data', (screenData: StormEvent) => {
-                                        if (screenData.type === 'PAGE') {
-                                            screenData.payload.conversationId = innerConversationId;
-                                            promises.push(
-                                                sendPageEvent(userJourneysStream.getConversationId(), screenData, res)
-                                            );
-                                        } else {
-                                            sendEvent(res, screenData);
-                                        }
-                                    });
-                                    screenStream.on('end', () => {
-                                        Promise.allSettled(promises).finally(resolve);
-                                    });
-                                } catch (e: any) {
-                                    console.error('Failed to process screen', e);
-                                    reject(e);
-                                }
-                            })
-                    );
                 });
             } catch (e) {
                 console.error('Failed to process event', e);
             }
         });
 
+        userJourneysStream.on('error', (error) => {
+            console.error('Error on userJourneysStream', error);
+            userJourneysStream.abort();
+            sendError(error, res);
+        });
+
         await waitForStormStream(userJourneysStream);
+
+        // Get the UI shells
+        const shellsStream = await stormClient.createUIShells(
+            {
+                pages: Object.values(uniqueUserJourneyScreens).map((screen) => ({
+                    name: screen.name,
+                    title: screen.title,
+                    filename: screen.filename,
+                    path: screen.path,
+                    method: screen.method,
+                    requirements: screen.requirements,
+                })),
+            },
+            conversationId
+        );
+
+        onRequestAborted(req, res, () => {
+            shellsStream.abort();
+        });
+
+        const uiShells: UIShell[] = [];
+
+        shellsStream.on('data', (data: StormEvent) => {
+            console.log('Processing shell event', data);
+            sendEvent(res, data);
+
+            if (data.type !== 'UI_SHELL') {
+                return;
+            }
+
+            if (shellsStream.isAborted()) {
+                return;
+            }
+
+            uiShells.push(data.payload);
+        });
+
+        shellsStream.on('error', (error) => {
+            console.error('Error on shellsStream', error);
+            shellsStream.abort();
+            sendError(error, res);
+        });
+
+        await waitForStormStream(shellsStream);
+
+        UI_SERVERS[outerConversationId] = new UIServer(outerConversationId);
+        await UI_SERVERS[outerConversationId].start();
+
+        // Get the pages (5 at a time)
+        const queue = new PromiseQueue(5);
+
+        onRequestAborted(req, res, () => {
+            queue.cancel();
+        });
+
+        for (const screen of Object.values(uniqueUserJourneyScreens)) {
+            await queue.add(
+                () =>
+                    new Promise(async (resolve, reject) => {
+                        try {
+                            const innerConversationId = uuid.v4();
+                            const screenStream = await stormClient.createUIPage(
+                                {
+                                    prompt: screen.requirements,
+                                    method: screen.method,
+                                    path: screen.path,
+                                    description: screen.requirements,
+                                    name: screen.name,
+                                    title: screen.title,
+                                    filename: screen.filename,
+                                    storage_prefix: outerConversationId + '_',
+                                    shell_page: uiShells.find((shell) => shell.screens.includes(screen.name))?.content,
+                                },
+                                innerConversationId
+                            );
+
+                            const promiseList: Promise<void>[] = [];
+                            screenStream.on('data', (screenData: StormEvent) => {
+                                if (screenData.type === 'PAGE') {
+                                    promiseList.push(
+                                        sendPageEvent(
+                                            outerConversationId,
+                                            {
+                                                ...screenData,
+                                                payload: {
+                                                    ...screenData.payload,
+                                                    conversationId: innerConversationId,
+                                                },
+                                            },
+                                            res
+                                        )
+                                    );
+                                } else {
+                                    sendEvent(res, screenData);
+                                }
+                            });
+
+                            screenStream.on('end', async () => {
+                                try {
+                                    await Promise.allSettled(promiseList).finally(() => resolve(true));
+                                } catch (error) {
+                                    console.error('Failed to process screen', error);
+                                }
+                            });
+
+                            screenStream.on('error', (error) => {
+                                console.error('Error on screenStream', error);
+                                screenStream.abort();
+                            });
+                        } catch (e) {
+                            console.error('Failed to process screen', e);
+                            reject(e);
+                        }
+                    })
+            );
+        }
+
         await queue.wait();
 
         if (userJourneysStream.isAborted()) {
@@ -222,8 +298,8 @@ router.post('/:handle/ui', async (req: KapetaBodyRequest, res: Response) => {
         }
 
         sendDone(res);
-    } catch (err: any) {
-        sendError(err, res);
+    } catch (err) {
+        sendError(err as Error, res);
         if (!res.closed) {
             res.end();
         }

package/src/storm/stormClient.ts

@@ -21,6 +21,17 @@ export const STORM_ID = 'storm';
 
 export const ConversationIdHeader = 'Conversation-Id';
 
+export interface UIShellsPrompt {
+    pages: {
+        name: string;
+        title: string;
+        filename: string;
+        path: string;
+        method: string;
+        requirements: string;
+    }[];
+}
+
 export interface UIPagePrompt {
     name: string;
     title: string;
@@ -30,6 +41,7 @@ export interface UIPagePrompt {
     method: string;
     description: string;
     storage_prefix: string;
+    shell_page?: string;
 }
 
 export interface UIPageEditPrompt {
@@ -153,6 +165,13 @@ class StormClient {
         });
     }
 
+    public createUIShells(prompt: UIShellsPrompt, conversationId?: string) {
+        return this.send('/v2/ui/shells', {
+            prompt: JSON.stringify(prompt),
+            conversationId,
+        });
+    }
+
     public createUIPage(prompt: UIPagePrompt, conversationId?: string) {
         return this.send('/v2/ui/page', {
             prompt: prompt,

package/test/storm/duplicate-entities-events.json

@@ -0,0 +1,143 @@
+[
+    {
+        "type": "CREATE_BLOCK",
+        "reason": "Block updated",
+        "payload": {
+            "archetype": "",
+            "description": "Handles traffic from the backend services.",
+            "name": "api-gateway",
+            "resources": [
+                {
+                    "description": "",
+                    "name": "posts",
+                    "to": "post-service",
+                    "type": "CLIENT"
+                },
+                {
+                    "description": "",
+                    "name": "comments",
+                    "to": "comment-service",
+                    "type": "CLIENT"
+                }
+            ],
+            "type": "GATEWAY",
+            "blockRef": "kapeta://kapeta/api-gateway:local",
+            "instanceId": "6b247f30-dec4-5960-a8a0-f300caa95226"
+        },
+        "created": 1720784242064
+    },
+    {
+        "type": "CREATE_BLOCK",
+        "reason": "Block updated",
+        "payload": {
+            "archetype": "",
+            "description": "Manages the creation, editing, and deletion of blog posts.",
+            "name": "post-service",
+            "resources": [
+                {
+                    "description": "The posts API provides endpoints for managing blog posts. It includes functionality for creating, editing, and deleting posts, as well as retrieving and searching for posts. The API is designed to be secure and follows best practices for authentication and authorization.",
+                    "name": "posts",
+                    "type": "API"
+                }
+            ],
+            "type": "BACKEND",
+            "blockRef": "kapeta://kapeta/post-service:local",
+            "instanceId": "4e002962-ca24-5b8b-bcea-395b9bbf7c26"
+        },
+        "created": 1720784243137
+    },
+    {
+        "type": "CREATE_BLOCK",
+        "reason": "Block updated",
+        "payload": {
+            "archetype": "",
+            "description": "Manages the creation, editing, and deletion of comments on blog posts.",
+            "name": "comment-service",
+            "resources": [
+                {
+                    "description": "The comments API provides endpoints for managing comments on blog posts. It includes functionality for creating, editing, and deleting comments, as well as retrieving and searching for comments. The API is designed to be secure and follows best practices for authentication and authorization.",
+                    "name": "comments",
+                    "type": "API"
+                }
+            ],
+            "type": "BACKEND",
+            "blockRef": "kapeta://kapeta/comment-service:local",
+            "instanceId": "d4215220-f552-5a6d-9429-bef1c40c4d7c"
+        },
+        "created": 1720784243141
+    },
+    {
+        "type": "CREATE_TYPE",
+        "reason": "Create type for post-service",
+        "payload": {
+            "blockName": "post-service",
+            "content": "enum Status {\n    NEW,\n    ARCHIVED\n}\n\ntype Result {\n    status: Status\n}\n\ntype User {\n   id: string\n}",
+            "blockRef": "kapeta://kapeta/post-service:local",
+            "instanceId": "4e002962-ca24-5b8b-bcea-395b9bbf7c26"
+        },
+        "created": 1720784233286
+    },
+    {
+        "type": "CREATE_API",
+        "reason": "Create API for post-service",
+        "payload": {
+            "blockName": "post-service",
+            "content": "@GET(\"/status\")\ngetStatus(): Result",
+            "blockRef": "kapeta://kapeta/post-service:local",
+            "instanceId": "4e002962-ca24-5b8b-bcea-395b9bbf7c26"
+        },
+        "created": 1720784233290
+    },
+    {
+        "type": "CREATE_TYPE",
+        "reason": "Create type for comment-service",
+        "payload": {
+            "blockName": "comment-service",
+            "content": "enum Status {\n    NEW,\n    APPROVED\n}\n\ntype Result {\n    status: Status\n}\n\ntype User {\n   id: string\n}",
+            "blockRef": "kapeta://kapeta/comment-service:local",
+            "instanceId": "d4215220-f552-5a6d-9429-bef1c40c4d7c"
+        },
+        "created": 1720784241000
+    },
+    {
+        "type": "CREATE_API",
+        "reason": "Create API for comment-service",
+        "payload": {
+            "blockName": "comment-service",
+            "content": "@GET(\"/status\")\ngetStatus(): Result",
+            "blockRef": "kapeta://kapeta/comment-service:local",
+            "instanceId": "d4215220-f552-5a6d-9429-bef1c40c4d7c"
+        },
+        "created": 1720784241002
+    },
+    {
+        "type": "CREATE_CONNECTION",
+        "reason": "api-gateway needs to be able to serve the posts API from the post-service",
+        "payload": {
+            "fromComponent": "post-service",
+            "fromResource": "posts",
+            "fromResourceType": "API",
+            "toComponent": "api-gateway",
+            "toResource": "posts",
+            "toResourceType": "CLIENT",
+            "fromBlockId": "4e002962-ca24-5b8b-bcea-395b9bbf7c26",
+            "toBlockId": "6b247f30-dec4-5960-a8a0-f300caa95226"
+        },
+        "created": 1720784243173
+    },
+    {
+        "type": "CREATE_CONNECTION",
+        "reason": "api-gateway needs to be able to serve the comments API from the comment-service",
+        "payload": {
+            "fromComponent": "comment-service",
+            "fromResource": "comments",
+            "fromResourceType": "API",
+            "toComponent": "api-gateway",
+            "toResource": "comments",
+            "toResourceType": "CLIENT",
+            "fromBlockId": "d4215220-f552-5a6d-9429-bef1c40c4d7c",
+            "toBlockId": "6b247f30-dec4-5960-a8a0-f300caa95226"
+        },
+        "created": 1720784243174
+    }
+]

package/test/storm/event-parser.test.ts

@@ -8,6 +8,8 @@ import { StormEvent } from '../../src/storm/events';
 import simpleBlogEvents from './simple-blog-events.json';
 import predefinedUserEvents from './predefined-user-events.json';
 import testEvents from './blog-events.json';
+import duplicateEntitiesEvents from './duplicate-entities-events.json';
+import { DSLAPIParser, DSLDataType, DSLDataTypeParser, DSLMethod } from '@kapeta/kaplang-core';
 
 export const parserOptions = {
     serviceKind: 'kapeta/block-service:local',
@@ -245,4 +247,41 @@ describe('event-parser', () => {
         const safeName = StormEventParser.toSafeArtifactName('Browser-based CRM Application');
         expect(safeName).toBe('browserbasedcrmapplication');
     });
+
+    it('rename duplicate entity names', async () => {
+        const events = duplicateEntitiesEvents as StormEvent[];
+        const parser = new StormEventParser(parserOptions);
+        for (const event of events) {
+            await parser.processEvent('kapeta', event);
+        }
+
+        const result = await parser.toResult('kapeta');
+        const apiGateway = result.blocks.find((block) => block.aiName === 'api-gateway');
+        expect(apiGateway).toBeDefined();
+
+        const dataTypes = DSLDataTypeParser.parse(apiGateway!.content!.spec!.entities!.source!.value, {
+            ignoreSemantics: true,
+        });
+        expect(dataTypes.map((type) => type.name)).toStrictEqual(['Status', 'Result', 'User', 'Status_1', 'Result_1']);
+
+        const conflictingType = dataTypes.find((type) => type.name === 'Result_1');
+        expect(conflictingType).toBeDefined();
+        const dataType = conflictingType as DSLDataType;
+        expect(dataType.properties?.length).toBe(1);
+        const dslDataTypeProperty = dataType.properties![0];
+        expect(dslDataTypeProperty.type).toBe('Status_1');
+
+        const commentsClient = apiGateway?.content!.spec!.consumers?.find(
+            (resource) => resource.metadata.name === 'comments'
+        );
+        expect(commentsClient).toBeDefined();
+
+        const methods = DSLAPIParser.parse(commentsClient!.spec!.source!.value, {
+            ignoreSemantics: true,
+        });
+        expect(methods).toBeDefined();
+        expect(methods.length).toBe(1);
+        const method = methods[0] as DSLMethod;
+        expect(method.returnType).toBe('Result_1');
+    });
 });