@kapeta/local-cluster-service 0.47.0 → 0.47.2

package/src/storm/event-parser.ts

@@ -14,11 +14,19 @@ import {
     SourceCode,
 } from '@kapeta/schemas';
 import { KapetaURI, normalizeKapetaUri, parseKapetaUri } from '@kapeta/nodejs-utils';
-import { KAPLANG_ID, KAPLANG_VERSION, RESTMethod } from '@kapeta/kaplang-core';
-import uuid from 'node-uuid';
+import {
+    DSLAPIParser,
+    DSLController,
+    DSLConverters,
+    DSLDataTypeParser,
+    DSLMethod,
+    DSLParser,
+    KAPLANG_ID,
+    KAPLANG_VERSION,
+    KaplangWriter,
+} from '@kapeta/kaplang-core';
+import { v5 as uuid } from 'uuid';
 import { definitionsManager } from '../definitionsManager';
-import createGraph from 'ngraph.graph';
-import createLayout from 'ngraph.forcelayout';
 
 export interface BlockDefinitionInfo {
     uri: KapetaURI;
@@ -57,6 +65,28 @@ export interface StormOptions {
     gatewayKind: string;
 }
 
+function prettifyKaplang(source: string) {
+    if (!source || !source.trim()) {
+        return '';
+    }
+
+    try {
+        const ast = DSLParser.parse(source, {
+            ignoreSemantics: true,
+            types: true,
+            methods: true,
+            rest: true,
+            extends: true,
+            generics: true,
+        });
+
+        return KaplangWriter.write(ast.entities ?? []);
+    } catch (e) {
+        console.warn('Failed to prettify source:\n%s', source);
+        return source;
+    }
+}
+
 export async function resolveOptions(): Promise<StormOptions> {
     // Predefined types for now - TODO: Allow user to select / change
 
@@ -170,8 +200,6 @@ export async function resolveOptions(): Promise<StormOptions> {
     };
 }
 
-const LAYOUT_MARGIN = 50;
-
 export class StormEventParser {
     private events: StormEvent[] = [];
     private planName: string = '';
@@ -193,8 +221,9 @@ export class StormEventParser {
         this.connections = [];
     }
 
-    public addEvent(handle:string, evt: StormEvent): StormDefinitions {
+    public addEvent(handle: string, evt: StormEvent): StormDefinitions {
         this.events.push(evt);
+        console.log('evt', evt);
         switch (evt.type) {
             case 'CREATE_PLAN_PROPERTIES':
                 this.planName = evt.payload.name;
@@ -216,13 +245,13 @@ export class StormEventParser {
                 this.error = evt.payload.error;
                 break;
             case 'CREATE_API':
-                this.blocks[evt.payload.blockName].apis.push(evt.payload.content);
+                this.blocks[evt.payload.blockName].apis.push(prettifyKaplang(evt.payload.content));
                 break;
             case 'CREATE_TYPE':
-                this.blocks[evt.payload.blockName].types.push(evt.payload.content);
+                this.blocks[evt.payload.blockName].types.push(prettifyKaplang(evt.payload.content));
                 break;
             case 'CREATE_MODEL':
-                this.blocks[evt.payload.blockName].models.push(evt.payload.content);
+                this.blocks[evt.payload.blockName].models.push(prettifyKaplang(evt.payload.content));
                 break;
             case 'CREATE_CONNECTION':
                 this.connections.push(evt.payload);
@@ -242,6 +271,9 @@ export class StormEventParser {
     }
 
     public isValid(): boolean {
+        if (!this.planName) {
+            return false;
+        }
         return !this.failed;
     }
 
@@ -249,59 +281,13 @@ export class StormEventParser {
         return this.error;
     }
 
-    private applyLayoutToBlocks(result: StormDefinitions): StormDefinitions {
-        const graph = createGraph();
-        const blockInstances: { [key: string]: BlockInstance } = {};
-
-        result.plan.spec.blocks.forEach((block, index) => {
-            graph.addNode(block.id, block);
-            blockInstances[block.id] = block;
-        });
-
-        result.plan.spec.connections.forEach((connection) => {
-            graph.addLink(connection.provider.blockId, connection.consumer.blockId);
-        });
-
-        const layout = createLayout(graph, {
-            springLength: 150,
-            debug: true,
-            dimensions: 2,
-            gravity: 2,
-            springCoefficient: 0.0008,
-        });
-
-        for (let i = 0; i < 100; ++i) {
-            layout.step();
-        }
-
-        // Layout might place things in negative space. We move everything to positive space
-        const graphBox = layout.getGraphRect();
-        let yAdjust = 0;
-        let xAdjust = 0;
-        if (graphBox.y1 < 0) {
-            yAdjust = -graphBox.y1;
-        }
-        if (graphBox.x1 < 0) {
-            xAdjust = -graphBox.x1;
-        }
-
-        graph.forEachNode((node) => {
-            const position = layout.getNodePosition(node.id);
-            blockInstances[node.id].dimensions.left = LAYOUT_MARGIN + Math.round(position.x + xAdjust);
-            blockInstances[node.id].dimensions.top = LAYOUT_MARGIN + Math.round(position.y + yAdjust);
-        });
-
-        layout.dispose();
-
-        return result;
-    }
-
     public toResult(handle: string): StormDefinitions {
-        const planRef = this.toRef(handle, this.planName);
+        const planRef = this.toRef(handle, this.planName ?? 'undefined');
         const blockDefinitions = this.toBlockDefinitions(handle);
         const refIdMap: { [key: string]: string } = {};
         const blocks = Object.entries(blockDefinitions).map(([ref, block]) => {
-            const id = uuid.v4();
+            // Create a deterministic uuid
+            const id = uuid(ref, uuid.URL);
             refIdMap[ref] = id;
             return {
                 id,
@@ -368,13 +354,41 @@ export class StormEventParser {
                     return;
                 }
 
+                if (apiProviderBlock.content.spec.entities?.source?.value) {
+                    if (!clientConsumerBlock.content.spec.entities) {
+                        clientConsumerBlock.content.spec.entities = {
+                            types: [],
+                            source: {
+                                type: KAPLANG_ID,
+                                version: KAPLANG_VERSION,
+                                value: '',
+                            },
+                        };
+                    }
+
+                    const clientTypes = DSLDataTypeParser.parse(
+                        clientConsumerBlock.content.spec.entities.source!.value
+                    );
+                    const apiTypes = DSLDataTypeParser.parse(apiProviderBlock.content.spec.entities?.source?.value);
+
+                    apiTypes.forEach((apiType) => {
+                        if (clientTypes.some((clientType) => clientType.name === apiType.name)) {
+                            // Already exists
+                            return;
+                        }
+                        clientTypes.push(apiType);
+                    });
+
+                    clientConsumerBlock.content.spec.entities.source!.value = KaplangWriter.write(clientTypes);
+                }
                 clientResource.spec.methods = apiResource.spec.methods;
                 clientResource.spec.source = apiResource.spec.source;
             });
 
-        const connections = this.connections.map((connection) => {
+        const connections: Connection[] = this.connections.map((connection) => {
             const fromRef = this.toRef(handle, connection.fromComponent);
             const toRef = this.toRef(handle, connection.toComponent);
+
             return {
                 port: {
                     type: this.toPortType(connection.fromResourceType),
@@ -387,9 +401,7 @@ export class StormEventParser {
                     blockId: refIdMap[fromRef.toNormalizedString()],
                     resourceName: connection.fromResource,
                 },
-                mapping: {
-                    //TODO: Add mapping
-                },
+                mapping: this.toConnectionMapping(handle, connection, blockDefinitions),
             } satisfies Connection;
         });
 
@@ -406,10 +418,10 @@ export class StormEventParser {
             },
         };
 
-        return this.applyLayoutToBlocks({
+        return {
             plan,
             blocks: Object.values(blockDefinitions),
-        });
+        };
     }
 
     private toSafeName(name: string): string {
@@ -637,6 +649,55 @@ export class StormEventParser {
         return '';
     }
 
+    private toConnectionMapping(
+        handle: string,
+        connection: StormConnection,
+        blockDefinitions: { [key: string]: BlockDefinitionInfo }
+    ): any {
+        if (connection.fromResourceType !== 'API') {
+            return;
+        }
+
+        const fromRef = this.toRef(handle, connection.fromComponent);
+
+        const apiProviderBlock = blockDefinitions[fromRef.toNormalizedString()];
+        if (!apiProviderBlock) {
+            console.warn('Provider block not found: %s', connection.fromComponent, connection);
+            return;
+        }
+
+        const apiResource = apiProviderBlock.content.spec.providers?.find(
+            (p) => p.kind === this.options.apiKind && p.metadata.name === connection.fromResource
+        );
+
+        if (!apiResource) {
+            console.warn(
+                'API resource not found: %s on %s',
+                connection.fromResource,
+                fromRef.toNormalizedString(),
+                connection
+            );
+            return;
+        }
+
+        const apiMethods = DSLConverters.toSchemaMethods(
+            DSLAPIParser.parse(apiResource.spec?.source?.value ?? '', {
+                ignoreSemantics: true,
+            }) as (DSLMethod | DSLController)[]
+        );
+
+        const mapping: any = {};
+
+        Object.entries(apiMethods).forEach(([methodId, method]) => {
+            mapping[methodId] = {
+                targetId: methodId,
+                type: 'EXACT',
+            };
+        });
+
+        return mapping;
+    }
+
     private toPortType(type: StormResourceType) {
         switch (type) {
             case 'API':

package/src/storm/events.ts

@@ -2,7 +2,7 @@
  * Copyright 2023 Kapeta Inc.
  * SPDX-License-Identifier: BUSL-1.1
  */
-import {StormDefinitions} from "./event-parser";
+import { StormDefinitions } from './event-parser';
 
 export type StormResourceType =
     | 'API'
@@ -146,6 +146,7 @@ export interface StormEventFile {
     payload: {
         filename: string;
         content: string;
+        blockName: string;
         blockRef: string;
     };
 }

package/src/storm/routes.ts

@@ -4,15 +4,15 @@
  */
 
 import Router from 'express-promise-router';
-import {Response} from 'express';
-import {corsHandler} from '../middleware/cors';
-import {stringBody} from '../middleware/stringBody';
-import {KapetaBodyRequest} from '../types';
-import {StormContextRequest, StormFileImplementationPrompt, StormFileInfo, StormStream} from './stream';
-import {stormClient} from './stormClient';
-import {StormEvent} from './events';
-import {resolveOptions, StormDefinitions, StormEventParser} from './event-parser';
-import {StormCodegen} from './codegen';
+import { Response } from 'express';
+import { corsHandler } from '../middleware/cors';
+import { stringBody } from '../middleware/stringBody';
+import { KapetaBodyRequest } from '../types';
+import { StormContextRequest, StormFileImplementationPrompt, StormFileInfo, StormStream } from './stream';
+import { stormClient } from './stormClient';
+import { StormEvent } from './events';
+import { resolveOptions, StormDefinitions, StormEventParser } from './event-parser';
+import { StormCodegen } from './codegen';
 
 const router = Router();
 
@@ -44,7 +44,7 @@ router.post('/:handle/all', async (req: KapetaBodyRequest, res: Response) => {
             // We can't continue if the meta stream is invalid
             sendEvent(res, {
                 type: 'ERROR_INTERNAL',
-                payload: {error: eventParser.getError()},
+                payload: { error: eventParser.getError() },
                 reason: 'Failed to generate system',
                 created: Date.now(),
             });
@@ -94,15 +94,14 @@ function sendError(err: Error, res: Response) {
         sendEvent(res, {
             type: 'ERROR_INTERNAL',
             created: Date.now(),
-            payload: {error: err.message},
+            payload: { error: err.message },
             reason: 'Failed while sending prompt',
         });
     } else {
-        res.status(400).send({error: err.message});
+        res.status(400).send({ error: err.message });
     }
 }
 
-
 function streamStormPartialResponse(result: StormStream, res: Response) {
     return new Promise<void>((resolve, reject) => {
         result.on('data', (data) => {

package/src/storm/stormClient.ts

@@ -34,6 +34,10 @@ class StormClient {
             //headers['Authorization'] = `Bearer ${api.getAccessToken()}`; //TODO: Enable authentication
         }
 
+        if (body.conversationId) {
+            headers['conversationId'] = body.conversationId;
+        }
+
         return {
             url,
             method: method,

package/src/storm/stream.ts

@@ -74,6 +74,7 @@ export interface ConversationItem {
 
 export interface StormContextRequest<T = string> {
     history?: ConversationItem[];
+    conversationId?: string;
     prompt: T;
 }
 

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

@@ -169,17 +169,9 @@ describe('event-parser', () => {
 
         const serviceBlockInstance = result.plan.spec.blocks[0];
         expect(serviceBlockInstance.name).toBe('service');
-        expect(serviceBlockInstance.dimensions.width).toBe(150);
-        expect(serviceBlockInstance.dimensions.height).toBe(200);
-        expect(serviceBlockInstance.dimensions.top).toBe(3);
-        expect(serviceBlockInstance.dimensions.left).toBe(6);
 
         const uiBlockInstance = result.plan.spec.blocks[1];
         expect(uiBlockInstance.name).toBe('ui');
-        expect(uiBlockInstance.dimensions.width).toBe(150);
-        expect(uiBlockInstance.dimensions.height).toBe(200);
-        expect(uiBlockInstance.dimensions.top).toBe(107);
-        expect(uiBlockInstance.dimensions.left).toBe(112);
 
         expect(result.plan.spec.connections.length).toBe(1);
         expect(result.plan.spec.connections[0].consumer.blockId).toBe(uiBlockInstance.id);