@kapeta/local-cluster-service 0.46.0 → 0.47.1

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [0.47.1](https://github.com/kapetacom/local-cluster-service/compare/v0.47.0...v0.47.1) (2024-05-30)
+
+
+### Bug Fixes
+
+* Make UUIDs deterministic to allow cleaner updates ([#150](https://github.com/kapetacom/local-cluster-service/issues/150)) ([0e3bbec](https://github.com/kapetacom/local-cluster-service/commit/0e3bbecb00d52e2cc0f5e0d8adb9953f40e6e253))
+
+# [0.47.0](https://github.com/kapetacom/local-cluster-service/compare/v0.46.0...v0.47.0) (2024-05-29)
+
+
+### Features
+
+* Added tests for event parsing and layouting of nodes ([#149](https://github.com/kapetacom/local-cluster-service/issues/149)) ([d36afa9](https://github.com/kapetacom/local-cluster-service/commit/d36afa905d0c66c4562b4eccf07c067efe6b3c9c))
+
 # [0.46.0](https://github.com/kapetacom/local-cluster-service/compare/v0.45.0...v0.46.0) (2024-05-28)
 
 

package/dist/cjs/src/storm/codegen.js

@@ -28,15 +28,15 @@ class StormCodegen {
     getStream() {
         return this.out;
     }
-    handleTemplateFileOutput(blockUri, template, data) {
+    handleTemplateFileOutput(blockUri, aiName, template, data) {
         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);
         }
     }
-    handleUiOutput(blockUri, data) {
+    handleUiOutput(blockUri, aiName, data) {
         switch (data.type) {
             case 'SCREEN':
                 this.out.emit('data', {
@@ -45,17 +45,17 @@ 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);
         }
     }
-    handleFileOutput(blockUri, data) {
+    handleFileOutput(blockUri, aiName, data) {
         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(),
@@ -77,7 +77,7 @@ 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 = allFiles.filter((file) => file.type !== codegen_1.AIFileTypes.IGNORE && file.type !== codegen_1.AIFileTypes.WEB_SCREEN);
         const uiTemplates = allFiles.filter((file) => file.type === codegen_1.AIFileTypes.WEB_SCREEN);
         if (uiTemplates.length > 0) {
@@ -89,7 +89,7 @@ class StormCodegen {
                 prompt: this.userPrompt,
             });
             uiStream.on('data', (evt) => {
-                this.handleUiOutput(block.uri, evt);
+                this.handleUiOutput(block.uri, block.aiName, evt);
             });
             await uiStream.waitForDone();
         }
@@ -98,13 +98,13 @@ class StormCodegen {
         // Send the service and UI templates to the AI. These will be send one-by-one in addition to the context files
         const serviceFiles = allFiles.filter((file) => file.type === codegen_1.AIFileTypes.SERVICE);
         if (serviceFiles.length > 0) {
-            await this.processTemplates(block.uri, stormClient_1.stormClient.createServiceImplementation.bind(stormClient_1.stormClient), serviceFiles, contextFiles);
+            await this.processTemplates(block.uri, block.aiName, stormClient_1.stormClient.createServiceImplementation.bind(stormClient_1.stormClient), serviceFiles, contextFiles);
         }
     }
     /**
      * Emits the text-based files to the stream
      */
-    emitFiles(uri, files) {
+    emitFiles(uri, aiName, files) {
         files.forEach((file) => {
             if (!file.content || typeof file.content !== 'string') {
                 return;
@@ -119,10 +119,10 @@ class StormCodegen {
                 // They will need to be implemented by the AI
                 return;
             }
-            this.emitFile(uri, file.filename, file.content);
+            this.emitFile(uri, aiName, file.filename, file.content);
         });
     }
-    emitFile(uri, filename, content, reason = 'File generated') {
+    emitFile(uri, blockName, filename, content, reason = 'File generated') {
         this.out.emit('data', {
             type: 'FILE',
             reason,
@@ -130,6 +130,7 @@ class StormCodegen {
             payload: {
                 filename: filename,
                 content: content,
+                blockName,
                 blockRef: uri.toNormalizedString(),
             },
         });
@@ -137,7 +138,7 @@ class StormCodegen {
     /**
      * Sends the template to the AI and processes the response
      */
-    async processTemplates(blockUri, generator, templates, contextFiles) {
+    async processTemplates(blockUri, aiName, generator, templates, contextFiles) {
         const promises = templates.map(async (templateFile) => {
             const stream = await generator({
                 context: contextFiles,
@@ -146,7 +147,7 @@ class StormCodegen {
             });
             const files = [];
             stream.on('data', (evt) => {
-                const file = this.handleTemplateFileOutput(blockUri, templateFile, evt);
+                const file = this.handleTemplateFileOutput(blockUri, aiName, templateFile, evt);
                 if (file) {
                     files.push(file);
                 }

package/dist/cjs/src/storm/event-parser.d.ts

@@ -10,7 +10,7 @@ export interface BlockDefinitionInfo {
     content: BlockDefinition;
     aiName: string;
 }
-export interface ParsedResult {
+export interface StormDefinitions {
     plan: Plan;
     blocks: BlockDefinitionInfo[];
 }
@@ -51,12 +51,11 @@ export declare class StormEventParser {
     private options;
     constructor(options: StormOptions);
     private reset;
-    addEvent(evt: StormEvent): void;
+    addEvent(handle: string, evt: StormEvent): StormDefinitions;
     getEvents(): StormEvent[];
     isValid(): boolean;
     getError(): string;
-    private applyLayoutToBlocks;
-    toResult(handle: string): ParsedResult;
+    toResult(handle: string): StormDefinitions;
     private toSafeName;
     private toRef;
     toBlockDefinitions(handle: string): {
@@ -64,6 +63,7 @@ export declare class StormEventParser {
     };
     private toResourceKind;
     private toBlockKind;
+    private toConnectionMapping;
     private toPortType;
     private toBlockTarget;
     private toBlockTargetKind;

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

@@ -3,14 +3,11 @@
  * 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");
 async function resolveOptions() {
     // Predefined types for now - TODO: Allow user to select / change
@@ -105,8 +102,9 @@ class StormEventParser {
         this.blocks = {};
         this.connections = [];
     }
-    addEvent(evt) {
+    addEvent(handle, evt) {
         this.events.push(evt);
+        console.log('evt', evt);
         switch (evt.type) {
             case 'CREATE_PLAN_PROPERTIES':
                 this.planName = evt.payload.name;
@@ -144,26 +142,27 @@ class StormEventParser {
             case 'FILE':
                 break;
         }
+        return this.toResult(handle);
     }
     getEvents() {
         return this.events;
     }
     isValid() {
+        if (!this.planName) {
+            return false;
+        }
         return !this.failed;
     }
     getError() {
         return this.error;
     }
-    applyLayoutToBlocks(result) {
-        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 screens = {};
         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,
@@ -174,7 +173,7 @@ class StormEventParser {
                 dimensions: {
                     left: 0,
                     top: 0,
-                    width: 200,
+                    width: 150,
                     height: 200,
                 },
             };
@@ -211,6 +210,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;
         });
@@ -229,9 +250,7 @@ class StormEventParser {
                     blockId: refIdMap[fromRef.toNormalizedString()],
                     resourceName: connection.fromResource,
                 },
-                mapping: {
-                //TODO: Add mapping
-                },
+                mapping: this.toConnectionMapping(handle, connection, blockDefinitions),
             };
         });
         const plan = {
@@ -246,10 +265,10 @@ class StormEventParser {
                 connections,
             },
         };
-        return this.applyLayoutToBlocks({
+        return {
             plan,
             blocks: Object.values(blockDefinitions),
-        });
+        };
     }
     toSafeName(name) {
         return name.toLowerCase().replace(/[^0-9a-z-]/gi, '');
@@ -377,7 +396,7 @@ class StormEventParser {
                                 },
                             },
                         };
-                        blockSpec.providers.push(dbResource);
+                        blockSpec.consumers.push(dbResource);
                         break;
                     case 'JWTCONSUMER':
                     case 'WEBFRAGMENT':
@@ -460,6 +479,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/cjs/src/storm/events.d.ts

@@ -2,6 +2,7 @@
  * Copyright 2023 Kapeta Inc.
  * SPDX-License-Identifier: BUSL-1.1
  */
+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 {
@@ -116,6 +117,7 @@ export interface StormEventFile {
     payload: {
         filename: string;
         content: string;
+        blockName: string;
         blockRef: string;
     };
 }
@@ -123,4 +125,10 @@ export interface StormEventDone {
     type: 'DONE';
     created: number;
 }
-export type StormEvent = StormEventCreateBlock | StormEventCreateConnection | StormEventCreatePlanProperties | StormEventInvalidResponse | StormEventPlanRetry | StormEventCreateDSL | StormEventError | StormEventScreen | StormEventScreenCandidate | StormEventFile | StormEventDone;
+export interface StormEventDefinitionChange {
+    type: 'DEFINITION_CHANGE';
+    reason: string;
+    created: number;
+    payload: StormDefinitions;
+}
+export type StormEvent = StormEventCreateBlock | StormEventCreateConnection | StormEventCreatePlanProperties | StormEventInvalidResponse | StormEventPlanRetry | StormEventCreateDSL | StormEventError | StormEventScreen | StormEventScreenCandidate | StormEventFile | StormEventDone | StormEventDefinitionChange;

package/dist/cjs/src/storm/events.js

@@ -1,6 +1,2 @@
 "use strict";
-/**
- * Copyright 2023 Kapeta Inc.
- * SPDX-License-Identifier: BUSL-1.1
- */
 Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/src/storm/routes.js

@@ -25,12 +25,13 @@ router.post('/:handle/all', async (req, res) => {
         const metaStream = await stormClient_1.stormClient.createMetadata(aiRequest.prompt, aiRequest.history);
         res.set('Content-Type', 'application/x-ndjson');
         metaStream.on('data', (data) => {
-            eventParser.addEvent(data);
+            const result = eventParser.addEvent(req.params.handle, data);
+            sendDefinitions(res, result);
         });
         await streamStormPartialResponse(metaStream, res);
         if (!eventParser.isValid()) {
             // We can't continue if the meta stream is invalid
-            res.write({
+            sendEvent(res, {
                 type: 'ERROR_INTERNAL',
                 payload: { error: eventParser.getError() },
                 reason: 'Failed to generate system',
@@ -40,6 +41,7 @@ router.post('/:handle/all', async (req, res) => {
             return;
         }
         const result = eventParser.toResult(handle);
+        sendDefinitions(res, result);
         const stormCodegen = new codegen_1.StormCodegen(aiRequest.prompt, result.blocks, eventParser.getEvents());
         const codegenStream = streamStormPartialResponse(stormCodegen.getStream(), res);
         await stormCodegen.process();
@@ -50,22 +52,30 @@ router.post('/:handle/all', async (req, res) => {
         sendError(err, res);
     }
 });
+function sendDefinitions(res, result) {
+    sendEvent(res, {
+        type: 'DEFINITION_CHANGE',
+        payload: result,
+        reason: 'Updates to definition',
+        created: Date.now(),
+    });
+}
 function sendDone(res) {
-    res.write(JSON.stringify({
+    sendEvent(res, {
         type: 'DONE',
         created: Date.now(),
-    }) + '\n');
+    });
     res.end();
 }
 function sendError(err, res) {
     console.error('Failed to send prompt', err);
     if (res.headersSent) {
-        res.write(JSON.stringify({
+        sendEvent(res, {
             type: 'ERROR_INTERNAL',
             created: Date.now(),
             payload: { error: err.message },
             reason: 'Failed while sending prompt',
-        }) + '\n');
+        });
     }
     else {
         res.status(400).send({ error: err.message });
@@ -74,7 +84,7 @@ function sendError(err, res) {
 function streamStormPartialResponse(result, res) {
     return new Promise((resolve, reject) => {
         result.on('data', (data) => {
-            res.write(JSON.stringify(data) + '\n');
+            sendEvent(res, data);
         });
         result.on('error', (err) => {
             reject(err);
@@ -84,4 +94,7 @@ function streamStormPartialResponse(result, res) {
         });
     });
 }
+function sendEvent(res, evt) {
+    res.write(JSON.stringify(evt) + '\n');
+}
 exports.default = router;

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

@@ -0,0 +1,5 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+export {};

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

@@ -0,0 +1,161 @@
+"use strict";
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const event_parser_1 = require("../../src/storm/event-parser");
+const parserOptions = {
+    serviceKind: 'kapeta/block-service:local',
+    serviceLanguage: 'kapeta/language-target-nodejs-ts:local',
+    frontendKind: 'kapeta/block-type-frontend:local',
+    frontendLanguage: 'kapeta/language-target-react-ts:local',
+    cliKind: 'kapeta/block-type-cli:local',
+    cliLanguage: 'kapeta/language-target-nodejs-ts:local',
+    desktopKind: 'kapeta/block-type-desktop:local',
+    desktopLanguage: 'kapeta/language-target-electron-ts:local',
+    gatewayKind: 'kapeta/block-type-gateway:local',
+    mqKind: 'kapeta/block-type-mq:local',
+    exchangeKind: 'kapeta/resource-type-exchange:local',
+    queueKind: 'kapeta/resource-type-queue:local',
+    publisherKind: 'kapeta/resource-type-publisher:local',
+    subscriberKind: 'kapeta/resource-type-subscriber:local',
+    databaseKind: 'kapeta/block-type-database:local',
+    apiKind: 'kapeta/block-type-api:local',
+    clientKind: 'kapeta/block-type-client:local',
+    webPageKind: 'kapeta/block-type-web-page:local',
+    webFragmentKind: 'kapeta/block-type-web-fragment:local',
+    jwtProviderKind: 'kapeta/resource-type-jwt-provider:local',
+    jwtConsumerKind: 'kapeta/resource-type-jwt-consumer:local',
+    smtpKind: 'kapeta/resource-type-smtp:local',
+    externalApiKind: 'kapeta/resource-type-external-api:local',
+};
+const events = [
+    {
+        type: 'CREATE_PLAN_PROPERTIES',
+        created: Date.now(),
+        reason: 'create plan properties',
+        payload: {
+            name: 'my-plan',
+            description: 'my plan description',
+        },
+    },
+    {
+        type: 'CREATE_BLOCK',
+        reason: 'create backend',
+        created: Date.now(),
+        payload: {
+            name: 'service',
+            description: 'A service block',
+            type: 'BACKEND',
+            resources: [
+                {
+                    name: 'entities',
+                    type: 'DATABASE',
+                    description: 'A database resource',
+                },
+                {
+                    type: 'API',
+                    name: 'entities',
+                    description: 'An API resource',
+                },
+            ],
+        },
+    },
+    {
+        type: 'CREATE_BLOCK',
+        reason: 'create frontend',
+        created: Date.now(),
+        payload: {
+            name: 'ui',
+            description: 'A frontend block',
+            type: 'FRONTEND',
+            resources: [
+                {
+                    name: 'web',
+                    type: 'WEBPAGE',
+                    description: 'A web page',
+                },
+                {
+                    type: 'CLIENT',
+                    name: 'entities',
+                    description: 'Client for backend',
+                },
+            ],
+        },
+    },
+    {
+        type: 'CREATE_CONNECTION',
+        created: Date.now(),
+        reason: 'connect service to ui',
+        payload: {
+            fromComponent: 'service',
+            fromResource: 'entities',
+            fromResourceType: 'API',
+            toComponent: 'ui',
+            toResource: 'entities',
+            toResourceType: 'CLIENT',
+        },
+    },
+    {
+        type: 'CREATE_API',
+        reason: 'create api',
+        created: Date.now(),
+        payload: {
+            blockName: 'service',
+            content: `controller Entities('/entities') {
+                        @GET('/')
+                        list(): string[]
+                    }`,
+        },
+    },
+    {
+        type: 'CREATE_MODEL',
+        created: Date.now(),
+        reason: 'create model',
+        payload: {
+            blockName: 'service',
+            content: `type Entity {
+                        @Id
+                        id: string
+                        
+                        name: string
+                    }`,
+        },
+    },
+];
+describe('event-parser', () => {
+    it('it can parse events into a plan and blocks with proper layout', () => {
+        const parser = new event_parser_1.StormEventParser(parserOptions);
+        events.forEach((event) => parser.addEvent('kapeta', event));
+        const result = parser.toResult('kapeta');
+        expect(result.plan.metadata.name).toBe('kapeta/my-plan');
+        expect(result.plan.metadata.description).toBe('my plan description');
+        expect(result.blocks.length).toBe(2);
+        expect(result.blocks[0].content.metadata.name).toBe('kapeta/service');
+        expect(result.blocks[1].content.metadata.name).toBe('kapeta/ui');
+        const dbResource = result.blocks[0].content.spec.consumers?.[0];
+        const apiResource = result.blocks[0].content.spec.providers?.[0];
+        const clientResource = result.blocks[1].content.spec.consumers?.[0];
+        const pageResource = result.blocks[1].content.spec.providers?.[0];
+        expect(apiResource).toBeDefined();
+        expect(clientResource).toBeDefined();
+        expect(dbResource).toBeDefined();
+        expect(pageResource).toBeDefined();
+        expect(apiResource?.kind).toBe(parserOptions.apiKind);
+        expect(clientResource?.kind).toBe(parserOptions.clientKind);
+        expect(dbResource?.kind).toBe(parserOptions.databaseKind);
+        expect(pageResource?.kind).toBe(parserOptions.webPageKind);
+        expect(apiResource?.spec).toEqual(clientResource?.spec);
+        expect(dbResource?.spec.source.value).toContain('type Entity');
+        const serviceBlockInstance = result.plan.spec.blocks[0];
+        expect(serviceBlockInstance.name).toBe('service');
+        const uiBlockInstance = result.plan.spec.blocks[1];
+        expect(uiBlockInstance.name).toBe('ui');
+        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);
+        expect(result.plan.spec.connections[0].provider.blockId).toBe(serviceBlockInstance.id);
+        expect(result.plan.spec.connections[0].provider.resourceName).toBe(apiResource?.metadata.name);
+    });
+});