@kapeta/local-cluster-service 0.20.1 → 0.20.3

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [0.20.3](https://github.com/kapetacom/local-cluster-service/compare/v0.20.2...v0.20.3) (2023-09-12)
+
+
+### Bug Fixes
+
+* Resolve configuration when returning it for instance ([#77](https://github.com/kapetacom/local-cluster-service/issues/77)) ([e1f9ee6](https://github.com/kapetacom/local-cluster-service/commit/e1f9ee62877efcd87b8c5b21c42609f10842ece2))
+
+## [0.20.2](https://github.com/kapetacom/local-cluster-service/compare/v0.20.1...v0.20.2) (2023-09-12)
+
+
+### Bug Fixes
+
+* bump nodejs-registry-utils dependency ([408ec86](https://github.com/kapetacom/local-cluster-service/commit/408ec865791b7fd10170c3e27c1a174b8052d9c2))
+
 ## [0.20.1](https://github.com/kapetacom/local-cluster-service/compare/v0.20.0...v0.20.1) (2023-09-12)
 
 

package/dist/cjs/src/assetManager.d.ts

@@ -1,5 +1,5 @@
 import { Definition } from '@kapeta/local-cluster-config';
-import { BlockDefinition } from '@kapeta/schemas';
+import { BlockDefinition, BlockInstance, Plan } from '@kapeta/schemas';
 import { SourceOfChange } from './types';
 export interface EnrichedAsset {
     ref: string;
@@ -19,7 +19,8 @@ declare class AssetManager {
      */
     getAssets(assetKinds?: string[]): Promise<EnrichedAsset[]>;
     getPlans(): Promise<EnrichedAsset[]>;
-    getPlan(ref: string, noCache?: boolean): Promise<Definition>;
+    getPlan(ref: string, noCache?: boolean): Promise<Plan>;
+    getBlockInstance(systemId: string, instanceId: string): Promise<BlockInstance>;
     getAsset(ref: string, noCache?: boolean, autoFetch?: boolean): Promise<EnrichedAsset | undefined>;
     createAsset(path: string, yaml: BlockDefinition, sourceOfChange?: SourceOfChange): Promise<EnrichedAsset[]>;
     updateAsset(ref: string, yaml: BlockDefinition, sourceOfChange?: SourceOfChange): Promise<void>;

package/dist/cjs/src/assetManager.js

@@ -68,11 +68,22 @@ class AssetManager {
     }
     async getPlan(ref, noCache = false) {
         const asset = await this.getAsset(ref, noCache);
+        if (!asset) {
+            throw new Error('Plan was not found: ' + ref);
+        }
         if ('core/plan' !== asset?.kind) {
             throw new Error('Asset was not a plan: ' + ref);
         }
         return asset.data;
     }
+    async getBlockInstance(systemId, instanceId) {
+        const plan = await this.getPlan(systemId, true);
+        const instance = plan.spec.blocks?.find((instance) => instance.id === instanceId);
+        if (!instance) {
+            throw new Error(`Instance not found: ${instanceId} in plan ${systemId}`);
+        }
+        return instance;
+    }
     async getAsset(ref, noCache = false, autoFetch = true) {
         ref = (0, utils_1.normalizeKapetaUri)(ref);
         const cacheKey = toKey(ref);

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

@@ -18,11 +18,22 @@ router.use('/', stringBody_1.stringBody);
 /**
  * Returns the full configuration for a given service.
  */
-router.get('/instance', (req, res) => {
-    const config = req.kapeta.instanceId
-        ? configManager_1.configManager.getConfigForSection(req.kapeta.systemId, req.kapeta.instanceId)
-        : configManager_1.configManager.getConfigForSystem(req.kapeta.systemId);
-    res.send(config);
+router.get('/instance', async (req, res) => {
+    try {
+        let config = {};
+        if (req.kapeta.instanceId) {
+            config = await configManager_1.configManager.getConfigForBlockInstance(req.kapeta.systemId, req.kapeta.instanceId);
+        }
+        else {
+            config = configManager_1.configManager.getConfigForSystem(req.kapeta.systemId);
+        }
+        res.send(config);
+    }
+    catch (err) {
+        console.error('Failed to get instance config', err);
+        res.status(400).send({ error: err.message });
+        return;
+    }
 });
 /**
  * Updates the full configuration for a given service.

package/dist/cjs/src/configManager.d.ts

@@ -12,6 +12,7 @@ declare class ConfigManager {
     _forSystem(systemId: string): any;
     setConfigForSystem(systemId: string, config: AnyMap): void;
     getConfigForSystem(systemId: string): AnyMap;
+    getConfigForBlockInstance(systemId: string, instanceId: string): Promise<import("./types").AnyMap>;
     setConfigForSection(systemId: string, sectionId: string, config: AnyMap): void;
     getConfigForSection(systemId: string, sectionId: string): any;
     /**

package/dist/cjs/src/configManager.js

@@ -27,6 +27,15 @@ class ConfigManager {
         systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         return this._forSystem(systemId);
     }
+    async getConfigForBlockInstance(systemId, instanceId) {
+        const blockInstance = await assetManager_1.assetManager.getBlockInstance(systemId, instanceId);
+        const blockAsset = await assetManager_1.assetManager.getAsset(blockInstance.block.ref, true);
+        if (!blockAsset) {
+            throw new Error(`Block definition not found: ${blockInstance.block.ref}`);
+        }
+        const instanceConfig = this.getConfigForSection(systemId, instanceId);
+        return (0, utils_1.getResolvedConfiguration)(blockAsset.data.spec.configuration, instanceConfig, blockInstance.defaultConfiguration);
+    }
     setConfigForSection(systemId, sectionId, config) {
         systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         let systemConfig = this._forSystem(systemId);

package/dist/cjs/src/instanceManager.js

@@ -319,14 +319,7 @@ class InstanceManager {
     async start(systemId, instanceId) {
         return this.exclusive(systemId, instanceId, async () => {
             systemId = (0, utils_1.normalizeKapetaUri)(systemId);
-            const plan = await assetManager_1.assetManager.getPlan(systemId, true);
-            if (!plan) {
-                throw new Error('Plan not found: ' + systemId);
-            }
-            const blockInstance = plan.spec && plan.spec.blocks ? lodash_1.default.find(plan.spec.blocks, { id: instanceId }) : null;
-            if (!blockInstance) {
-                throw new Error('Block instance not found: ' + instanceId);
-            }
+            const blockInstance = await assetManager_1.assetManager.getBlockInstance(systemId, instanceId);
             const blockRef = (0, utils_1.normalizeKapetaUri)(blockInstance.block.ref);
             const blockAsset = await assetManager_1.assetManager.getAsset(blockRef, true);
             if (!blockAsset) {

package/dist/cjs/src/networkManager.d.ts

@@ -1,4 +1,5 @@
-import { Connection, SimpleRequest, SimpleResponse } from './types';
+import { Connection } from '@kapeta/schemas';
+import { SimpleRequest, SimpleResponse } from './types';
 declare class NetworkManager {
     private _connections;
     private _sources;

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

@@ -35,7 +35,7 @@ router.all('/:systemId/:consumerInstanceId/:consumerResourceName/:type/*', async
         const plan = await assetManager_1.assetManager.getPlan(req.params.systemId);
         // We can find the connection by the consumer information alone since
         // only 1 provider can be connected to a consumer resource at a time
-        const connection = lodash_1.default.find(plan.spec.connections, (connection) => {
+        const connection = plan.spec.connections.find((connection) => {
             return (connection.consumer.blockId.toLowerCase() === req.params.consumerInstanceId.toLowerCase() &&
                 connection.consumer.resourceName.toLowerCase() === req.params.consumerResourceName.toLowerCase());
         });

package/dist/cjs/src/types.d.ts

@@ -1,5 +1,5 @@
 import express from 'express';
-import { Resource } from '@kapeta/schemas';
+import { Connection, Resource } from '@kapeta/schemas';
 import { StringBodyRequest } from './middleware/stringBody';
 import { KapetaRequest } from './middleware/kapeta';
 export type StringMap = {
@@ -68,16 +68,7 @@ export type InstanceInfo = {
     pid?: number | string | null;
     portType?: string;
 };
-interface ResourceRef {
-    blockId: string;
-    resourceName: string;
-}
 export type ProxyRequestHandler = (req: StringBodyRequest, res: express.Response, info: ProxyRequestInfo) => void;
-export interface Connection {
-    mapping: any;
-    provider: ResourceRef;
-    consumer: ResourceRef;
-}
 export interface OperatorInfo {
     host: string;
     port: string;
@@ -105,4 +96,3 @@ export interface SimpleRequest {
     body: any;
 }
 export type KapetaBodyRequest = KapetaRequest & StringBodyRequest;
-export {};

package/dist/esm/src/assetManager.d.ts

@@ -1,5 +1,5 @@
 import { Definition } from '@kapeta/local-cluster-config';
-import { BlockDefinition } from '@kapeta/schemas';
+import { BlockDefinition, BlockInstance, Plan } from '@kapeta/schemas';
 import { SourceOfChange } from './types';
 export interface EnrichedAsset {
     ref: string;
@@ -19,7 +19,8 @@ declare class AssetManager {
      */
     getAssets(assetKinds?: string[]): Promise<EnrichedAsset[]>;
     getPlans(): Promise<EnrichedAsset[]>;
-    getPlan(ref: string, noCache?: boolean): Promise<Definition>;
+    getPlan(ref: string, noCache?: boolean): Promise<Plan>;
+    getBlockInstance(systemId: string, instanceId: string): Promise<BlockInstance>;
     getAsset(ref: string, noCache?: boolean, autoFetch?: boolean): Promise<EnrichedAsset | undefined>;
     createAsset(path: string, yaml: BlockDefinition, sourceOfChange?: SourceOfChange): Promise<EnrichedAsset[]>;
     updateAsset(ref: string, yaml: BlockDefinition, sourceOfChange?: SourceOfChange): Promise<void>;

package/dist/esm/src/assetManager.js

@@ -68,11 +68,22 @@ class AssetManager {
     }
     async getPlan(ref, noCache = false) {
         const asset = await this.getAsset(ref, noCache);
+        if (!asset) {
+            throw new Error('Plan was not found: ' + ref);
+        }
         if ('core/plan' !== asset?.kind) {
             throw new Error('Asset was not a plan: ' + ref);
         }
         return asset.data;
     }
+    async getBlockInstance(systemId, instanceId) {
+        const plan = await this.getPlan(systemId, true);
+        const instance = plan.spec.blocks?.find((instance) => instance.id === instanceId);
+        if (!instance) {
+            throw new Error(`Instance not found: ${instanceId} in plan ${systemId}`);
+        }
+        return instance;
+    }
     async getAsset(ref, noCache = false, autoFetch = true) {
         ref = (0, utils_1.normalizeKapetaUri)(ref);
         const cacheKey = toKey(ref);

package/dist/esm/src/config/routes.js

@@ -18,11 +18,22 @@ router.use('/', stringBody_1.stringBody);
 /**
  * Returns the full configuration for a given service.
  */
-router.get('/instance', (req, res) => {
-    const config = req.kapeta.instanceId
-        ? configManager_1.configManager.getConfigForSection(req.kapeta.systemId, req.kapeta.instanceId)
-        : configManager_1.configManager.getConfigForSystem(req.kapeta.systemId);
-    res.send(config);
+router.get('/instance', async (req, res) => {
+    try {
+        let config = {};
+        if (req.kapeta.instanceId) {
+            config = await configManager_1.configManager.getConfigForBlockInstance(req.kapeta.systemId, req.kapeta.instanceId);
+        }
+        else {
+            config = configManager_1.configManager.getConfigForSystem(req.kapeta.systemId);
+        }
+        res.send(config);
+    }
+    catch (err) {
+        console.error('Failed to get instance config', err);
+        res.status(400).send({ error: err.message });
+        return;
+    }
 });
 /**
  * Updates the full configuration for a given service.

package/dist/esm/src/configManager.d.ts

@@ -12,6 +12,7 @@ declare class ConfigManager {
     _forSystem(systemId: string): any;
     setConfigForSystem(systemId: string, config: AnyMap): void;
     getConfigForSystem(systemId: string): AnyMap;
+    getConfigForBlockInstance(systemId: string, instanceId: string): Promise<import("./types").AnyMap>;
     setConfigForSection(systemId: string, sectionId: string, config: AnyMap): void;
     getConfigForSection(systemId: string, sectionId: string): any;
     /**

package/dist/esm/src/configManager.js

@@ -27,6 +27,15 @@ class ConfigManager {
         systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         return this._forSystem(systemId);
     }
+    async getConfigForBlockInstance(systemId, instanceId) {
+        const blockInstance = await assetManager_1.assetManager.getBlockInstance(systemId, instanceId);
+        const blockAsset = await assetManager_1.assetManager.getAsset(blockInstance.block.ref, true);
+        if (!blockAsset) {
+            throw new Error(`Block definition not found: ${blockInstance.block.ref}`);
+        }
+        const instanceConfig = this.getConfigForSection(systemId, instanceId);
+        return (0, utils_1.getResolvedConfiguration)(blockAsset.data.spec.configuration, instanceConfig, blockInstance.defaultConfiguration);
+    }
     setConfigForSection(systemId, sectionId, config) {
         systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         let systemConfig = this._forSystem(systemId);

package/dist/esm/src/instanceManager.js

@@ -319,14 +319,7 @@ class InstanceManager {
     async start(systemId, instanceId) {
         return this.exclusive(systemId, instanceId, async () => {
             systemId = (0, utils_1.normalizeKapetaUri)(systemId);
-            const plan = await assetManager_1.assetManager.getPlan(systemId, true);
-            if (!plan) {
-                throw new Error('Plan not found: ' + systemId);
-            }
-            const blockInstance = plan.spec && plan.spec.blocks ? lodash_1.default.find(plan.spec.blocks, { id: instanceId }) : null;
-            if (!blockInstance) {
-                throw new Error('Block instance not found: ' + instanceId);
-            }
+            const blockInstance = await assetManager_1.assetManager.getBlockInstance(systemId, instanceId);
             const blockRef = (0, utils_1.normalizeKapetaUri)(blockInstance.block.ref);
             const blockAsset = await assetManager_1.assetManager.getAsset(blockRef, true);
             if (!blockAsset) {

package/dist/esm/src/networkManager.d.ts

@@ -1,4 +1,5 @@
-import { Connection, SimpleRequest, SimpleResponse } from './types';
+import { Connection } from '@kapeta/schemas';
+import { SimpleRequest, SimpleResponse } from './types';
 declare class NetworkManager {
     private _connections;
     private _sources;

package/dist/esm/src/proxy/routes.js

@@ -35,7 +35,7 @@ router.all('/:systemId/:consumerInstanceId/:consumerResourceName/:type/*', async
         const plan = await assetManager_1.assetManager.getPlan(req.params.systemId);
         // We can find the connection by the consumer information alone since
         // only 1 provider can be connected to a consumer resource at a time
-        const connection = lodash_1.default.find(plan.spec.connections, (connection) => {
+        const connection = plan.spec.connections.find((connection) => {
             return (connection.consumer.blockId.toLowerCase() === req.params.consumerInstanceId.toLowerCase() &&
                 connection.consumer.resourceName.toLowerCase() === req.params.consumerResourceName.toLowerCase());
         });

package/dist/esm/src/types.d.ts

@@ -1,5 +1,5 @@
 import express from 'express';
-import { Resource } from '@kapeta/schemas';
+import { Connection, Resource } from '@kapeta/schemas';
 import { StringBodyRequest } from './middleware/stringBody';
 import { KapetaRequest } from './middleware/kapeta';
 export type StringMap = {
@@ -68,16 +68,7 @@ export type InstanceInfo = {
     pid?: number | string | null;
     portType?: string;
 };
-interface ResourceRef {
-    blockId: string;
-    resourceName: string;
-}
 export type ProxyRequestHandler = (req: StringBodyRequest, res: express.Response, info: ProxyRequestInfo) => void;
-export interface Connection {
-    mapping: any;
-    provider: ResourceRef;
-    consumer: ResourceRef;
-}
 export interface OperatorInfo {
     host: string;
     port: string;
@@ -105,4 +96,3 @@ export interface SimpleRequest {
     body: any;
 }
 export type KapetaBodyRequest = KapetaRequest & StringBodyRequest;
-export {};

package/package.json

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

package/src/assetManager.ts

@@ -6,7 +6,7 @@ import { codeGeneratorManager } from './codeGeneratorManager';
 import { ProgressListener } from './progressListener';
 import { parseKapetaUri } from '@kapeta/nodejs-utils';
 import { repositoryManager } from './repositoryManager';
-import { BlockDefinition } from '@kapeta/schemas';
+import { BlockDefinition, BlockInstance, Plan } from '@kapeta/schemas';
 import { Actions } from '@kapeta/nodejs-registry-utils';
 import { definitionsManager } from './definitionsManager';
 import { normalizeKapetaUri } from './utils/utils';
@@ -86,14 +86,29 @@ class AssetManager {
         return this.getAssets(['core/plan']);
     }
 
-    async getPlan(ref: string, noCache: boolean = false) {
+    async getPlan(ref: string, noCache: boolean = false): Promise<Plan> {
         const asset = await this.getAsset(ref, noCache);
 
+        if (!asset) {
+            throw new Error('Plan was not found: ' + ref);
+        }
+
         if ('core/plan' !== asset?.kind) {
             throw new Error('Asset was not a plan: ' + ref);
         }
 
-        return asset.data;
+        return asset.data as Plan;
+    }
+
+    async getBlockInstance(systemId: string, instanceId: string): Promise<BlockInstance> {
+        const plan = await this.getPlan(systemId, true);
+
+        const instance = plan.spec.blocks?.find((instance) => instance.id === instanceId);
+        if (!instance) {
+            throw new Error(`Instance not found: ${instanceId} in plan ${systemId}`);
+        }
+
+        return instance;
     }
 
     async getAsset(

package/src/config/routes.ts

@@ -6,8 +6,10 @@ import { instanceManager } from '../instanceManager';
 import { corsHandler } from '../middleware/cors';
 import { kapetaHeaders, KapetaRequest } from '../middleware/kapeta';
 import { stringBody } from '../middleware/stringBody';
-import { KapetaBodyRequest } from '../types';
+import { AnyMap, KapetaBodyRequest } from '../types';
 import { Response } from 'express';
+import { getResolvedConfiguration, normalizeKapetaUri } from '../utils/utils';
+import { assetManager } from '../assetManager';
 
 const router = Router();
 
@@ -18,12 +20,21 @@ router.use('/', stringBody);
 /**
  * Returns the full configuration for a given service.
  */
-router.get('/instance', (req: KapetaBodyRequest, res: Response) => {
-    const config = req.kapeta!.instanceId
-        ? configManager.getConfigForSection(req.kapeta!.systemId, req.kapeta!.instanceId)
-        : configManager.getConfigForSystem(req.kapeta!.systemId);
+router.get('/instance', async (req: KapetaBodyRequest, res: Response) => {
+    try {
+        let config: AnyMap = {};
+        if (req.kapeta!.instanceId) {
+            config = await configManager.getConfigForBlockInstance(req.kapeta!.systemId, req.kapeta!.instanceId);
+        } else {
+            config = configManager.getConfigForSystem(req.kapeta!.systemId);
+        }
 
-    res.send(config);
+        res.send(config);
+    } catch (err: any) {
+        console.error('Failed to get instance config', err);
+        res.status(400).send({ error: err.message });
+        return;
+    }
 });
 
 /**

package/src/configManager.ts

@@ -3,7 +3,7 @@ import { BlockInstance } from '@kapeta/schemas';
 import { storageService } from './storageService';
 import { assetManager } from './assetManager';
 import { parseKapetaUri } from '@kapeta/nodejs-utils';
-import { normalizeKapetaUri } from './utils/utils';
+import { getResolvedConfiguration, normalizeKapetaUri } from './utils/utils';
 
 export const SYSTEM_ID = '$plan';
 type AnyMap = { [key: string]: any };
@@ -41,6 +41,20 @@ class ConfigManager {
         return this._forSystem(systemId);
     }
 
+    async getConfigForBlockInstance(systemId: string, instanceId: string) {
+        const blockInstance = await assetManager.getBlockInstance(systemId, instanceId);
+        const blockAsset = await assetManager.getAsset(blockInstance.block.ref, true);
+        if (!blockAsset) {
+            throw new Error(`Block definition not found: ${blockInstance.block.ref}`);
+        }
+        const instanceConfig = this.getConfigForSection(systemId, instanceId);
+        return getResolvedConfiguration(
+            blockAsset.data.spec.configuration,
+            instanceConfig,
+            blockInstance.defaultConfiguration
+        );
+    }
+
     setConfigForSection(systemId: string, sectionId: string, config: AnyMap) {
         systemId = normalizeKapetaUri(systemId);
         let systemConfig = this._forSystem(systemId);

package/src/instanceManager.ts

@@ -407,16 +407,7 @@ export class InstanceManager {
     public async start(systemId: string, instanceId: string): Promise<InstanceInfo | Task<InstanceInfo>> {
         return this.exclusive(systemId, instanceId, async () => {
             systemId = normalizeKapetaUri(systemId);
-            const plan = await assetManager.getPlan(systemId, true);
-            if (!plan) {
-                throw new Error('Plan not found: ' + systemId);
-            }
-
-            const blockInstance = plan.spec && plan.spec.blocks ? _.find(plan.spec.blocks, { id: instanceId }) : null;
-            if (!blockInstance) {
-                throw new Error('Block instance not found: ' + instanceId);
-            }
-
+            const blockInstance = await assetManager.getBlockInstance(systemId, instanceId);
             const blockRef = normalizeKapetaUri(blockInstance.block.ref);
 
             const blockAsset = await assetManager.getAsset(blockRef, true);

package/src/networkManager.ts

@@ -1,6 +1,6 @@
+import { Connection } from '@kapeta/schemas';
 import uuid from 'node-uuid';
-import { Connection, SimpleRequest, SimpleResponse } from './types';
-import express from 'express';
+import { SimpleRequest, SimpleResponse } from './types';
 import { normalizeKapetaUri } from './utils/utils';
 
 class NetworkManager {

package/src/proxy/routes.ts

@@ -42,7 +42,7 @@ router.all(
 
             // We can find the connection by the consumer information alone since
             // only 1 provider can be connected to a consumer resource at a time
-            const connection = _.find(plan.spec.connections, (connection) => {
+            const connection = plan.spec.connections.find((connection) => {
                 return (
                     connection.consumer.blockId.toLowerCase() === req.params.consumerInstanceId.toLowerCase() &&
                     connection.consumer.resourceName.toLowerCase() === req.params.consumerResourceName.toLowerCase()

package/src/types.ts

@@ -1,5 +1,5 @@
 import express from 'express';
-import { Resource } from '@kapeta/schemas';
+import { Connection, Resource } from '@kapeta/schemas';
 import { StringBodyRequest } from './middleware/stringBody';
 import { KapetaRequest } from './middleware/kapeta';
 
@@ -81,12 +81,6 @@ interface ResourceRef {
 
 export type ProxyRequestHandler = (req: StringBodyRequest, res: express.Response, info: ProxyRequestInfo) => void;
 
-export interface Connection {
-    mapping: any;
-    provider: ResourceRef;
-    consumer: ResourceRef;
-}
-
 export interface OperatorInfo {
     host: string;
     port: string;