@kapeta/local-cluster-service 0.16.8 → 0.18.0

package/dist/esm/src/api.js

@@ -1,21 +1,26 @@
-import Router from 'express-promise-router';
-import { corsHandler } from './middleware/cors';
-import { KapetaAPI } from '@kapeta/nodejs-api-client';
-import ClusterConfiguration from '@kapeta/local-cluster-config';
+"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 cors_1 = require("./middleware/cors");
+const nodejs_api_client_1 = require("@kapeta/nodejs-api-client");
+const local_cluster_config_1 = __importDefault(require("@kapeta/local-cluster-config"));
 const { createAPIRoute } = require('@kapeta/web-microfrontend/server');
 const packageJson = require('../package.json');
-const router = Router();
-const remoteServices = ClusterConfiguration.getClusterConfig().remoteServices ?? {};
-router.use('/', corsHandler);
+const router = (0, express_promise_router_1.default)();
+const remoteServices = local_cluster_config_1.default.getClusterConfig().remoteServices ?? {};
+router.use('/', cors_1.corsHandler);
 router.use('/registry', createAPIRoute(remoteServices.registry ?? 'https://registry.kapeta.com', {
     nonce: false,
     userAgent: `KapetaDesktopCluster/${packageJson.version}`,
     tokenFetcher: () => {
-        const api = new KapetaAPI();
+        const api = new nodejs_api_client_1.KapetaAPI();
         if (api.hasToken()) {
             return api.getAccessToken();
         }
         return null;
     },
 }));
-export default router;
+exports.default = router;

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

@@ -17,8 +17,8 @@ declare class AssetManager {
      * @param {string[]} [assetKinds]
      * @returns {{path: *, ref: string, data: *, editable: boolean, kind: *, exists: boolean}[]}
      */
-    getAssets(assetKinds?: string[]): EnrichedAsset[];
-    getPlans(): EnrichedAsset[];
+    getAssets(assetKinds?: string[]): Promise<EnrichedAsset[]>;
+    getPlans(): Promise<EnrichedAsset[]>;
     getPlan(ref: string, noCache?: boolean): Promise<Definition>;
     getAsset(ref: string, noCache?: boolean, autoFetch?: boolean): Promise<EnrichedAsset | undefined>;
     createAsset(path: string, yaml: BlockDefinition, sourceOfChange?: SourceOfChange): Promise<EnrichedAsset[]>;

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) {
@@ -42,9 +48,9 @@ class AssetManager {
      * @param {string[]} [assetKinds]
      * @returns {{path: *, ref: string, data: *, editable: boolean, kind: *, exists: boolean}[]}
      */
-    getAssets(assetKinds) {
+    async getAssets(assetKinds) {
         if (!assetKinds) {
-            const blockTypeProviders = definitionsManager.getDefinitions([
+            const blockTypeProviders = await definitionsManager_1.definitionsManager.getDefinitions([
                 'core/block-type',
                 'core/block-type-operator',
             ]);
@@ -53,10 +59,10 @@ class AssetManager {
             });
             assetKinds.push('core/plan');
         }
-        const assets = definitionsManager.getDefinitions(assetKinds);
+        const assets = await definitionsManager_1.definitionsManager.getDefinitions(assetKinds);
         return assets.map(enrichAsset);
     }
-    getPlans() {
+    async getPlans() {
         return this.getAssets(['core/plan']);
     }
     async getPlan(ref, noCache = false) {
@@ -67,51 +73,50 @@ 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
-            .getDefinitions()
-            .map(enrichAsset)
-            .find((a) => parseKapetaUri(a.ref).equals(uri));
-        if (autoFetch && !asset) {
+        const definitionInfo = await definitionsManager_1.definitionsManager.getDefinition(ref);
+        if (autoFetch && !definitionInfo) {
             throw new Error('Asset not found: ' + ref);
         }
-        if (asset) {
-            cacheManager.set(cacheKey, asset, CACHE_TTL);
+        if (definitionInfo) {
+            const asset = enrichAsset(definitionInfo);
+            cacheManager_1.cacheManager.set(cacheKey, asset, CACHE_TTL);
+            return asset;
         }
-        return asset;
+        return undefined;
     }
     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);
+        await 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,31 +127,32 @@ 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();
-        this.maybeGenerateCode(asset.ref, asset.ymlPath, yaml);
+        cacheManager_1.cacheManager.remove(toKey(ref));
+        definitionsManager_1.definitionsManager.clearCache();
+        await 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();
-        return this.getAssets().filter((a) => refs.some((ref) => compareRefs(ref, a.ref)));
+        definitionsManager_1.definitionsManager.clearCache();
+        const assets = await this.getAssets();
+        return assets.filter((a) => refs.some((ref) => compareRefs(ref, a.ref)));
     }
     async unregisterAsset(ref) {
         const asset = await this.getAsset(ref, true);
@@ -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);
+    async maybeGenerateCode(ref, ymlPath, block) {
+        ref = (0, utils_1.normalizeKapetaUri)(ref);
+        if (await 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([]));
+router.get('/', async (req, res) => {
+    res.send(await 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/authManager.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+import { EventEmitter } from 'node:events';
+declare class AuthManager extends EventEmitter {
+    private watcher?;
+    private hadToken;
+    constructor();
+    listenForChanges(): void;
+    private hasToken;
+    private handleFileChange;
+}
+export declare const authManager: AuthManager;
+export {};

package/dist/esm/src/authManager.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authManager = void 0;
+const node_events_1 = require("node:events");
+const node_path_1 = __importDefault(require("node:path"));
+const chokidar_1 = __importDefault(require("chokidar"));
+const local_cluster_config_1 = __importDefault(require("@kapeta/local-cluster-config"));
+const definitionsManager_1 = require("./definitionsManager");
+const nodejs_api_client_1 = require("@kapeta/nodejs-api-client");
+const socketManager_1 = require("./socketManager");
+class AuthManager extends node_events_1.EventEmitter {
+    watcher;
+    hadToken;
+    constructor() {
+        super();
+        this.hadToken = this.hasToken();
+    }
+    listenForChanges() {
+        const parentDir = node_path_1.default.dirname(local_cluster_config_1.default.getKapetaBasedir());
+        //We watch the parent dir to catch changes to the base dir itself
+        this.watcher = chokidar_1.default.watch(parentDir, {
+            followSymlinks: false,
+            ignorePermissionErrors: true,
+            disableGlobbing: true,
+            persistent: true,
+            ignoreInitial: true,
+            depth: 1,
+            ignored: (path) => {
+                return !path.startsWith(local_cluster_config_1.default.getKapetaBasedir());
+            },
+        });
+        this.watcher.add(local_cluster_config_1.default.getKapetaBasedir());
+        this.watcher.on('all', this.handleFileChange.bind(this));
+        this.watcher.on('error', (error) => {
+            console.log('Error watching repository', error);
+        });
+        this.watcher.on('ready', () => {
+            console.log('Watching for auth changes: %s', local_cluster_config_1.default.getKapetaBasedir());
+        });
+    }
+    hasToken() {
+        const api = new nodejs_api_client_1.KapetaAPI();
+        return api.hasToken();
+    }
+    async handleFileChange(eventName, path) {
+        const hasTokenNow = this.hasToken();
+        if (this.hadToken !== hasTokenNow) {
+            socketManager_1.socketManager.emitGlobal('auth-change', {});
+            if (hasTokenNow) {
+                // Clear the cache in case we need to rewrite the sample plan
+                definitionsManager_1.definitionsManager.clearCache();
+            }
+            this.hadToken = hasTokenNow;
+        }
+    }
+}
+exports.authManager = new AuthManager();

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.d.ts

@@ -1,7 +1,7 @@
 import { BlockDefinition } from '@kapeta/schemas';
 declare class CodeGeneratorManager {
     reload(): Promise<void>;
-    canGenerateCode(yamlContent: BlockDefinition): boolean;
+    canGenerateCode(yamlContent: BlockDefinition): Promise<boolean>;
     generate(yamlFile: string, yamlContent: BlockDefinition): Promise<void>;
 }
 export declare const codeGeneratorManager: CodeGeneratorManager;

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 = await 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) {
@@ -23,25 +29,25 @@ class CodeGeneratorManager {
             }
         }
     }
-    canGenerateCode(yamlContent) {
+    async canGenerateCode(yamlContent) {
         if (!yamlContent.spec.target?.kind) {
             //Not all block types have targets
             return false;
         }
-        const blockTypes = definitionsManager.getDefinitions(BLOCK_TYPE_KIND);
+        const blockTypes = await 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();