@kapeta/local-cluster-service 0.16.8 → 0.17.0

package/dist/esm/src/assetManager.js

@@ -1,15 +1,21 @@
-import Path from 'node:path';
-import FS from 'fs-extra';
-import YAML from 'yaml';
-import { codeGeneratorManager } from './codeGeneratorManager';
-import { ProgressListener } from './progressListener';
-import { parseKapetaUri } from '@kapeta/nodejs-utils';
-import { repositoryManager } from './repositoryManager';
-import { Actions } from '@kapeta/nodejs-registry-utils';
-import { definitionsManager } from './definitionsManager';
-import { normalizeKapetaUri } from './utils/utils';
-import { taskManager } from './taskManager';
-import { cacheManager } from './cacheManager';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assetManager = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const yaml_1 = __importDefault(require("yaml"));
+const codeGeneratorManager_1 = require("./codeGeneratorManager");
+const progressListener_1 = require("./progressListener");
+const nodejs_utils_1 = require("@kapeta/nodejs-utils");
+const repositoryManager_1 = require("./repositoryManager");
+const nodejs_registry_utils_1 = require("@kapeta/nodejs-registry-utils");
+const definitionsManager_1 = require("./definitionsManager");
+const utils_1 = require("./utils/utils");
+const taskManager_1 = require("./taskManager");
+const cacheManager_1 = require("./cacheManager");
 const CACHE_TTL = 60 * 60 * 1000; // 1 hour
 const toKey = (ref) => `assetManager:asset:${ref}`;
 function enrichAsset(asset) {
@@ -44,7 +50,7 @@ class AssetManager {
      */
     getAssets(assetKinds) {
         if (!assetKinds) {
-            const blockTypeProviders = definitionsManager.getDefinitions([
+            const blockTypeProviders = definitionsManager_1.definitionsManager.getDefinitions([
                 'core/block-type',
                 'core/block-type-operator',
             ]);
@@ -53,7 +59,7 @@ class AssetManager {
             });
             assetKinds.push('core/plan');
         }
-        const assets = definitionsManager.getDefinitions(assetKinds);
+        const assets = definitionsManager_1.definitionsManager.getDefinitions(assetKinds);
         return assets.map(enrichAsset);
     }
     getPlans() {
@@ -67,51 +73,51 @@ class AssetManager {
         return asset.data;
     }
     async getAsset(ref, noCache = false, autoFetch = true) {
-        ref = normalizeKapetaUri(ref);
+        ref = (0, utils_1.normalizeKapetaUri)(ref);
         const cacheKey = toKey(ref);
-        if (!noCache && cacheManager.has(cacheKey)) {
-            return cacheManager.get(cacheKey);
+        if (!noCache && cacheManager_1.cacheManager.has(cacheKey)) {
+            return cacheManager_1.cacheManager.get(cacheKey);
         }
-        const uri = parseKapetaUri(ref);
+        const uri = (0, nodejs_utils_1.parseKapetaUri)(ref);
         if (autoFetch) {
-            await repositoryManager.ensureAsset(uri.handle, uri.name, uri.version, true);
+            await repositoryManager_1.repositoryManager.ensureAsset(uri.handle, uri.name, uri.version, true);
         }
-        let asset = definitionsManager
+        let asset = definitionsManager_1.definitionsManager
             .getDefinitions()
             .map(enrichAsset)
-            .find((a) => parseKapetaUri(a.ref).equals(uri));
+            .find((a) => (0, nodejs_utils_1.parseKapetaUri)(a.ref).equals(uri));
         if (autoFetch && !asset) {
             throw new Error('Asset not found: ' + ref);
         }
         if (asset) {
-            cacheManager.set(cacheKey, asset, CACHE_TTL);
+            cacheManager_1.cacheManager.set(cacheKey, asset, CACHE_TTL);
         }
         return asset;
     }
     async createAsset(path, yaml, sourceOfChange = 'filesystem') {
-        if (await FS.pathExists(path)) {
+        if (await fs_extra_1.default.pathExists(path)) {
             throw new Error('File already exists: ' + path);
         }
-        const dirName = Path.dirname(path);
-        if (!(await FS.pathExists(dirName))) {
-            await FS.mkdirp(dirName);
+        const dirName = node_path_1.default.dirname(path);
+        if (!(await fs_extra_1.default.pathExists(dirName))) {
+            await fs_extra_1.default.mkdirp(dirName);
         }
-        await repositoryManager.setSourceOfChangeFor(path, sourceOfChange);
-        await FS.writeFile(path, YAML.stringify(yaml));
+        await repositoryManager_1.repositoryManager.setSourceOfChangeFor(path, sourceOfChange);
+        await fs_extra_1.default.writeFile(path, yaml_1.default.stringify(yaml));
         const asset = await this.importFile(path);
         asset.forEach((a) => {
-            const ref = normalizeKapetaUri(a.ref);
+            const ref = (0, utils_1.normalizeKapetaUri)(a.ref);
             const key = toKey(ref);
-            cacheManager.set(key, a, CACHE_TTL);
+            cacheManager_1.cacheManager.set(key, a, CACHE_TTL);
         });
-        definitionsManager.clearCache();
+        definitionsManager_1.definitionsManager.clearCache();
         console.log(`Created asset at: ${path}`);
         const ref = `kapeta://${yaml.metadata.name}:local`;
         this.maybeGenerateCode(ref, path, yaml);
         return asset;
     }
     async updateAsset(ref, yaml, sourceOfChange = 'filesystem') {
-        ref = normalizeKapetaUri(ref);
+        ref = (0, utils_1.normalizeKapetaUri)(ref);
         const asset = await this.getAsset(ref, true, false);
         if (!asset) {
             throw new Error('Attempted to update unknown asset: ' + ref);
@@ -122,30 +128,30 @@ class AssetManager {
         if (!asset.ymlPath) {
             throw new Error('Attempted to update corrupted asset: ' + ref);
         }
-        await repositoryManager.setSourceOfChangeFor(asset.ymlPath, sourceOfChange);
-        await FS.writeFile(asset.ymlPath, YAML.stringify(yaml));
+        await repositoryManager_1.repositoryManager.setSourceOfChangeFor(asset.ymlPath, sourceOfChange);
+        await fs_extra_1.default.writeFile(asset.ymlPath, yaml_1.default.stringify(yaml));
         console.log(`Updated asset at: ${asset.ymlPath}`);
-        cacheManager.remove(toKey(ref));
-        definitionsManager.clearCache();
+        cacheManager_1.cacheManager.remove(toKey(ref));
+        definitionsManager_1.definitionsManager.clearCache();
         this.maybeGenerateCode(asset.ref, asset.ymlPath, yaml);
     }
     async importFile(filePath) {
         if (filePath.startsWith('file://')) {
             filePath = filePath.substring('file://'.length);
         }
-        if (!(await FS.pathExists(filePath))) {
+        if (!(await fs_extra_1.default.pathExists(filePath))) {
             throw new Error('File not found: ' + filePath);
         }
-        const content = await FS.readFile(filePath);
-        const assetInfos = YAML.parseAllDocuments(content.toString()).map((doc) => doc.toJSON());
-        await Actions.link(new ProgressListener(), Path.dirname(filePath));
+        const content = await fs_extra_1.default.readFile(filePath);
+        const assetInfos = yaml_1.default.parseAllDocuments(content.toString()).map((doc) => doc.toJSON());
+        await nodejs_registry_utils_1.Actions.link(new progressListener_1.ProgressListener(), node_path_1.default.dirname(filePath));
         const version = 'local';
-        const refs = assetInfos.map((assetInfo) => normalizeKapetaUri(`kapeta://${assetInfo.metadata.name}:${version}`));
+        const refs = assetInfos.map((assetInfo) => (0, utils_1.normalizeKapetaUri)(`kapeta://${assetInfo.metadata.name}:${version}`));
         refs.forEach((ref) => {
             const key = toKey(ref);
-            cacheManager.remove(key);
+            cacheManager_1.cacheManager.remove(key);
         });
-        definitionsManager.clearCache();
+        definitionsManager_1.definitionsManager.clearCache();
         return this.getAssets().filter((a) => refs.some((ref) => compareRefs(ref, a.ref)));
     }
     async unregisterAsset(ref) {
@@ -154,28 +160,28 @@ class AssetManager {
             throw new Error('Asset does not exists: ' + ref);
         }
         const key = toKey(ref);
-        cacheManager.remove(key);
-        definitionsManager.clearCache();
-        await Actions.uninstall(new ProgressListener(), [asset.ref]);
+        cacheManager_1.cacheManager.remove(key);
+        definitionsManager_1.definitionsManager.clearCache();
+        await nodejs_registry_utils_1.Actions.uninstall(new progressListener_1.ProgressListener(), [asset.ref]);
     }
     async installAsset(ref) {
         const asset = await this.getAsset(ref, true, false);
         if (asset) {
             throw new Error('Asset already installed: ' + ref);
         }
-        const uri = parseKapetaUri(ref);
+        const uri = (0, nodejs_utils_1.parseKapetaUri)(ref);
         console.log('Installing %s', ref);
         const key = toKey(ref);
-        cacheManager.remove(key);
-        definitionsManager.clearCache();
-        return await repositoryManager.ensureAsset(uri.handle, uri.name, uri.version, false);
+        cacheManager_1.cacheManager.remove(key);
+        definitionsManager_1.definitionsManager.clearCache();
+        return await repositoryManager_1.repositoryManager.ensureAsset(uri.handle, uri.name, uri.version, false);
     }
     maybeGenerateCode(ref, ymlPath, block) {
-        ref = normalizeKapetaUri(ref);
-        if (codeGeneratorManager.canGenerateCode(block)) {
-            const assetTitle = block.metadata.title ? block.metadata.title : parseKapetaUri(block.metadata.name).name;
-            taskManager.add(`codegen:${ref}`, async () => {
-                await codeGeneratorManager.generate(ymlPath, block);
+        ref = (0, utils_1.normalizeKapetaUri)(ref);
+        if (codeGeneratorManager_1.codeGeneratorManager.canGenerateCode(block)) {
+            const assetTitle = block.metadata.title ? block.metadata.title : (0, nodejs_utils_1.parseKapetaUri)(block.metadata.name).name;
+            taskManager_1.taskManager.add(`codegen:${ref}`, async () => {
+                await codeGeneratorManager_1.codeGeneratorManager.generate(ymlPath, block);
             }, {
                 name: `Generating code for ${assetTitle}`,
             });
@@ -184,4 +190,4 @@ class AssetManager {
         return false;
     }
 }
-export const assetManager = new AssetManager();
+exports.assetManager = new AssetManager();

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

@@ -1,8 +1,13 @@
-import Router from 'express-promise-router';
-import YAML from 'yaml';
-import { assetManager } from '../assetManager';
-import { corsHandler } from '../middleware/cors';
-import { stringBody } from '../middleware/stringBody';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_promise_router_1 = __importDefault(require("express-promise-router"));
+const yaml_1 = __importDefault(require("yaml"));
+const assetManager_1 = require("../assetManager");
+const cors_1 = require("../middleware/cors");
+const stringBody_1 = require("../middleware/stringBody");
 function parseBody(req) {
     switch (req.headers['content-type']) {
         case 'application/json':
@@ -14,17 +19,17 @@ function parseBody(req) {
         case 'text/yaml':
         case 'text/x-yaml':
         default:
-            return YAML.parse(req.stringBody ?? '{}');
+            return yaml_1.default.parse(req.stringBody ?? '{}');
     }
 }
-const router = Router();
-router.use('/', corsHandler);
-router.use('/', stringBody);
+const router = (0, express_promise_router_1.default)();
+router.use('/', cors_1.corsHandler);
+router.use('/', stringBody_1.stringBody);
 /**
  * Get all local assets available
  */
 router.get('/', (req, res) => {
-    res.send(assetManager.getAssets([]));
+    res.send(assetManager_1.assetManager.getAssets([]));
 });
 /**
  * Get single asset
@@ -36,7 +41,7 @@ router.get('/read', async (req, res) => {
     }
     const ensure = req.query.ensure !== 'false';
     try {
-        const asset = await assetManager.getAsset(req.query.ref, true, ensure);
+        const asset = await assetManager_1.assetManager.getAsset(req.query.ref, true, ensure);
         if (asset) {
             res.send(asset);
         }
@@ -58,7 +63,7 @@ router.post('/create', async (req, res) => {
     }
     const content = parseBody(req);
     try {
-        const assets = await assetManager.createAsset(req.query.path, content, 'user');
+        const assets = await assetManager_1.assetManager.createAsset(req.query.path, content, 'user');
         res.status(200).send(assets);
     }
     catch (err) {
@@ -76,7 +81,7 @@ router.put('/update', async (req, res) => {
     }
     const content = parseBody(req);
     try {
-        await assetManager.updateAsset(req.query.ref, content, 'user');
+        await assetManager_1.assetManager.updateAsset(req.query.ref, content, 'user');
         res.sendStatus(204);
     }
     catch (err) {
@@ -93,7 +98,7 @@ router.delete('/', async (req, res) => {
         return;
     }
     try {
-        await assetManager.unregisterAsset(req.query.ref);
+        await assetManager_1.assetManager.unregisterAsset(req.query.ref);
         res.status(204).send();
     }
     catch (err) {
@@ -109,7 +114,7 @@ router.put('/import', async (req, res) => {
         return;
     }
     try {
-        const assets = await assetManager.importFile(req.query.ref);
+        const assets = await assetManager_1.assetManager.importFile(req.query.ref);
         res.status(200).send(assets);
     }
     catch (err) {
@@ -122,7 +127,7 @@ router.put('/install', async (req, res) => {
         return;
     }
     try {
-        const tasks = await assetManager.installAsset(req.query.ref);
+        const tasks = await assetManager_1.assetManager.installAsset(req.query.ref);
         const taskIds = tasks?.map((t) => t.id) ?? [];
         res.status(200).send(taskIds);
     }
@@ -130,4 +135,4 @@ router.put('/install', async (req, res) => {
         res.status(400).send({ error: err.message });
     }
 });
-export default router;
+exports.default = router;

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

@@ -1,15 +1,20 @@
-import Router from 'express-promise-router';
-import { KapetaAPI } from '@kapeta/nodejs-api-client';
-import { corsHandler } from '../middleware/cors';
-import { storageService } from '../storageService';
-const router = Router();
-const api = new KapetaAPI();
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_promise_router_1 = __importDefault(require("express-promise-router"));
+const nodejs_api_client_1 = require("@kapeta/nodejs-api-client");
+const cors_1 = require("../middleware/cors");
+const storageService_1 = require("../storageService");
+const router = (0, express_promise_router_1.default)();
+const api = new nodejs_api_client_1.KapetaAPI();
 const DEFAULT_REGISTRY_BASE = 'https://registry.kapeta.com';
 function getBaseUrl() {
-    const endpoint = storageService.get('endpoints', 'registry', DEFAULT_REGISTRY_BASE);
+    const endpoint = storageService_1.storageService.get('endpoints', 'registry', DEFAULT_REGISTRY_BASE);
     return `${endpoint}/v1/registry`;
 }
-router.use('/', corsHandler);
+router.use('/', cors_1.corsHandler);
 router.put('/:handle/:name', async (req, res) => {
     if (!api.hasToken()) {
         res.status(401).send({
@@ -60,4 +65,4 @@ router.put('/:handle/:name', async (req, res) => {
         res.status(e.status ?? 500).send(e);
     }
 });
-export default router;
+exports.default = router;

package/dist/esm/src/cacheManager.js

@@ -1,7 +1,13 @@
-import NodeCache from 'node-cache';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doCached = exports.cacheManager = exports.CacheManager = void 0;
+const node_cache_1 = __importDefault(require("node-cache"));
 const DEFAULT_CACHE_TTL = 60 * 1000; // 1 min
-export class CacheManager {
-    cache = new NodeCache();
+class CacheManager {
+    cache = new node_cache_1.default();
     flush() {
         this.cache.flushAll();
     }
@@ -35,5 +41,7 @@ export class CacheManager {
         }
     }
 }
-export const cacheManager = new CacheManager();
-export const doCached = (key, getter, ttl = DEFAULT_CACHE_TTL) => cacheManager.doCached(key, getter, ttl);
+exports.CacheManager = CacheManager;
+exports.cacheManager = new CacheManager();
+const doCached = (key, getter, ttl = DEFAULT_CACHE_TTL) => exports.cacheManager.doCached(key, getter, ttl);
+exports.doCached = doCached;

package/dist/esm/src/clusterService.js

@@ -1,4 +1,7 @@
-import { normalizeKapetaUri } from './utils/utils';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clusterService = void 0;
+const utils_1 = require("./utils/utils");
 const net = require('net');
 const DEFAULT_SERVER_PORT = 35100;
 const DEFAULT_START_PORT = 40000;
@@ -106,8 +109,8 @@ class ClusterService {
      * @return {string}
      */
     getProxyPath(systemId, consumerInstanceId, consumerResourceName, portType) {
-        systemId = normalizeKapetaUri(systemId);
+        systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         return `/proxy/${encodeURIComponent(systemId)}/${encodeURIComponent(consumerInstanceId)}/${encodeURIComponent(consumerResourceName)}/${encodeURIComponent(portType)}/`;
     }
 }
-export const clusterService = new ClusterService();
+exports.clusterService = new ClusterService();

package/dist/esm/src/codeGeneratorManager.js

@@ -1,21 +1,27 @@
-import Path from 'path';
-import { registry as Targets, BlockCodeGenerator, CodeWriter } from '@kapeta/codegen';
-import { definitionsManager } from './definitionsManager';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codeGeneratorManager = void 0;
+const path_1 = __importDefault(require("path"));
+const codegen_1 = require("@kapeta/codegen");
+const definitionsManager_1 = require("./definitionsManager");
 const TARGET_KIND = 'core/language-target';
 const BLOCK_TYPE_KIND = 'core/block-type';
 class CodeGeneratorManager {
     async reload() {
-        Targets.reset();
-        const languageTargets = definitionsManager.getDefinitions(TARGET_KIND);
+        codegen_1.registry.reset();
+        const languageTargets = definitionsManager_1.definitionsManager.getDefinitions(TARGET_KIND);
         for (const languageTarget of languageTargets) {
             const key = `${languageTarget.definition.metadata.name}:${languageTarget.version}`;
             try {
                 const target = require(languageTarget.path);
                 if (target.default) {
-                    Targets.register(key, target.default);
+                    codegen_1.registry.register(key, target.default);
                 }
                 else {
-                    Targets.register(key, target);
+                    codegen_1.registry.register(key, target);
                 }
             }
             catch (e) {
@@ -28,20 +34,20 @@ class CodeGeneratorManager {
             //Not all block types have targets
             return false;
         }
-        const blockTypes = definitionsManager.getDefinitions(BLOCK_TYPE_KIND);
+        const blockTypes = definitionsManager_1.definitionsManager.getDefinitions(BLOCK_TYPE_KIND);
         const blockTypeKinds = blockTypes.map((blockType) => blockType.definition.metadata.name.toLowerCase() + ':' + blockType.version);
         return !!(yamlContent && yamlContent.kind && blockTypeKinds.indexOf(yamlContent.kind.toLowerCase()) > -1);
     }
     async generate(yamlFile, yamlContent) {
-        const baseDir = Path.dirname(yamlFile);
+        const baseDir = path_1.default.dirname(yamlFile);
         console.log('Generating code for path: %s', baseDir);
-        const codeGenerator = new BlockCodeGenerator(yamlContent);
+        const codeGenerator = new codegen_1.BlockCodeGenerator(yamlContent);
         const output = await codeGenerator.generate();
-        const writer = new CodeWriter(baseDir, {});
+        const writer = new codegen_1.CodeWriter(baseDir, {});
         const assets = writer.write(output);
         await codeGenerator.postprocess(baseDir, assets);
         console.log('Code generated for path: %s', baseDir);
     }
 }
-export const codeGeneratorManager = new CodeGeneratorManager();
-codeGeneratorManager.reload();
+exports.codeGeneratorManager = new CodeGeneratorManager();
+exports.codeGeneratorManager.reload();

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

@@ -1,23 +1,28 @@
-import Router from 'express-promise-router';
-import { configManager } from '../configManager';
-import { serviceManager } from '../serviceManager';
-import { operatorManager } from '../operatorManager';
-import { instanceManager } from '../instanceManager';
-import { corsHandler } from '../middleware/cors';
-import { kapetaHeaders } from '../middleware/kapeta';
-import { stringBody } from '../middleware/stringBody';
-const router = Router();
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_promise_router_1 = __importDefault(require("express-promise-router"));
+const configManager_1 = require("../configManager");
+const serviceManager_1 = require("../serviceManager");
+const operatorManager_1 = require("../operatorManager");
+const instanceManager_1 = require("../instanceManager");
+const cors_1 = require("../middleware/cors");
+const kapeta_1 = require("../middleware/kapeta");
+const stringBody_1 = require("../middleware/stringBody");
+const router = (0, express_promise_router_1.default)();
 const SYSTEM_ID = '$plan';
-router.use('/', corsHandler);
-router.use('/', kapetaHeaders);
-router.use('/', stringBody);
+router.use('/', cors_1.corsHandler);
+router.use('/', kapeta_1.kapetaHeaders);
+router.use('/', stringBody_1.stringBody);
 /**
  * Returns the full configuration for a given service.
  */
 router.get('/instance', (req, res) => {
     const config = req.kapeta.instanceId
-        ? configManager.getConfigForSection(req.kapeta.systemId, req.kapeta.instanceId)
-        : configManager.getConfigForSystem(req.kapeta.systemId);
+        ? configManager_1.configManager.getConfigForSection(req.kapeta.systemId, req.kapeta.instanceId)
+        : configManager_1.configManager.getConfigForSystem(req.kapeta.systemId);
     res.send(config);
 });
 /**
@@ -30,12 +35,12 @@ router.put('/instance', async (req, res) => {
             config = {};
         }
         if (req.kapeta.instanceId) {
-            configManager.setConfigForSection(req.kapeta.systemId, req.kapeta.instanceId, config);
+            configManager_1.configManager.setConfigForSection(req.kapeta.systemId, req.kapeta.instanceId, config);
             //Restart the instance if it is running after config change
-            await instanceManager.prepareForRestart(req.kapeta.systemId, req.kapeta.instanceId);
+            await instanceManager_1.instanceManager.prepareForRestart(req.kapeta.systemId, req.kapeta.instanceId);
         }
         else {
-            configManager.setConfigForSystem(req.kapeta.systemId, config);
+            configManager_1.configManager.setConfigForSystem(req.kapeta.systemId, config);
         }
     }
     catch (err) {
@@ -49,7 +54,7 @@ router.put('/instance', async (req, res) => {
  * Returns the full configuration for a plan
  */
 router.get('/system', (req, res) => {
-    const config = configManager.getConfigForSection(req.kapeta.systemId, SYSTEM_ID);
+    const config = configManager_1.configManager.getConfigForSection(req.kapeta.systemId, SYSTEM_ID);
     res.send(config);
 });
 /**
@@ -60,7 +65,7 @@ router.put('/system', (req, res) => {
     if (!config) {
         config = {};
     }
-    configManager.setConfigForSection(req.kapeta.systemId, SYSTEM_ID, config);
+    configManager_1.configManager.setConfigForSection(req.kapeta.systemId, SYSTEM_ID, config);
     res.status(202).send({ ok: true });
 });
 /**
@@ -77,12 +82,12 @@ router.get('/identity', async (req, res) => {
     }
     try {
         if (!identity.systemId || !identity.instanceId) {
-            const { systemId, instanceId } = await configManager.resolveIdentity(req.kapeta.blockRef, identity.systemId);
+            const { systemId, instanceId } = await configManager_1.configManager.resolveIdentity(req.kapeta.blockRef, identity.systemId);
             identity.systemId = systemId;
             identity.instanceId = instanceId;
         }
         else {
-            await configManager.verifyIdentity(req.kapeta.blockRef, identity.systemId, identity.instanceId);
+            await configManager_1.configManager.verifyIdentity(req.kapeta.blockRef, identity.systemId, identity.instanceId);
         }
         res.send(identity);
     }
@@ -97,7 +102,7 @@ router.get('/identity', async (req, res) => {
  */
 router.get('/provides/:type', async (req, res) => {
     //Get service port
-    res.send('' + (await serviceManager.ensureServicePort(req.kapeta.systemId, req.kapeta.instanceId, req.params.type)));
+    res.send('' + (await serviceManager_1.serviceManager.ensureServicePort(req.kapeta.systemId, req.kapeta.instanceId, req.params.type)));
 });
 /**
  * Used by services to get info for consumed operator resource.
@@ -106,7 +111,7 @@ router.get('/provides/:type', async (req, res) => {
  * assign port numbers to it etc.
  */
 router.get('/consumes/resource/:resourceType/:portType/:name', async (req, res) => {
-    const operatorInfo = await operatorManager.getConsumerResourceInfo(req.kapeta.systemId, req.kapeta.instanceId, req.params.resourceType, req.params.portType, req.params.name, req.kapeta.environment);
+    const operatorInfo = await operatorManager_1.operatorManager.getConsumerResourceInfo(req.kapeta.systemId, req.kapeta.instanceId, req.params.resourceType, req.params.portType, req.params.name, req.kapeta.environment);
     res.send(operatorInfo);
 });
 /**
@@ -116,6 +121,6 @@ router.get('/consumes/resource/:resourceType/:portType/:name', async (req, res)
  * to handle clients for services that hasn't started yet.
  */
 router.get('/consumes/:resourceName/:type', (req, res) => {
-    res.send(serviceManager.getConsumerAddress(req.kapeta.systemId, req.kapeta.instanceId, req.params.resourceName, req.params.type, req.kapeta.environment));
+    res.send(serviceManager_1.serviceManager.getConsumerAddress(req.kapeta.systemId, req.kapeta.instanceId, req.params.resourceName, req.params.type, req.kapeta.environment));
 });
-export default router;
+exports.default = router;