@kapeta/local-cluster-service 0.55.1 → 0.55.3

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.1",
+    "version": "0.55.3",
     "description": "Manages configuration, ports and service discovery for locally running Kapeta systems",
     "type": "commonjs",
     "exports": {

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) {
@@ -281,11 +282,15 @@ export class StormEventParser {
                 this.planDescription = evt.payload.description;
                 break;
             case 'CREATE_BLOCK':
+                const apis = this.blocks[evt.payload.name]?.apis;
+                const models = this.blocks[evt.payload.name]?.models;
+                const types = this.blocks[evt.payload.name]?.types;
+
                 this.blocks[evt.payload.name] = {
                     ...evt.payload,
-                    apis: [],
-                    models: [],
-                    types: [],
+                    apis: apis ?? [],
+                    models: models ?? [],
+                    types: types ?? [],
                 };
                 evt.payload.blockRef = StormEventParser.toRef(handle, evt.payload.name).toNormalizedString();
                 evt.payload.instanceId = StormEventParser.toInstanceIdFromRef(evt.payload.blockRef);
@@ -360,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 } = {};
@@ -405,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;
                 }
 
@@ -424,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;
                 }
 
@@ -483,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;
         });
 
@@ -517,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);
             }
@@ -685,18 +694,18 @@ export class StormEventParser {
                 }
             }
 
-                if (!exactMatch) {
-                    // if we couldn't place the given api on the exact resource we just park it on the first
-                    // available rest resource
-                    const firstKey = Object.keys(apiResources)[0];
-                    const firstEntry = apiResources[firstKey];
-                    if (firstEntry) {
-                        firstEntry.spec.source.value += api + '\n\n';
-                    } else {
-                        console.warn('Unable to find resource for API', api);
-                    }
+            if (!exactMatch) {
+                // if we couldn't place the given api on the exact resource we just park it on the first
+                // available rest resource
+                const firstKey = Object.keys(apiResources)[0];
+                const firstEntry = apiResources[firstKey];
+                if (firstEntry) {
+                    firstEntry.spec.source.value += api + '\n\n';
+                } else {
+                    // this might be ok as we might receive api and types before resources from the ai-service
                 }
-            });
+            }
+        });
 
         blockInfo.types.forEach((type) => {
             blockSpec.entities!.source!.value += type + '\n';
@@ -766,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;
@@ -785,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;
         }
 
@@ -884,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

@@ -103,7 +103,7 @@ 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;