@kapeta/local-cluster-service 0.60.1 → 0.60.3

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [0.60.3](https://github.com/kapetacom/local-cluster-service/compare/v0.60.2...v0.60.3) (2024-08-07)
+
+
+### Bug Fixes
+
+* rename conflicting entities when creating connections ([a5125cf](https://github.com/kapetacom/local-cluster-service/commit/a5125cf652b808cd94cf3ebe0df853f0c7256566))
+
+## [0.60.2](https://github.com/kapetacom/local-cluster-service/compare/v0.60.1...v0.60.2) (2024-08-06)
+
+
+### Bug Fixes
+
+* actually use the new toSafeArtifactName() function ([41f5033](https://github.com/kapetacom/local-cluster-service/commit/41f5033d0a2b2cd21ff6954d2ef3468644ee56c7))
+
 ## [0.60.1](https://github.com/kapetacom/local-cluster-service/compare/v0.60.0...v0.60.1) (2024-08-06)
 
 

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

@@ -313,6 +313,7 @@ class StormEventParser {
                 }
                 return;
             }
+            const renamedEntities = {};
             if (apiProviderBlock.content.spec.entities?.source?.value) {
                 if (!clientConsumerBlock.content.spec.entities) {
                     clientConsumerBlock.content.spec.entities = {
@@ -328,17 +329,79 @@ class StormEventParser {
                 const apiTypes = kaplang_core_1.DSLDataTypeParser.parse(apiProviderBlock.content.spec.entities?.source?.value, {
                     ignoreSemantics: true,
                 });
+                const newTypes = [];
+                const clientTypeExists = function (apiType) {
+                    const clientType = clientTypes.find((t) => t.name === apiType.name);
+                    return clientType != undefined;
+                };
+                const clientTypeIsCompatible = function (apiType) {
+                    const clientType = clientTypes.find((t) => t.name === apiType.name);
+                    return (clientType != undefined &&
+                        kaplang_core_1.DSLCompatibilityHelper.isDataCompatible(apiType, clientType, apiTypes, clientTypes));
+                };
                 apiTypes.forEach((apiType) => {
-                    if (clientTypes.some((clientType) => clientType.name === apiType.name)) {
-                        // Already exists
+                    if (!clientTypeExists(apiType)) {
+                        newTypes.push(apiType);
+                        return;
+                    }
+                    if (clientTypeIsCompatible(apiType)) {
                         return;
                     }
-                    clientTypes.push(apiType);
+                    const originalName = apiType.name;
+                    const toEntity = lodash_1.default.cloneDeep(apiType);
+                    let conflictCount = 1;
+                    while (clientTypeExists(toEntity) && !clientTypeIsCompatible(toEntity)) {
+                        toEntity.name = `${originalName}_${conflictCount}`;
+                        conflictCount++;
+                    }
+                    newTypes.push(toEntity);
+                    renamedEntities[originalName] = toEntity.name;
+                });
+                Object.entries(renamedEntities).forEach(([from, to]) => {
+                    newTypes.forEach((newType) => {
+                        if (newType.type !== kaplang_core_1.DSLEntityType.DATATYPE) {
+                            return;
+                        }
+                        if (!newType.properties) {
+                            return;
+                        }
+                        newType.properties.forEach((property) => {
+                            const type = kaplang_core_1.DSLTypeHelper.asType(property.type);
+                            if (from !== type.name) {
+                                return;
+                            }
+                            type.name = to;
+                            property.type = type;
+                        });
+                    });
                 });
-                clientConsumerBlock.content.spec.entities.source.value = kaplang_core_1.KaplangWriter.write(clientTypes);
+                clientConsumerBlock.content.spec.entities.source.value = kaplang_core_1.KaplangWriter.write([
+                    ...clientTypes,
+                    ...newTypes,
+                ]);
             }
             clientResource.spec.methods = apiResource.spec.methods;
-            clientResource.spec.source = apiResource.spec.source;
+            if (Object.keys(renamedEntities).length == 0) {
+                clientResource.spec.source = apiResource.spec.source;
+            }
+            else {
+                // entities were renamed - rename references as well
+                const targetSource = lodash_1.default.cloneDeep(apiResource.spec.source);
+                const methods = kaplang_core_1.DSLAPIParser.parse(targetSource.value, {
+                    ignoreSemantics: true,
+                });
+                const resolver = new kaplang_core_1.DSLReferenceResolver();
+                resolver.visitReferences(methods, (name) => {
+                    const type = kaplang_core_1.DSLTypeHelper.asType(name);
+                    if (renamedEntities[type.name]) {
+                        type.name = renamedEntities[type.name];
+                        return type;
+                    }
+                    return name;
+                });
+                targetSource.value = kaplang_core_1.KaplangWriter.write(methods);
+                clientResource.spec.source = targetSource;
+            }
         });
         const connections = this.connections.map((connection) => {
             const fromRef = StormEventParser.toRef(handle, connection.fromComponent);
@@ -677,7 +740,7 @@ class StormEventParser {
         let options = {};
         if (kind.includes('java')) {
             const groupId = `ai.${StormEventParser.toSafeName(handle)}`;
-            const artifactId = StormEventParser.toSafeName(this.planName);
+            const artifactId = StormEventParser.toSafeArtifactName(this.planName);
             options = {
                 groupId,
                 artifactId,

package/dist/cjs/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/dist/cjs/test/storm/event-parser.test.js

@@ -12,6 +12,8 @@ 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"));
+const duplicate_entities_events_json_1 = __importDefault(require("./duplicate-entities-events.json"));
+const kaplang_core_1 = require("@kapeta/kaplang-core");
 exports.parserOptions = {
     serviceKind: 'kapeta/block-service:local',
     serviceLanguage: 'kapeta/language-target-java-spring-boot:local',
@@ -217,4 +219,33 @@ describe('event-parser', () => {
         const safeName = event_parser_1.StormEventParser.toSafeArtifactName('Browser-based CRM Application');
         expect(safeName).toBe('browserbasedcrmapplication');
     });
+    it('rename duplicate entity names', async () => {
+        const events = duplicate_entities_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');
+        const apiGateway = result.blocks.find((block) => block.aiName === 'api-gateway');
+        expect(apiGateway).toBeDefined();
+        const dataTypes = kaplang_core_1.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;
+        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 = kaplang_core_1.DSLAPIParser.parse(commentsClient.spec.source.value, {
+            ignoreSemantics: true,
+        });
+        expect(methods).toBeDefined();
+        expect(methods.length).toBe(1);
+        const method = methods[0];
+        expect(method.returnType).toBe('Result_1');
+    });
 });

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

@@ -313,6 +313,7 @@ class StormEventParser {
                 }
                 return;
             }
+            const renamedEntities = {};
             if (apiProviderBlock.content.spec.entities?.source?.value) {
                 if (!clientConsumerBlock.content.spec.entities) {
                     clientConsumerBlock.content.spec.entities = {
@@ -328,17 +329,79 @@ class StormEventParser {
                 const apiTypes = kaplang_core_1.DSLDataTypeParser.parse(apiProviderBlock.content.spec.entities?.source?.value, {
                     ignoreSemantics: true,
                 });
+                const newTypes = [];
+                const clientTypeExists = function (apiType) {
+                    const clientType = clientTypes.find((t) => t.name === apiType.name);
+                    return clientType != undefined;
+                };
+                const clientTypeIsCompatible = function (apiType) {
+                    const clientType = clientTypes.find((t) => t.name === apiType.name);
+                    return (clientType != undefined &&
+                        kaplang_core_1.DSLCompatibilityHelper.isDataCompatible(apiType, clientType, apiTypes, clientTypes));
+                };
                 apiTypes.forEach((apiType) => {
-                    if (clientTypes.some((clientType) => clientType.name === apiType.name)) {
-                        // Already exists
+                    if (!clientTypeExists(apiType)) {
+                        newTypes.push(apiType);
+                        return;
+                    }
+                    if (clientTypeIsCompatible(apiType)) {
                         return;
                     }
-                    clientTypes.push(apiType);
+                    const originalName = apiType.name;
+                    const toEntity = lodash_1.default.cloneDeep(apiType);
+                    let conflictCount = 1;
+                    while (clientTypeExists(toEntity) && !clientTypeIsCompatible(toEntity)) {
+                        toEntity.name = `${originalName}_${conflictCount}`;
+                        conflictCount++;
+                    }
+                    newTypes.push(toEntity);
+                    renamedEntities[originalName] = toEntity.name;
+                });
+                Object.entries(renamedEntities).forEach(([from, to]) => {
+                    newTypes.forEach((newType) => {
+                        if (newType.type !== kaplang_core_1.DSLEntityType.DATATYPE) {
+                            return;
+                        }
+                        if (!newType.properties) {
+                            return;
+                        }
+                        newType.properties.forEach((property) => {
+                            const type = kaplang_core_1.DSLTypeHelper.asType(property.type);
+                            if (from !== type.name) {
+                                return;
+                            }
+                            type.name = to;
+                            property.type = type;
+                        });
+                    });
                 });
-                clientConsumerBlock.content.spec.entities.source.value = kaplang_core_1.KaplangWriter.write(clientTypes);
+                clientConsumerBlock.content.spec.entities.source.value = kaplang_core_1.KaplangWriter.write([
+                    ...clientTypes,
+                    ...newTypes,
+                ]);
             }
             clientResource.spec.methods = apiResource.spec.methods;
-            clientResource.spec.source = apiResource.spec.source;
+            if (Object.keys(renamedEntities).length == 0) {
+                clientResource.spec.source = apiResource.spec.source;
+            }
+            else {
+                // entities were renamed - rename references as well
+                const targetSource = lodash_1.default.cloneDeep(apiResource.spec.source);
+                const methods = kaplang_core_1.DSLAPIParser.parse(targetSource.value, {
+                    ignoreSemantics: true,
+                });
+                const resolver = new kaplang_core_1.DSLReferenceResolver();
+                resolver.visitReferences(methods, (name) => {
+                    const type = kaplang_core_1.DSLTypeHelper.asType(name);
+                    if (renamedEntities[type.name]) {
+                        type.name = renamedEntities[type.name];
+                        return type;
+                    }
+                    return name;
+                });
+                targetSource.value = kaplang_core_1.KaplangWriter.write(methods);
+                clientResource.spec.source = targetSource;
+            }
         });
         const connections = this.connections.map((connection) => {
             const fromRef = StormEventParser.toRef(handle, connection.fromComponent);
@@ -677,7 +740,7 @@ class StormEventParser {
         let options = {};
         if (kind.includes('java')) {
             const groupId = `ai.${StormEventParser.toSafeName(handle)}`;
-            const artifactId = StormEventParser.toSafeName(this.planName);
+            const artifactId = StormEventParser.toSafeArtifactName(this.planName);
             options = {
                 groupId,
                 artifactId,

package/dist/esm/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/dist/esm/test/storm/event-parser.test.js

@@ -12,6 +12,8 @@ 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"));
+const duplicate_entities_events_json_1 = __importDefault(require("./duplicate-entities-events.json"));
+const kaplang_core_1 = require("@kapeta/kaplang-core");
 exports.parserOptions = {
     serviceKind: 'kapeta/block-service:local',
     serviceLanguage: 'kapeta/language-target-java-spring-boot:local',
@@ -217,4 +219,33 @@ describe('event-parser', () => {
         const safeName = event_parser_1.StormEventParser.toSafeArtifactName('Browser-based CRM Application');
         expect(safeName).toBe('browserbasedcrmapplication');
     });
+    it('rename duplicate entity names', async () => {
+        const events = duplicate_entities_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');
+        const apiGateway = result.blocks.find((block) => block.aiName === 'api-gateway');
+        expect(apiGateway).toBeDefined();
+        const dataTypes = kaplang_core_1.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;
+        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 = kaplang_core_1.DSLAPIParser.parse(commentsClient.spec.source.value, {
+            ignoreSemantics: true,
+        });
+        expect(methods).toBeDefined();
+        expect(methods.length).toBe(1);
+        const method = methods[0];
+        expect(method.returnType).toBe('Result_1');
+    });
 });

package/package.json

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

package/src/storm/event-parser.ts

@@ -24,12 +24,16 @@ import {
 import { KapetaURI, normalizeKapetaUri, parseKapetaUri } from '@kapeta/nodejs-utils';
 import {
     DSLAPIParser,
+    DSLCompatibilityHelper,
     DSLController,
     DSLConverters,
+    DSLData,
     DSLDataTypeParser,
     DSLEntityType,
     DSLMethod,
     DSLParser,
+    DSLReferenceResolver,
+    DSLTypeHelper,
     KAPLANG_ID,
     KAPLANG_VERSION,
     KaplangWriter,
@@ -413,13 +417,11 @@ export class StormEventParser {
                     return;
                 }
 
-                const apiResource = apiProviderBlock.content.spec.providers?.find(
-                    (p) => {
-                        const pKind = normalizeKapetaUri(p.kind);
-                        const apiKind = normalizeKapetaUri(this.options.apiKind);
-                        return pKind === apiKind && p.metadata.name === apiConnection.fromResource
-                    }
-                );
+                const apiResource = apiProviderBlock.content.spec.providers?.find((p) => {
+                    const pKind = normalizeKapetaUri(p.kind);
+                    const apiKind = normalizeKapetaUri(this.options.apiKind);
+                    return pKind === apiKind && p.metadata.name === apiConnection.fromResource;
+                });
 
                 if (!apiResource) {
                     if (warn) {
@@ -454,6 +456,8 @@ export class StormEventParser {
                     return;
                 }
 
+                const renamedEntities: { [from: string]: string } = {};
+
                 if (apiProviderBlock.content.spec.entities?.source?.value) {
                     if (!clientConsumerBlock.content.spec.entities) {
                         clientConsumerBlock.content.spec.entities = {
@@ -473,19 +477,99 @@ export class StormEventParser {
                     const apiTypes = DSLDataTypeParser.parse(apiProviderBlock.content.spec.entities?.source?.value, {
                         ignoreSemantics: true,
                     });
+                    const newTypes: DSLData[] = [];
+
+                    const clientTypeExists = function (apiType: DSLData): boolean {
+                        const clientType = clientTypes.find((t) => t.name === apiType.name);
+                        return clientType != undefined;
+                    };
+
+                    const clientTypeIsCompatible = function (apiType: DSLData): boolean {
+                        const clientType = clientTypes.find((t) => t.name === apiType.name);
+                        return (
+                            clientType != undefined &&
+                            DSLCompatibilityHelper.isDataCompatible(apiType, clientType, apiTypes, clientTypes)
+                        );
+                    };
 
                     apiTypes.forEach((apiType) => {
-                        if (clientTypes.some((clientType) => clientType.name === apiType.name)) {
-                            // Already exists
+                        if (!clientTypeExists(apiType)) {
+                            newTypes.push(apiType);
                             return;
                         }
-                        clientTypes.push(apiType);
+
+                        if (clientTypeIsCompatible(apiType)) {
+                            return;
+                        }
+
+                        const originalName = apiType.name;
+                        const toEntity = _.cloneDeep(apiType);
+                        let conflictCount = 1;
+
+                        while (clientTypeExists(toEntity) && !clientTypeIsCompatible(toEntity)) {
+                            toEntity.name = `${originalName}_${conflictCount}`;
+                            conflictCount++;
+                        }
+
+                        newTypes.push(toEntity);
+                        renamedEntities[originalName] = toEntity.name;
+                    });
+
+                    Object.entries(renamedEntities).forEach(([from, to]) => {
+                        newTypes.forEach((newType) => {
+                            if (newType.type !== DSLEntityType.DATATYPE) {
+                                return;
+                            }
+
+                            if (!newType.properties) {
+                                return;
+                            }
+
+                            newType.properties.forEach((property) => {
+                                const type = DSLTypeHelper.asType(property.type);
+
+                                if (from !== type.name) {
+                                    return;
+                                }
+
+                                type.name = to;
+                                property.type = type;
+                            });
+                        });
                     });
 
-                    clientConsumerBlock.content.spec.entities.source!.value = KaplangWriter.write(clientTypes);
+                    clientConsumerBlock.content.spec.entities.source!.value = KaplangWriter.write([
+                        ...clientTypes,
+                        ...newTypes,
+                    ]);
                 }
+
                 clientResource.spec.methods = apiResource.spec.methods;
-                clientResource.spec.source = apiResource.spec.source;
+
+                if (Object.keys(renamedEntities).length == 0) {
+                    clientResource.spec.source = apiResource.spec.source;
+                } else {
+                    // entities were renamed - rename references as well
+                    const targetSource = _.cloneDeep(apiResource.spec.source);
+                    const methods = DSLAPIParser.parse(targetSource.value, {
+                        ignoreSemantics: true,
+                    });
+
+                    const resolver = new DSLReferenceResolver();
+                    resolver.visitReferences(methods, (name) => {
+                        const type = DSLTypeHelper.asType(name);
+
+                        if (renamedEntities[type.name]) {
+                            type.name = renamedEntities[type.name];
+                            return type;
+                        }
+
+                        return name;
+                    });
+
+                    targetSource.value = KaplangWriter.write(methods);
+                    clientResource.spec.source = targetSource;
+                }
             });
 
         const connections: Connection[] = this.connections.map((connection) => {
@@ -802,13 +886,11 @@ export class StormEventParser {
             return;
         }
 
-        const apiResource = apiProviderBlock.content.spec.providers?.find(
-            (p) => {
-                const pKind = normalizeKapetaUri(p.kind);
-                const apiKind = normalizeKapetaUri(this.options.apiKind);
-                return pKind === apiKind && p.metadata.name === connection.fromResource
-            }
-            );
+        const apiResource = apiProviderBlock.content.spec.providers?.find((p) => {
+            const pKind = normalizeKapetaUri(p.kind);
+            const apiKind = normalizeKapetaUri(this.options.apiKind);
+            return pKind === apiKind && p.metadata.name === connection.fromResource;
+        });
 
         if (!apiResource) {
             if (warn) {
@@ -882,7 +964,7 @@ export class StormEventParser {
 
         if (kind.includes('java')) {
             const groupId = `ai.${StormEventParser.toSafeName(handle)}`;
-            const artifactId = StormEventParser.toSafeName(this.planName);
+            const artifactId = StormEventParser.toSafeArtifactName(this.planName);
             options = {
                 groupId,
                 artifactId,

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');
+    });
 });