@kapeta/local-cluster-service 0.0.0-96f91ef

package/dist/esm/src/ai/transform.js

@@ -0,0 +1,239 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformToPlan = void 0;
+const definitionsManager_1 = require("../definitionsManager");
+const nodejs_utils_1 = require("@kapeta/nodejs-utils");
+const node_uuid_1 = __importDefault(require("node-uuid"));
+async function getFreeName(name) {
+    let currentName = name;
+    let iteration = 1;
+    do {
+        const found = await definitionsManager_1.definitionsManager.getLatestDefinition(currentName);
+        if (!found) {
+            return currentName;
+        }
+        currentName = name + '_' + iteration++;
+    } while (true);
+}
+const transformToPlan = async (handle, application) => {
+    const blockTypeService = await definitionsManager_1.definitionsManager.getLatestDefinition('kapeta/block-type-service');
+    const blockTypeFrontend = await definitionsManager_1.definitionsManager.getLatestDefinition('kapeta/block-type-frontend');
+    const mongoDbResource = await definitionsManager_1.definitionsManager.getLatestDefinition('kapeta/resource-type-mongodb');
+    const postgresResource = await definitionsManager_1.definitionsManager.getLatestDefinition('kapeta/resource-type-postgresql');
+    const webPageResource = await definitionsManager_1.definitionsManager.getLatestDefinition('kapeta/resource-type-web-page');
+    const webFragmentResource = await definitionsManager_1.definitionsManager.getLatestDefinition('kapeta/resource-type-web-fragment');
+    const restApiResource = await definitionsManager_1.definitionsManager.getLatestDefinition('kapeta/resource-type-rest-api');
+    const restClientResource = await definitionsManager_1.definitionsManager.getLatestDefinition('kapeta/resource-type-rest-client');
+    const javaLanguage = await definitionsManager_1.definitionsManager.getLatestDefinition('kapeta/language-target-java-spring-boot');
+    const nodejsLanguage = await definitionsManager_1.definitionsManager.getLatestDefinition('kapeta/language-target-nodejs');
+    const reactLanguage = await definitionsManager_1.definitionsManager.getLatestDefinition('kapeta/language-target-react-ts');
+    if (!blockTypeService ||
+        !blockTypeFrontend ||
+        !mongoDbResource ||
+        !postgresResource ||
+        !javaLanguage ||
+        !nodejsLanguage ||
+        !reactLanguage ||
+        !webPageResource ||
+        !restApiResource ||
+        !restClientResource ||
+        !webFragmentResource) {
+        throw new Error('Missing definitions');
+    }
+    const plan = {
+        kind: 'core/plan',
+        metadata: {
+            name: await getFreeName(`${handle}/${application.name}`),
+            title: application.title,
+            description: application.description,
+            visibility: 'private',
+        },
+        spec: {
+            blocks: [],
+            connections: [],
+        },
+    };
+    const blocks = [];
+    const addToPlan = (ref, name) => {
+        const top = 100 + Math.floor(plan.spec.blocks.length / 3) * 300;
+        const left = 200 + (plan.spec.blocks.length % 3) * 450;
+        plan.spec.blocks.push({
+            block: {
+                ref,
+            },
+            name,
+            id: node_uuid_1.default.v4(),
+            dimensions: {
+                top,
+                left,
+                width: -1,
+                height: -1,
+            },
+        });
+    };
+    const nameMapper = new Map();
+    for (const backend of application.backends) {
+        const blockName = `${handle}/${backend.name}`;
+        const blockRealName = await getFreeName(blockName);
+        nameMapper.set(blockName, blockRealName);
+        const language = backend.targetLanguage === 'java' ? javaLanguage : nodejsLanguage;
+        const databaseInfo = backend.databases?.[0];
+        const database = databaseInfo?.type === 'mongodb' ? mongoDbResource : postgresResource;
+        const blockRef = (0, nodejs_utils_1.normalizeKapetaUri)(blockRealName + ':local');
+        let targetOptions = {};
+        if (backend.targetLanguage === 'java') {
+            targetOptions = {
+                basePackage: `${handle}.${application.name}`.toLowerCase().replace(/-/g, '_'),
+                groupId: `${handle}.${application.name}`.toLowerCase().replace(/-/g, '_'),
+                artifactId: backend.name.toLowerCase().replace(/-/g, '_'),
+            };
+        }
+        blocks.push({
+            kind: (0, nodejs_utils_1.normalizeKapetaUri)(`${blockTypeService.definition.metadata.name}:${blockTypeService.version}`),
+            metadata: {
+                name: blockRealName,
+                title: backend.title,
+                description: backend.description,
+                visibility: 'private',
+            },
+            spec: {
+                target: {
+                    kind: (0, nodejs_utils_1.normalizeKapetaUri)(`${language.definition.metadata.name}:${language.version}`),
+                    options: targetOptions,
+                },
+                consumers: [
+                    {
+                        kind: (0, nodejs_utils_1.normalizeKapetaUri)(`${database.definition.metadata.name}:${database.version}`),
+                        metadata: {
+                            name: (databaseInfo?.name ?? 'main').replace(/-/g, ''),
+                        },
+                        spec: {
+                            port: {
+                                type: database.definition.spec.ports[0].type,
+                            },
+                        },
+                    },
+                ],
+                providers: [
+                    {
+                        kind: (0, nodejs_utils_1.normalizeKapetaUri)(`${restApiResource.definition.metadata.name}:${restApiResource.version}`),
+                        metadata: {
+                            name: 'main',
+                        },
+                        spec: {
+                            port: {
+                                type: restApiResource.definition.spec.ports[0].type,
+                            },
+                        },
+                    },
+                ],
+            },
+        });
+        addToPlan(blockRef, backend.name);
+    }
+    for (const frontend of application.frontends) {
+        const blockName = `${handle}/${frontend.name}`;
+        const blockRealName = await getFreeName(blockName);
+        nameMapper.set(blockName, blockRealName);
+        const language = reactLanguage;
+        const blockRef = (0, nodejs_utils_1.normalizeKapetaUri)(blockRealName + ':local');
+        blocks.push({
+            kind: (0, nodejs_utils_1.normalizeKapetaUri)(`${blockTypeFrontend.definition.metadata.name}:${blockTypeFrontend.version}`),
+            metadata: {
+                name: blockRealName,
+                title: frontend.title,
+                description: frontend.description,
+                visibility: 'private',
+            },
+            spec: {
+                target: {
+                    kind: (0, nodejs_utils_1.normalizeKapetaUri)(`${language.definition.metadata.name}:${language.version}`),
+                    options: {},
+                },
+                consumers: [],
+                providers: [
+                    {
+                        kind: (0, nodejs_utils_1.normalizeKapetaUri)(`${webPageResource.definition.metadata.name}:${webPageResource.version}`),
+                        metadata: {
+                            name: 'main',
+                        },
+                        spec: {
+                            port: {
+                                type: webPageResource.definition.spec.ports[0].type,
+                            },
+                        },
+                    },
+                ],
+            },
+        });
+        addToPlan(blockRef, frontend.name);
+    }
+    application.connections?.forEach((connection) => {
+        const fullProviderName = nameMapper.get(`${handle}/${connection.provider.name}`);
+        const fullConsumerName = nameMapper.get(`${handle}/${connection.consumer.name}`);
+        const consumerResourceName = connection.provider.name;
+        const providerRef = (0, nodejs_utils_1.normalizeKapetaUri)(`${fullProviderName}:local`);
+        const consumerRef = (0, nodejs_utils_1.normalizeKapetaUri)(`${fullConsumerName}:local`);
+        const instanceProvider = plan.spec.blocks.find((b) => b.block.ref === providerRef);
+        const instanceConsumer = plan.spec.blocks.find((b) => b.block.ref === consumerRef);
+        const consumerBlock = blocks.find((block) => block.metadata.name === fullConsumerName);
+        const providerBlock = blocks.find((block) => block.metadata.name === fullProviderName);
+        if (!consumerBlock) {
+            throw new Error('Missing consumer block: ' + fullConsumerName);
+        }
+        if (!providerBlock) {
+            throw new Error('Missing provider block: ' + fullProviderName);
+        }
+        const portType = (0, nodejs_utils_1.parseKapetaUri)(providerBlock.kind).fullName === 'kapeta/block-type-service' ? 'rest' : 'web';
+        if (portType === 'rest') {
+            consumerBlock.spec.consumers.push({
+                kind: (0, nodejs_utils_1.normalizeKapetaUri)(`${restClientResource.definition.metadata.name}:${restClientResource.version}`),
+                metadata: {
+                    name: consumerResourceName,
+                },
+                spec: {
+                    port: {
+                        type: 'rest',
+                    },
+                },
+            });
+        }
+        else {
+            consumerBlock.spec.consumers.push({
+                kind: (0, nodejs_utils_1.normalizeKapetaUri)(`${webFragmentResource.definition.metadata.name}:${webFragmentResource.version}`),
+                metadata: {
+                    name: consumerResourceName,
+                },
+                spec: {
+                    port: {
+                        type: 'web',
+                    },
+                },
+            });
+        }
+        plan.spec.connections.push({
+            provider: {
+                blockId: instanceProvider.id,
+                resourceName: 'main',
+                port: {
+                    type: portType,
+                },
+            },
+            consumer: {
+                blockId: instanceConsumer.id,
+                resourceName: consumerResourceName,
+                port: {
+                    type: portType,
+                },
+            },
+        });
+    });
+    return {
+        plan,
+        blocks,
+    };
+};
+exports.transformToPlan = transformToPlan;

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

@@ -0,0 +1,40 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+export interface Database {
+    name: string;
+    type: 'mongodb' | 'postgres';
+}
+export interface BackendService {
+    name: string;
+    title: string;
+    description: string;
+    targetLanguage: 'java' | 'node';
+    databases: Database[] | null;
+}
+export interface FrontendService {
+    name: string;
+    title: string;
+    description: string;
+    targetLanguage: 'react';
+}
+export interface Endpoint {
+    type: 'backend' | 'frontend';
+    name: string;
+}
+export interface Connection {
+    provider: Endpoint;
+    consumer: Endpoint;
+}
+export interface Application {
+    kind: 'core/plan';
+    name: string;
+    title: string;
+    description: string;
+    backends: BackendService[];
+    frontends: FrontendService[];
+    connections: Connection[];
+    explanation: string;
+    response: string;
+}

package/dist/esm/src/ai/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,7 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+/// <reference types="express" />
+declare const router: import("express").Router;
+export default router;

package/dist/esm/src/api.js

@@ -0,0 +1,29 @@
+"use strict";
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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 nodejs_registry_utils_1 = require("@kapeta/nodejs-registry-utils");
+const { createAPIRoute } = require('@kapeta/web-microfrontend/server');
+const packageJson = require('../package.json');
+const router = (0, express_promise_router_1.default)();
+router.use('/', cors_1.corsHandler);
+router.use('/registry', createAPIRoute(nodejs_registry_utils_1.Config.data?.registry?.url ?? 'https://registry.kapeta.com', {
+    nonce: false,
+    userAgent: `KapetaDesktopCluster/${packageJson.version}`,
+    tokenFetcher: () => {
+        const api = new nodejs_api_client_1.KapetaAPI();
+        if (api.hasToken()) {
+            return api.getAccessToken();
+        }
+        return null;
+    },
+}));
+exports.default = router;

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

@@ -0,0 +1,41 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+import { Definition } from '@kapeta/local-cluster-config';
+import { BlockDefinition, BlockInstance, Plan } from '@kapeta/schemas';
+import { Task } from './taskManager';
+import { SourceOfChange } from './types';
+export interface EnrichedAsset {
+    ref: string;
+    editable: boolean;
+    exists: boolean;
+    version: string;
+    kind: string;
+    data: Definition;
+    path: string;
+    ymlPath: string;
+}
+declare class AssetManager {
+    startUpgradeInterval(): void;
+    /**
+     *
+     * @param {string[]} [assetKinds]
+     * @returns {{path: *, ref: string, data: *, editable: boolean, kind: *, exists: boolean}[]}
+     */
+    getAssets(assetKinds?: string[]): Promise<EnrichedAsset[]>;
+    getPlans(): Promise<EnrichedAsset[]>;
+    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: Definition, sourceOfChange?: SourceOfChange): Promise<void>;
+    importFile(filePath: string): Promise<EnrichedAsset[]>;
+    unregisterAsset(ref: string): Promise<void>;
+    installAsset(ref: string, wait?: boolean): Promise<Task<void>[] | undefined>;
+    private cleanupUnusedProviders;
+    private upgradeAllProviders;
+    private maybeGenerateCode;
+}
+export declare const assetManager: AssetManager;
+export {};

package/dist/esm/src/assetManager.js

@@ -0,0 +1,274 @@
+"use strict";
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.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 taskManager_1 = require("./taskManager");
+const types_1 = require("./types");
+const cacheManager_1 = require("./cacheManager");
+const node_uuid_1 = __importDefault(require("node-uuid"));
+const node_os_1 = __importDefault(require("node:os"));
+const CACHE_TTL = 60 * 60 * 1000; // 1 hour
+const UPGRADE_CHECK_INTERVAL = 10 * 60 * 1000; // 10 minutes
+const toKey = (ref) => `assetManager:asset:${ref}`;
+function filterExists(asset) {
+    return fs_extra_1.default.existsSync(asset.path) && fs_extra_1.default.existsSync(asset.ymlPath);
+}
+function enrichAsset(asset) {
+    return {
+        ref: `kapeta://${asset.definition.metadata.name}:${asset.version}`,
+        editable: asset.version === 'local', //Only local versions are editable
+        exists: true,
+        version: asset.version,
+        kind: asset.definition.kind,
+        data: asset.definition,
+        path: fs_extra_1.default.realpathSync(asset.path),
+        ymlPath: fs_extra_1.default.realpathSync(asset.ymlPath),
+    };
+}
+function compareRefs(a, b) {
+    const [aProtocol, aId] = parseRef(a);
+    const [bProtocol, bId] = parseRef(b);
+    return aProtocol === bProtocol && aId === bId;
+}
+function parseRef(ref) {
+    let out = ref.split(/:\/\//, 2);
+    if (out.length === 1) {
+        return ['kapeta', ref.toLowerCase()];
+    }
+    return [out[0].toLowerCase(), out[1].toLowerCase()];
+}
+class AssetManager {
+    startUpgradeInterval() {
+        console.debug('Checking for upgrades...');
+        this.upgradeAllProviders()
+            .then((task) => {
+            return task && task.wait();
+        })
+            .catch((e) => {
+            console.error('Failed to upgrade providers', e);
+        })
+            .finally(() => {
+            setTimeout(() => {
+                this.startUpgradeInterval();
+            }, UPGRADE_CHECK_INTERVAL);
+        });
+    }
+    /**
+     *
+     * @param {string[]} [assetKinds]
+     * @returns {{path: *, ref: string, data: *, editable: boolean, kind: *, exists: boolean}[]}
+     */
+    async getAssets(assetKinds) {
+        if (!assetKinds) {
+            const blockTypeProviders = await definitionsManager_1.definitionsManager.getDefinitions([
+                types_1.KIND_BLOCK_TYPE,
+                types_1.KIND_BLOCK_TYPE_OPERATOR,
+                types_1.KIND_BLOCK_TYPE_EXECUTABLE,
+            ]);
+            assetKinds = blockTypeProviders.map((p) => {
+                return `${p.definition.metadata.name}:${p.version}`;
+            });
+            assetKinds.push('core/plan');
+        }
+        const assets = await definitionsManager_1.definitionsManager.getDefinitions(assetKinds);
+        return assets.filter(filterExists).map(enrichAsset);
+    }
+    async getPlans() {
+        return this.getAssets(['core/plan']);
+    }
+    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, nodejs_utils_1.normalizeKapetaUri)(ref);
+        const cacheKey = toKey(ref);
+        if (!noCache && cacheManager_1.cacheManager.has(cacheKey)) {
+            return cacheManager_1.cacheManager.get(cacheKey);
+        }
+        const uri = (0, nodejs_utils_1.parseKapetaUri)(ref);
+        if (autoFetch) {
+            await repositoryManager_1.repositoryManager.ensureAsset(uri.handle, uri.name, uri.version, true);
+        }
+        const definitionInfo = await definitionsManager_1.definitionsManager.getDefinition(ref);
+        if (autoFetch && !definitionInfo) {
+            throw new Error('Asset not found: ' + ref);
+        }
+        if (definitionInfo) {
+            const asset = enrichAsset(definitionInfo);
+            cacheManager_1.cacheManager.set(cacheKey, asset, CACHE_TTL);
+            return asset;
+        }
+        return undefined;
+    }
+    async createAsset(path, yaml, sourceOfChange = 'filesystem') {
+        if (await fs_extra_1.default.pathExists(path)) {
+            throw new Error('File already exists: ' + path);
+        }
+        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_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 = (0, nodejs_utils_1.normalizeKapetaUri)(a.ref);
+            const key = toKey(ref);
+            cacheManager_1.cacheManager.set(key, a, CACHE_TTL);
+        });
+        definitionsManager_1.definitionsManager.clearCache();
+        console.log(`Created asset at: ${path}`);
+        const ref = `kapeta://${yaml.metadata.name}:local`;
+        await this.maybeGenerateCode(ref, path, yaml);
+        return asset;
+    }
+    async updateAsset(ref, yaml, sourceOfChange = 'filesystem') {
+        ref = (0, nodejs_utils_1.normalizeKapetaUri)(ref);
+        const asset = await this.getAsset(ref, true, false);
+        if (!asset) {
+            throw new Error('Attempted to update unknown asset: ' + ref);
+        }
+        if (!asset.editable) {
+            throw new Error('Attempted to update read-only asset: ' + ref);
+        }
+        if (!asset.ymlPath) {
+            throw new Error('Attempted to update corrupted asset: ' + ref);
+        }
+        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_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_extra_1.default.pathExists(filePath))) {
+            throw new Error('File not found: ' + 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) => (0, nodejs_utils_1.normalizeKapetaUri)(`kapeta://${assetInfo.metadata.name}:${version}`));
+        refs.forEach((ref) => {
+            const key = toKey(ref);
+            cacheManager_1.cacheManager.remove(key);
+        });
+        definitionsManager_1.definitionsManager.clearCache();
+        // Get all possible asset kinds, to make sure we return the result if possible
+        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, false);
+        if (!asset) {
+            throw new Error('Asset does not exists: ' + ref);
+        }
+        const key = toKey(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, wait = false) {
+        const asset = await this.getAsset(ref, true, false);
+        if (asset) {
+            throw new Error('Asset already installed: ' + ref);
+        }
+        const uri = (0, nodejs_utils_1.parseKapetaUri)(ref);
+        console.log('Installing %s (sync: %s)', ref, wait);
+        const key = toKey(ref);
+        cacheManager_1.cacheManager.remove(key);
+        definitionsManager_1.definitionsManager.clearCache();
+        return await repositoryManager_1.repositoryManager.ensureAsset(uri.handle, uri.name, uri.version, wait);
+    }
+    async cleanupUnusedProviders() {
+        const unusedProviders = await repositoryManager_1.repositoryManager.getUnusedProviders();
+        if (unusedProviders.length < 1) {
+            return;
+        }
+        console.log('Cleaning up unused providers: ', unusedProviders);
+        await Promise.all(unusedProviders.map((ref) => {
+            return this.unregisterAsset(ref);
+        }));
+    }
+    async upgradeAllProviders() {
+        const providers = await definitionsManager_1.definitionsManager.getProviderDefinitions();
+        const names = providers.map((p) => p.definition.metadata.name);
+        const refs = await repositoryManager_1.repositoryManager.getUpdatableAssets(names);
+        if (refs.length < 1) {
+            await this.cleanupUnusedProviders();
+            return;
+        }
+        console.log('Installing updates', refs);
+        const updateAll = async (task) => {
+            const progressListener = new progressListener_1.TaskProgressListener(task);
+            try {
+                //We change to a temp dir to avoid issues with the current working directory
+                process.chdir(node_os_1.default.tmpdir());
+                await nodejs_registry_utils_1.Actions.install(progressListener, refs, {});
+                await this.cleanupUnusedProviders();
+            }
+            catch (e) {
+                console.error(`Failed to update assets: ${refs.join(',')}`, e);
+                throw e;
+            }
+            cacheManager_1.cacheManager.flush();
+            definitionsManager_1.definitionsManager.clearCache();
+        };
+        return taskManager_1.taskManager.add(`asset:update`, updateAll, {
+            name: `Installing ${refs.length} updates`,
+            group: 'asset:update:check',
+        });
+    }
+    async maybeGenerateCode(ref, ymlPath, block) {
+        ref = (0, nodejs_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;
+            const taskId = `codegen:${node_uuid_1.default.v4()}`;
+            const group = `codegen:${ref}`;
+            // We group the codegen tasks since we want to run them all but only 1 at a time per block
+            taskManager_1.taskManager.add(taskId, async () => {
+                await codeGeneratorManager_1.codeGeneratorManager.generate(ymlPath, block);
+            }, {
+                name: `Generating code for ${assetTitle}`,
+                group, //Group prevents multiple tasks from running at the same time
+            });
+            return true;
+        }
+        return false;
+    }
+}
+exports.assetManager = new AssetManager();

package/dist/esm/src/assets/routes.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+/// <reference types="express" />
+declare const router: import("express").Router;
+export default router;