@kapeta/local-cluster-service 0.47.0 → 0.47.2

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

@@ -3,17 +3,32 @@
  * Copyright 2023 Kapeta Inc.
  * SPDX-License-Identifier: BUSL-1.1
  */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StormEventParser = exports.resolveOptions = void 0;
 const nodejs_utils_1 = require("@kapeta/nodejs-utils");
 const kaplang_core_1 = require("@kapeta/kaplang-core");
-const node_uuid_1 = __importDefault(require("node-uuid"));
+const uuid_1 = require("uuid");
 const definitionsManager_1 = require("../definitionsManager");
-const ngraph_graph_1 = __importDefault(require("ngraph.graph"));
-const ngraph_forcelayout_1 = __importDefault(require("ngraph.forcelayout"));
+function prettifyKaplang(source) {
+    if (!source || !source.trim()) {
+        return '';
+    }
+    try {
+        const ast = kaplang_core_1.DSLParser.parse(source, {
+            ignoreSemantics: true,
+            types: true,
+            methods: true,
+            rest: true,
+            extends: true,
+            generics: true,
+        });
+        return kaplang_core_1.KaplangWriter.write(ast.entities ?? []);
+    }
+    catch (e) {
+        console.warn('Failed to prettify source:\n%s', source);
+        return source;
+    }
+}
 async function resolveOptions() {
     // Predefined types for now - TODO: Allow user to select / change
     const blockTypeService = await definitionsManager_1.definitionsManager.getLatestDefinition('kapeta/block-type-service');
@@ -89,7 +104,6 @@ async function resolveOptions() {
     };
 }
 exports.resolveOptions = resolveOptions;
-const LAYOUT_MARGIN = 50;
 class StormEventParser {
     events = [];
     planName = '';
@@ -110,6 +124,7 @@ class StormEventParser {
     }
     addEvent(handle, evt) {
         this.events.push(evt);
+        console.log('evt', evt);
         switch (evt.type) {
             case 'CREATE_PLAN_PROPERTIES':
                 this.planName = evt.payload.name;
@@ -131,13 +146,13 @@ 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);
@@ -153,55 +168,21 @@ class StormEventParser {
         return this.events;
     }
     isValid() {
+        if (!this.planName) {
+            return false;
+        }
         return !this.failed;
     }
     getError() {
         return this.error;
     }
-    applyLayoutToBlocks(result) {
-        const graph = (0, ngraph_graph_1.default)();
-        const blockInstances = {};
-        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 = (0, ngraph_forcelayout_1.default)(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;
-    }
     toResult(handle) {
-        const planRef = this.toRef(handle, this.planName);
+        const planRef = this.toRef(handle, this.planName ?? 'undefined');
         const blockDefinitions = this.toBlockDefinitions(handle);
         const refIdMap = {};
         const blocks = Object.entries(blockDefinitions).map(([ref, block]) => {
-            const id = node_uuid_1.default.v4();
+            // Create a deterministic uuid
+            const id = (0, uuid_1.v5)(ref, uuid_1.v5.URL);
             refIdMap[ref] = id;
             return {
                 id,
@@ -249,6 +230,28 @@ class StormEventParser {
                 console.warn('Client resource not found: %s on %s', apiConnection.toResource, clientConsumerRef.toNormalizedString(), apiConnection);
                 return;
             }
+            if (apiProviderBlock.content.spec.entities?.source?.value) {
+                if (!clientConsumerBlock.content.spec.entities) {
+                    clientConsumerBlock.content.spec.entities = {
+                        types: [],
+                        source: {
+                            type: kaplang_core_1.KAPLANG_ID,
+                            version: kaplang_core_1.KAPLANG_VERSION,
+                            value: '',
+                        },
+                    };
+                }
+                const clientTypes = kaplang_core_1.DSLDataTypeParser.parse(clientConsumerBlock.content.spec.entities.source.value);
+                const apiTypes = kaplang_core_1.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 = kaplang_core_1.KaplangWriter.write(clientTypes);
+            }
             clientResource.spec.methods = apiResource.spec.methods;
             clientResource.spec.source = apiResource.spec.source;
         });
@@ -267,9 +270,7 @@ class StormEventParser {
                     blockId: refIdMap[fromRef.toNormalizedString()],
                     resourceName: connection.fromResource,
                 },
-                mapping: {
-                //TODO: Add mapping
-                },
+                mapping: this.toConnectionMapping(handle, connection, blockDefinitions),
             };
         });
         const plan = {
@@ -284,10 +285,10 @@ class StormEventParser {
                 connections,
             },
         };
-        return this.applyLayoutToBlocks({
+        return {
             plan,
             blocks: Object.values(blockDefinitions),
-        });
+        };
     }
     toSafeName(name) {
         return name.toLowerCase().replace(/[^0-9a-z-]/gi, '');
@@ -498,6 +499,33 @@ class StormEventParser {
         }
         return '';
     }
+    toConnectionMapping(handle, connection, blockDefinitions) {
+        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 = kaplang_core_1.DSLConverters.toSchemaMethods(kaplang_core_1.DSLAPIParser.parse(apiResource.spec?.source?.value ?? '', {
+            ignoreSemantics: true,
+        }));
+        const mapping = {};
+        Object.entries(apiMethods).forEach(([methodId, method]) => {
+            mapping[methodId] = {
+                targetId: methodId,
+                type: 'EXACT',
+            };
+        });
+        return mapping;
+    }
     toPortType(type) {
         switch (type) {
             case 'API':

package/dist/esm/src/storm/events.d.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' | 'DATABASE' | 'CLIENT' | 'JWTPROVIDER' | 'JWTCONSUMER' | 'WEBFRAGMENT' | 'WEBPAGE' | 'SMTPCLIENT' | 'EXTERNAL_API' | 'SUBSCRIBER' | 'PUBLISHER' | 'QUEUE' | 'EXCHANGE';
 export type StormBlockType = 'BACKEND' | 'FRONTEND' | 'GATEWAY' | 'MQ' | 'CLI' | 'DESKTOP';
 export interface StormBlockInfo {
@@ -117,6 +117,7 @@ export interface StormEventFile {
     payload: {
         filename: string;
         content: string;
+        blockName: string;
         blockRef: string;
     };
 }

package/dist/esm/src/storm/stormClient.js

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

package/dist/esm/src/storm/stream.d.ts

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

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

@@ -150,16 +150,8 @@ describe('event-parser', () => {
         expect(dbResource?.spec.source.value).toContain('type Entity');
         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);
         expect(result.plan.spec.connections[0].consumer.resourceName).toBe(clientResource?.metadata.name);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@kapeta/local-cluster-service",
-    "version": "0.47.0",
+    "version": "0.47.2",
     "description": "Manages configuration, ports and service discovery for locally running Kapeta systems",
     "type": "commonjs",
     "exports": {
@@ -52,7 +52,7 @@
     "dependencies": {
         "@kapeta/codegen": "^1.4.0",
         "@kapeta/config-mapper": "^1.2.1",
-        "@kapeta/kaplang-core": "^1.16.0",
+        "@kapeta/kaplang-core": "^1.17.1",
         "@kapeta/local-cluster-config": "^0.4.2",
         "@kapeta/nodejs-api-client": ">=0.2.0 <2",
         "@kapeta/nodejs-process": "^1.2.0",
@@ -74,8 +74,6 @@
         "gunzip-maybe": "^1.4.2",
         "lodash": "^4.17.15",
         "md5": "2.2.1",
-        "ngraph.forcelayout": "^3.3.1",
-        "ngraph.graph": "^20.0.1",
         "node-cache": "^5.1.2",
         "node-uuid": "^1.4.8",
         "parse-data-uri": "^0.2.0",
@@ -85,6 +83,7 @@
         "stream-json": "^1.8.0",
         "tar-stream": "^3.1.6",
         "typescript": "^5.1.6",
+        "uuid": "^9.0.1",
         "yaml": "^1.6.0"
     },
     "devDependencies": {
@@ -103,6 +102,7 @@
         "@types/node-uuid": "^0.0.29",
         "@types/request": "^2.48.8",
         "@types/tar-stream": "^2.2.2",
+        "@types/uuid": "^9.0.8",
         "eslint": "^8.42.0",
         "eslint-config-prettier": "^8.8.0",
         "jest": "^29.6.4",

package/src/storm/codegen.ts

@@ -8,7 +8,7 @@ import { AIFileTypes, BlockCodeGenerator, GeneratedFile, GeneratedResult } from
 import { BlockDefinition } from '@kapeta/schemas';
 import { codeGeneratorManager } from '../codeGeneratorManager';
 import { STORM_ID, stormClient } from './stormClient';
-import { ScreenTemplate, StormEvent, StormEventFile, StormEventScreen } from './events';
+import { StormEvent, StormEventFile } from './events';
 import { BlockDefinitionInfo } from './event-parser';
 import { ConversationItem, StormFileImplementationPrompt, StormFileInfo, StormStream } from './stream';
 import { KapetaURI } from '@kapeta/nodejs-utils';
@@ -42,16 +42,16 @@ export class StormCodegen {
         return this.out;
     }
 
-    private handleTemplateFileOutput(blockUri: KapetaURI, template: StormFileInfo, data: StormEvent) {
+    private handleTemplateFileOutput(blockUri: KapetaURI, aiName: string, template: StormFileInfo, data: StormEvent) {
         switch (data.type) {
             case 'FILE':
                 template.filename = data.payload.filename;
                 template.content = data.payload.content;
-                return this.handleFileOutput(blockUri, data);
+                return this.handleFileOutput(blockUri, aiName, data);
         }
     }
 
-    private handleUiOutput(blockUri: KapetaURI, data: StormEvent) {
+    private handleUiOutput(blockUri: KapetaURI, aiName: string, data: StormEvent) {
         switch (data.type) {
             case 'SCREEN':
                 this.out.emit('data', {
@@ -60,18 +60,18 @@ export class StormCodegen {
                     created: Date.now(),
                     payload: {
                         ...data.payload,
-                        blockName: blockUri.toNormalizedString(),
+                        blockName: aiName,
                     },
                 });
             case 'FILE':
-                return this.handleFileOutput(blockUri, data);
+                return this.handleFileOutput(blockUri, aiName, data);
         }
     }
 
-    private handleFileOutput(blockUri: KapetaURI, data: StormEvent) {
+    private handleFileOutput(blockUri: KapetaURI, aiName: string, data: StormEvent) {
         switch (data.type) {
             case 'FILE':
-                this.emitFile(blockUri, data.payload.filename, data.payload.content, data.reason);
+                this.emitFile(blockUri, aiName, data.payload.filename, data.payload.content, data.reason);
                 return {
                     type: 'FILE',
                     created: Date.now(),
@@ -96,7 +96,7 @@ export class StormCodegen {
         const allFiles = this.toStormFiles(generatedResult);
 
         // Send all the non-ai files to the stream
-        this.emitFiles(block.uri, allFiles);
+        this.emitFiles(block.uri, block.aiName, allFiles);
 
         const relevantFiles: StormFileInfo[] = allFiles.filter(
             (file) => file.type !== AIFileTypes.IGNORE && file.type !== AIFileTypes.WEB_SCREEN
@@ -112,7 +112,7 @@ export class StormCodegen {
             });
 
             uiStream.on('data', (evt) => {
-                this.handleUiOutput(block.uri, evt);
+                this.handleUiOutput(block.uri, block.aiName, evt);
             });
 
             await uiStream.waitForDone();
@@ -128,6 +128,7 @@ export class StormCodegen {
         if (serviceFiles.length > 0) {
             await this.processTemplates(
                 block.uri,
+                block.aiName,
                 stormClient.createServiceImplementation.bind(stormClient),
                 serviceFiles,
                 contextFiles
@@ -138,7 +139,7 @@ export class StormCodegen {
     /**
      * Emits the text-based files to the stream
      */
-    private emitFiles(uri: KapetaURI, files: StormFileInfo[]) {
+    private emitFiles(uri: KapetaURI, aiName: string, files: StormFileInfo[]) {
         files.forEach((file) => {
             if (!file.content || typeof file.content !== 'string') {
                 return;
@@ -156,11 +157,17 @@ export class StormCodegen {
                 return;
             }
 
-            this.emitFile(uri, file.filename, file.content);
+            this.emitFile(uri, aiName, file.filename, file.content);
         });
     }
 
-    private emitFile(uri: KapetaURI, filename: string, content: string, reason: string = 'File generated') {
+    private emitFile(
+        uri: KapetaURI,
+        blockName: string,
+        filename: string,
+        content: string,
+        reason: string = 'File generated'
+    ) {
         this.out.emit('data', {
             type: 'FILE',
             reason,
@@ -168,6 +175,7 @@ export class StormCodegen {
             payload: {
                 filename: filename,
                 content: content,
+                blockName,
                 blockRef: uri.toNormalizedString(),
             },
         } satisfies StormEventFile);
@@ -178,6 +186,7 @@ export class StormCodegen {
      */
     private async processTemplates(
         blockUri: KapetaURI,
+        aiName: string,
         generator: ImplementationGenerator,
         templates: StormFileInfo[],
         contextFiles: StormFileInfo[]
@@ -192,7 +201,7 @@ export class StormCodegen {
             const files: StormEventFile[] = [];
 
             stream.on('data', (evt) => {
-                const file = this.handleTemplateFileOutput(blockUri, templateFile, evt);
+                const file = this.handleTemplateFileOutput(blockUri, aiName, templateFile, evt);
                 if (file) {
                     files.push(file);
                 }