@kapeta/local-cluster-service 0.8.3 → 0.9.1

package/src/instances/routes.ts

@@ -5,7 +5,7 @@ import { corsHandler } from '../middleware/cors';
 import { NextFunction, Request, Response } from 'express';
 import { kapetaHeaders, KapetaRequest } from '../middleware/kapeta';
 import { stringBody } from '../middleware/stringBody';
-import { EnvironmentType, KapetaBodyRequest } from '../types';
+import { DesiredInstanceStatus, InstanceInfo, InstanceOwner, InstanceType, KapetaBodyRequest } from '../types';
 
 const router = Router();
 router.use('/', corsHandler);
@@ -28,11 +28,11 @@ router.get('/:systemId/instances', (req: Request, res: Response) => {
  * Start all instances in a plan
  */
 router.post('/:systemId/start', async (req: Request, res: Response) => {
-    const processes = await instanceManager.createProcessesForPlan(req.params.systemId);
+    const instances = await instanceManager.startAllForPlan(req.params.systemId);
 
     res.status(202).send({
         ok: true,
-        processes: processes.map((p) => {
+        processes: instances.map((p) => {
             return { pid: p.pid, type: p.type };
         }),
     });
@@ -53,7 +53,7 @@ router.post('/:systemId/stop', async (req: Request, res: Response) => {
  * Start single instance in a plan
  */
 router.post('/:systemId/:instanceId/start', async (req: Request, res: Response) => {
-    const process = await instanceManager.createProcess(req.params.systemId, req.params.instanceId);
+    const process = await instanceManager.start(req.params.systemId, req.params.instanceId);
 
     res.status(202).send({
         ok: true,
@@ -66,7 +66,7 @@ router.post('/:systemId/:instanceId/start', async (req: Request, res: Response)
  * Stop single instance in a plan
  */
 router.post('/:systemId/:instanceId/stop', async (req: Request, res: Response) => {
-    await instanceManager.stopProcess(req.params.systemId, req.params.instanceId);
+    await instanceManager.stop(req.params.systemId, req.params.instanceId);
 
     res.status(202).send({ ok: true });
 });
@@ -75,14 +75,14 @@ router.post('/:systemId/:instanceId/stop', async (req: Request, res: Response) =
  * Get logs for instance in a plan
  */
 router.get('/:systemId/:instanceId/logs', (req: Request, res: Response) => {
-    const processInfo = instanceManager.getProcessForInstance(req.params.systemId, req.params.instanceId);
-    if (!processInfo) {
+    const instanceInfo = instanceManager.getInstance(req.params.systemId, req.params.instanceId);
+    if (!instanceInfo) {
         res.status(404).send({ ok: false });
         return;
     }
 
     res.status(202).send({
-        logs: processInfo.logs(),
+        logs: instanceInfo.internal?.logs() ?? [],
     });
 });
 
@@ -132,31 +132,37 @@ router.use('/', (req: KapetaBodyRequest, res: Response, next: NextFunction) => {
 });
 
 /**
- * Updates the full configuration for a given service.
+ * Updates the full configuration for a given instance.
  */
 router.put('/', async (req: KapetaBodyRequest, res: Response) => {
-    let instance = req.stringBody ? JSON.parse(req.stringBody) : null;
+    let instance: InstanceInfo = req.stringBody ? JSON.parse(req.stringBody) : null;
     if (req.kapeta!.environment === 'docker') {
         //A bit hacky but we want to avoid overwriting the docker PID with a process PID
         const oldInstance = instanceManager.getInstance(req.kapeta!.systemId, req.kapeta!.instanceId);
         if (oldInstance) {
             instance.pid = oldInstance.pid;
         }
-        instance.type = 'docker';
-    } else if (req.kapeta!.environment === 'process') {
-        instance.type = 'process';
+        instance.type = InstanceType.DOCKER;
+    } else {
+        // Coming from user starting the instance outside of kapeta
+        instance.type = InstanceType.LOCAL;
+        instance.owner = InstanceOwner.EXTERNAL;
+        instance.desiredStatus = DesiredInstanceStatus.EXTERNAL;
     }
 
-    await instanceManager.registerInstance(req.kapeta!.systemId, req.kapeta!.instanceId, instance);
-
-    res.status(202).send({ ok: true });
+    try {
+        await instanceManager.registerInstanceFromSDK(req.kapeta!.systemId, req.kapeta!.instanceId, instance);
+        res.status(202).send({ ok: true });
+    } catch (e: any) {
+        res.status(400).send({ error: e.message });
+    }
 });
 
 /**
  * Delete instance
  */
 router.delete('/', async (req: KapetaRequest, res: Response) => {
-    await instanceManager.setInstanceAsStopped(req.kapeta!.systemId, req.kapeta!.instanceId);
+    await instanceManager.markAsStopped(req.kapeta!.systemId, req.kapeta!.instanceId);
 
     res.status(202).send({ ok: true });
 });

package/src/middleware/kapeta.ts

@@ -1,5 +1,7 @@
 import { NextFunction, Request, Response } from 'express';
 import { EnvironmentType } from '../types';
+import { parseKapetaUri } from '@kapeta/nodejs-utils';
+import { normalizeKapetaUri } from '../utils/utils';
 
 export interface KapetaRequest extends Request {
     kapeta?: {
@@ -16,6 +18,14 @@ export function kapetaHeaders(req: KapetaRequest, res: Response, next: NextFunct
     let instanceId: string = req.headers['x-kapeta-instance'] as string;
     let environment: string = req.headers['x-kapeta-environment'] as string;
 
+    if (blockRef) {
+        blockRef = normalizeKapetaUri(blockRef);
+    }
+
+    if (systemId) {
+        systemId = normalizeKapetaUri(systemId);
+    }
+
     req.kapeta = {
         blockRef,
         instanceId,

package/src/networkManager.ts

@@ -1,6 +1,7 @@
 import uuid from 'node-uuid';
 import { Connection, SimpleRequest, SimpleResponse } from './types';
 import express from 'express';
+import { normalizeKapetaUri } from './utils/utils';
 
 class NetworkManager {
     private _connections: { [systemId: string]: { [connectionId: string]: Traffic[] } };
@@ -23,6 +24,7 @@ class NetworkManager {
     }
 
     _ensureSystem(systemId: string) {
+        systemId = normalizeKapetaUri(systemId);
         if (!this._connections[systemId]) {
             this._connections[systemId] = {};
         }
@@ -37,6 +39,7 @@ class NetworkManager {
     }
 
     _ensureConnection(systemId: string, connectionId: string) {
+        systemId = normalizeKapetaUri(systemId);
         this._ensureSystem(systemId);
 
         if (!this._connections[systemId][connectionId]) {
@@ -47,6 +50,7 @@ class NetworkManager {
     }
 
     _ensureSource(systemId: string, sourceBlockInstanceId: string) {
+        systemId = normalizeKapetaUri(systemId);
         this._ensureSystem(systemId);
 
         if (!this._sources[systemId][sourceBlockInstanceId]) {
@@ -57,6 +61,7 @@ class NetworkManager {
     }
 
     _ensureTarget(systemId: string, targetBlockInstanceId: string) {
+        systemId = normalizeKapetaUri(systemId);
         this._ensureSystem(systemId);
 
         if (!this._targets[systemId][targetBlockInstanceId]) {
@@ -73,6 +78,7 @@ class NetworkManager {
         consumerMethodId?: string,
         providerMethodId?: string
     ) {
+        systemId = normalizeKapetaUri(systemId);
         const traffic = new Traffic(connection, request, consumerMethodId, providerMethodId);
 
         this._ensureConnection(systemId, traffic.connectionId).push(traffic);

package/src/operatorManager.ts

@@ -8,6 +8,8 @@ import { ContainerInfo, containerManager } from './containerManager';
 import FSExtra from 'fs-extra';
 import { AnyMap, EnvironmentType, OperatorInfo } from './types';
 import { BlockInstance, Resource } from '@kapeta/schemas';
+import { definitionsManager } from './definitionsManager';
+import { normalizeKapetaUri } from './utils/utils';
 
 const KIND_OPERATOR = 'core/resource-type-operator';
 
@@ -47,7 +49,7 @@ class OperatorManager {
      * @return {Operator}
      */
     getOperator(resourceType: string, version: string) {
-        const operators = ClusterConfiguration.getDefinitions(KIND_OPERATOR);
+        const operators = definitionsManager.getDefinitions(KIND_OPERATOR);
 
         const operator: DefinitionInfo | undefined = operators.find(
             (operator) =>
@@ -80,7 +82,8 @@ class OperatorManager {
         name: string,
         environment?: EnvironmentType
     ): Promise<OperatorInfo> {
-        const plans = ClusterConfiguration.getDefinitions('core/plan');
+        systemId = normalizeKapetaUri(systemId);
+        const plans = definitionsManager.getDefinitions('core/plan');
 
         const planUri = parseKapetaUri(systemId);
         const currentPlan = plans.find(
@@ -98,10 +101,12 @@ class OperatorManager {
         }
 
         const blockUri = parseKapetaUri(currentInstance.block.ref);
-        const blockDefinition = ClusterConfiguration.getDefinitions().find(
-            (definition) =>
-                definition.version === blockUri.version && definition.definition.metadata.name === blockUri.fullName
-        );
+        const blockDefinition = definitionsManager
+            .getDefinitions()
+            .find(
+                (definition) =>
+                    definition.version === blockUri.version && definition.definition.metadata.name === blockUri.fullName
+            );
 
         if (!blockDefinition) {
             throw new Error(`Unknown block: ${currentInstance.block.ref} in plan ${systemId}`);

package/src/providerManager.ts

@@ -3,6 +3,7 @@ import FSExtra from 'fs-extra';
 import { repositoryManager } from './repositoryManager';
 import ClusterConfiguration from '@kapeta/local-cluster-config';
 import { StringMap } from './types';
+import { definitionsManager } from './definitionsManager';
 
 class ProviderManager {
     private _webAssetCache: StringMap;
@@ -11,7 +12,7 @@ class ProviderManager {
     }
 
     getWebProviders() {
-        return ClusterConfiguration.getProviderDefinitions().filter((providerDefinition) => providerDefinition.hasWeb);
+        return definitionsManager.getProviderDefinitions().filter((providerDefinition) => providerDefinition.hasWeb);
     }
 
     async getAsset(handle: string, name: string, version: string, sourceMap: boolean = false) {
@@ -42,7 +43,7 @@ class ProviderManager {
     }
 }
 
-const providerDefinitions = ClusterConfiguration.getProviderDefinitions();
+const providerDefinitions = definitionsManager.getProviderDefinitions();
 
 if (providerDefinitions.length > 0) {
     console.log('## Loaded the following providers ##');

package/src/repositoryManager.ts

@@ -9,6 +9,7 @@ import { socketManager } from './socketManager';
 import { progressListener } from './progressListener';
 import { Dependency } from '@kapeta/schemas';
 import { Actions, Config, RegistryService } from '@kapeta/nodejs-registry-utils';
+import { definitionsManager } from './definitionsManager';
 
 const INSTALL_ATTEMPTED: { [p: string]: boolean } = {};
 
@@ -94,6 +95,7 @@ class RepositoryManager {
 
                 allDefinitions = newDefinitions;
                 socketManager.emit(`assets`, 'changed', payload);
+                definitionsManager.clearCache();
             });
         } catch (e) {
             // Fallback to run without watch mode due to potential platform issues.
@@ -186,7 +188,7 @@ class RepositoryManager {
             return;
         }
 
-        const definitions = ClusterConfiguration.getDefinitions();
+        const definitions = definitionsManager.getDefinitions();
         const installedAsset = definitions.find(
             (d) => d.definition.metadata.name === fullName && d.version === version
         );
@@ -221,8 +223,10 @@ class RepositoryManager {
         } else {
             //Ensure dependencies are installed
             const refs = assetVersion.dependencies.map((dep: Dependency) => dep.name);
-            console.log(`Auto-installing dependencies: ${refs.join(', ')}`);
-            await this._install(refs);
+            if (refs.length > 0) {
+                console.log(`Auto-installing dependencies: ${refs.join(', ')}`);
+                await this._install(refs);
+            }
         }
     }
 }

package/src/serviceManager.ts

@@ -2,6 +2,7 @@ import _ from 'lodash';
 import { clusterService } from './clusterService';
 import { storageService } from './storageService';
 import { EnvironmentType } from './types';
+import { normalizeKapetaUri } from './utils/utils';
 
 const DEFAULT_PORT_TYPE = 'rest';
 
@@ -42,6 +43,8 @@ class ServiceManager {
     }
 
     _ensureSystem(systemId: string) {
+        systemId = normalizeKapetaUri(systemId);
+
         if (!this._systems[systemId]) {
             this._systems[systemId] = {};
         }
@@ -60,6 +63,7 @@ class ServiceManager {
     }
 
     async ensureServicePort(systemId: string, blockInstanceId: string, portType: string = DEFAULT_PORT_TYPE) {
+        systemId = normalizeKapetaUri(systemId);
         if (!portType) {
             portType = DEFAULT_PORT_TYPE;
         }
@@ -94,6 +98,7 @@ class ServiceManager {
         portType: string,
         environmentType?: EnvironmentType
     ): string {
+        systemId = normalizeKapetaUri(systemId);
         const port = clusterService.getClusterServicePort();
         const path = clusterService.getProxyPath(systemId, consumerInstanceId, consumerResourceName, portType);
         return this._forLocal(port, path, environmentType);
@@ -108,6 +113,7 @@ class ServiceManager {
      *
      */
     async getProviderAddress(systemId: string, providerInstanceId: string, portType: string): Promise<string> {
+        systemId = normalizeKapetaUri(systemId);
         const port = await this.ensureServicePort(systemId, providerInstanceId, portType);
         return this._forLocal(port);
     }

package/src/types.ts

@@ -10,6 +10,7 @@ export type AnyMap = { [key: string]: any };
 export type LogLevel = 'ERROR' | 'WARN' | 'INFO' | 'DEBUG' | 'TRACE' | 'FATAL';
 export type LogSource = 'stdout' | 'stderr';
 export type EnvironmentType = 'docker' | 'process';
+
 export interface LogEntry {
     source: LogSource;
     level: LogLevel;
@@ -23,32 +24,61 @@ export interface BlockProcessParams {
     configuration?: AnyMap;
 }
 
-export type ProcessType = 'docker' | 'local';
+export enum InstanceType {
+    DOCKER = 'docker',
+    LOCAL = 'local',
+    UNKNOWN = 'unknown',
+}
+export enum InstanceOwner {
+    INTERNAL = 'internal',
+    EXTERNAL = 'external',
+}
 
-export interface ProcessDetails {
-    pid: number | string;
-    type: ProcessType;
-    portType?: string;
-    output: EventEmitter;
-    logs: () => LogEntry[];
-    stop: () => Promise<void> | void;
+export enum InstanceStatus {
+    STOPPED = 'stopped',
+    STARTING = 'starting',
+    BUSY = 'busy',
+    READY = 'ready',
+    STOPPING = 'stopping',
+    UNHEALTHY = 'unhealthy',
+    FAILED = 'failed',
 }
 
-export interface ProcessInfo extends ProcessDetails {
-    id: string;
-    ref: string;
-    name: string;
+export enum DesiredInstanceStatus {
+    STOP = 'stop',
+    RUN = 'run',
+    EXTERNAL = 'external',
 }
 
+export type ProcessInfo = {
+    type: InstanceType;
+    pid?: number | string | null;
+    output: EventEmitter;
+    portType?: string;
+    logs: () => LogEntry[];
+    stop: () => Promise<void> | void;
+};
+
 export type InstanceInfo = {
     systemId: string;
     instanceId: string;
+    ref: string;
+    name: string;
+    type: InstanceType;
+    owner: InstanceOwner;
+    status: InstanceStatus;
+    desiredStatus: DesiredInstanceStatus;
     address?: string;
+
+    startedAt?: number;
     health?: string | null;
-    status: string;
     pid?: number | string | null;
-    type: ProcessType;
     portType?: string;
+
+    internal?: {
+        output: EventEmitter;
+        logs: () => LogEntry[];
+    };
 };
 
 interface ResourceRef {

package/src/utils/BlockInstanceRunner.ts

@@ -1,15 +1,15 @@
 import FS from 'node:fs';
 import ClusterConfig, { DefinitionInfo } from '@kapeta/local-cluster-config';
-import { getBindHost, readYML } from './utils';
+import { getBindHost, getBlockInstanceContainerName, normalizeKapetaUri, readYML } from './utils';
 import { KapetaURI, parseKapetaUri } from '@kapeta/nodejs-utils';
 import { serviceManager } from '../serviceManager';
 import { containerManager, DockerMounts, toLocalBindVolume } from '../containerManager';
 import { LogData } from './LogData';
 import EventEmitter from 'events';
-import md5 from 'md5';
 import { clusterService } from '../clusterService';
-import { AnyMap, BlockProcessParams, ProcessDetails, ProcessInfo, StringMap } from '../types';
+import { AnyMap, BlockProcessParams, ProcessInfo, InstanceType, StringMap } from '../types';
 import { Container } from 'node-docker-api/lib/container';
+import { definitionsManager } from '../definitionsManager';
 
 const KIND_BLOCK_TYPE_OPERATOR = 'core/block-type-operator';
 const KAPETA_SYSTEM_ID = 'KAPETA_SYSTEM_ID';
@@ -27,7 +27,7 @@ const DOCKER_ENV_VARS = [
 ];
 
 function getProvider(uri: KapetaURI) {
-    return ClusterConfig.getProviderDefinitions().find((provider) => {
+    return definitionsManager.getProviderDefinitions().find((provider) => {
         const ref = `${provider.definition.metadata.name}:${provider.version}`;
         return parseKapetaUri(ref).id === uri.id;
     });
@@ -46,13 +46,13 @@ function getProviderPorts(assetVersion: DefinitionInfo): string[] {
 export class BlockInstanceRunner {
     private readonly _systemId: string;
 
-    constructor(planReference: string) {
+    constructor(systemId: string) {
         /**
          *
          * @type {string}
          * @private
          */
-        this._systemId = planReference ?? '';
+        this._systemId = normalizeKapetaUri(systemId);
     }
 
     /**
@@ -88,7 +88,7 @@ export class BlockInstanceRunner {
             blockUri.version = 'local';
         }
 
-        const assetVersion = ClusterConfig.getDefinitions().find((definitions) => {
+        const assetVersion = definitionsManager.getDefinitions().find((definitions) => {
             const ref = `${definitions.definition.metadata.name}:${definitions.version}`;
             return parseKapetaUri(ref).id === blockUri.id;
         });
@@ -105,30 +105,26 @@ export class BlockInstanceRunner {
             throw new Error(`Kind not found: ${kindUri.id}`);
         }
 
-        let processDetails: ProcessDetails;
+        let processInfo: ProcessInfo;
 
         if (providerVersion.definition.kind === KIND_BLOCK_TYPE_OPERATOR) {
-            processDetails = await this._startOperatorProcess(blockInstance, blockUri, providerVersion, env);
+            processInfo = await this._startOperatorProcess(blockInstance, blockUri, providerVersion, env);
         } else {
             //We need a port type to know how to connect to the block consistently
             const portTypes = getProviderPorts(assetVersion);
 
             if (blockUri.version === 'local') {
-                processDetails = await this._startLocalProcess(blockInstance, blockUri, env, assetVersion);
+                processInfo = await this._startLocalProcess(blockInstance, blockUri, env, assetVersion);
             } else {
-                processDetails = await this._startDockerProcess(blockInstance, blockUri, env);
+                processInfo = await this._startDockerProcess(blockInstance, blockUri, env);
             }
 
             if (portTypes.length > 0) {
-                processDetails.portType = portTypes[0];
+                processInfo.portType = portTypes[0];
             }
         }
 
-        return {
-            name: blockUri.id,
-            ...blockInstance,
-            ...processDetails,
-        };
+        return processInfo;
     }
 
     /**
@@ -139,7 +135,7 @@ export class BlockInstanceRunner {
         blockInfo: KapetaURI,
         env: StringMap,
         assetVersion: DefinitionInfo
-    ): Promise<ProcessDetails> {
+    ): Promise<ProcessInfo> {
         const baseDir = ClusterConfig.getRepositoryAssetPath(blockInfo.handle, blockInfo.name, blockInfo.version);
 
         if (!FS.existsSync(baseDir)) {
@@ -172,22 +168,25 @@ export class BlockInstanceRunner {
             throw new Error(`Missing docker image information: ${JSON.stringify(localContainer)}`);
         }
 
-        const containerName = `kapeta-block-instance-${blockInstance.id}`;
+        const containerName = getBlockInstanceContainerName(blockInstance.id);
         const logs = new LogData();
         logs.addLog(`Starting block ${blockInstance.ref}`);
-        let container: Container | null = (await containerManager.getContainerByName(containerName)) ?? null;
+        let containerInfo = await containerManager.getContainerByName(containerName);
+        let container = containerInfo?.native;
+
         console.log('Starting dev container', containerName);
 
-        if (container) {
-            console.log(`Container already exists. Deleting...`);
+        if (containerInfo) {
+            console.log(`Dev container already exists. Deleting...`);
             try {
-                await container.delete({
+                await containerInfo.remove({
                     force: true,
                 });
             } catch (e: any) {
                 throw new Error('Failed to delete existing container: ' + e.message);
             }
-            container = null;
+            container = undefined;
+            containerInfo = undefined;
         }
 
         logs.addLog(`Creating new container for block: ${containerName}`);
@@ -229,6 +228,7 @@ export class BlockInstanceRunner {
             HealthCheck = containerManager.toDockerHealth({ cmd: localContainer.healthcheck });
         }
 
+        console.log('Starting dev container', containerName, dockerImage);
         container = await containerManager.startContainer({
             Image: dockerImage,
             name: containerName,
@@ -274,7 +274,7 @@ export class BlockInstanceRunner {
         container: Container,
         logs: LogData,
         deleteOnExit: boolean = false
-    ): Promise<ProcessDetails> {
+    ): Promise<ProcessInfo> {
         let localContainer: Container | null = container;
         const logStream = (await container.logs({
             follow: true,
@@ -299,14 +299,14 @@ export class BlockInstanceRunner {
             const data = status.data as any;
             if (deleteOnExit) {
                 try {
-                    await container.delete();
+                    await containerManager.remove(container);
                 } catch (e: any) {}
             }
             outputEvents.emit('exit', data?.State?.ExitCode ?? 0);
         });
 
         return {
-            type: 'docker',
+            type: InstanceType.DOCKER,
             pid: container.id,
             output: outputEvents,
             stop: async () => {
@@ -317,7 +317,7 @@ export class BlockInstanceRunner {
                 try {
                     await localContainer.stop();
                     if (deleteOnExit) {
-                        await localContainer.delete();
+                        await containerManager.remove(localContainer);
                     }
                 } catch (e) {}
                 localContainer = null;
@@ -350,9 +350,10 @@ export class BlockInstanceRunner {
             throw new Error(`Missing docker image information: ${JSON.stringify(versionInfo?.artifact?.details)}`);
         }
 
-        const containerName = `kapeta-block-instance-${blockInstance.id}`;
+        const containerName = getBlockInstanceContainerName(blockInstance.id);
         const logs = new LogData();
-        let container = await containerManager.getContainerByName(containerName);
+        const containerInfo = await containerManager.getContainerByName(containerName);
+        let container = containerInfo?.native;
 
         // For windows we need to default to root
         const innerHome = process.platform === 'win32' ? '/root/.kapeta' : ClusterConfig.getKapetaBasedir();
@@ -435,9 +436,11 @@ export class BlockInstanceRunner {
             console.warn('Failed to pull image. Continuing...', e);
         }
 
-        const containerName = `kapeta-block-instance-${md5(blockInstance.id)}`;
+        const containerName = getBlockInstanceContainerName(blockInstance.id);
         const logs = new LogData();
-        let container: Container | null = (await containerManager.getContainerByName(containerName)) ?? null;
+        const containerInfo = await containerManager.getContainerByName(containerName);
+        let container = containerInfo?.native;
+
         if (container) {
             const containerData = container.data as any;
             if (containerData.State === 'running') {
@@ -446,9 +449,9 @@ export class BlockInstanceRunner {
                 if (containerData.State?.ExitCode > 0) {
                     logs.addLog(`Container exited with code: ${containerData.State.ExitCode}. Deleting...`);
                     try {
-                        await container.delete();
+                        await containerManager.remove(container);
                     } catch (e) {}
-                    container = null;
+                    container = undefined;
                 } else {
                     logs.addLog(`Found existing container for block: ${containerName}. Starting now`);
                     try {
@@ -456,9 +459,9 @@ export class BlockInstanceRunner {
                     } catch (e) {
                         console.warn('Failed to start container. Deleting...', e);
                         try {
-                            await container.delete();
+                            await containerManager.remove(container);
                         } catch (e) {}
-                        container = null;
+                        container = undefined;
                     }
                 }
             }

package/src/utils/utils.ts

@@ -1,5 +1,23 @@
 import FS from 'node:fs';
 import YAML from 'yaml';
+import { parseKapetaUri } from '@kapeta/nodejs-utils';
+
+export function getBlockInstanceContainerName(instanceId: string) {
+    return `kapeta-block-instance-${instanceId}`;
+}
+
+export function normalizeKapetaUri(uri: string) {
+    if (!uri) {
+        return '';
+    }
+
+    const uriObj = parseKapetaUri(uri);
+    if (!uriObj.version) {
+        return `kapeta://${parseKapetaUri(uri).fullName}`;
+    }
+
+    return `kapeta://${parseKapetaUri(uri).id}`;
+}
 
 export function readYML(path: string) {
     const rawYaml = FS.readFileSync(path);