@kapeta/local-cluster-service 0.16.8 → 0.18.0

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;

package/dist/esm/src/configManager.js

@@ -1,36 +1,39 @@
-import { storageService } from './storageService';
-import { assetManager } from './assetManager';
-import { parseKapetaUri } from '@kapeta/nodejs-utils';
-import { normalizeKapetaUri } from './utils/utils';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configManager = void 0;
+const storageService_1 = require("./storageService");
+const assetManager_1 = require("./assetManager");
+const nodejs_utils_1 = require("@kapeta/nodejs-utils");
+const utils_1 = require("./utils/utils");
 class ConfigManager {
     _config;
     constructor() {
-        this._config = storageService.section('config');
+        this._config = storageService_1.storageService.section('config');
     }
     _forSystem(systemId) {
-        systemId = normalizeKapetaUri(systemId);
+        systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         if (!this._config[systemId]) {
             this._config[systemId] = {};
         }
         return this._config[systemId];
     }
     setConfigForSystem(systemId, config) {
-        systemId = normalizeKapetaUri(systemId);
+        systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         const systemConfig = config || {};
-        storageService.put('config', systemId, systemConfig);
+        storageService_1.storageService.put('config', systemId, systemConfig);
     }
     getConfigForSystem(systemId) {
-        systemId = normalizeKapetaUri(systemId);
+        systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         return this._forSystem(systemId);
     }
     setConfigForSection(systemId, sectionId, config) {
-        systemId = normalizeKapetaUri(systemId);
+        systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         let systemConfig = this._forSystem(systemId);
         systemConfig[sectionId] = config || {};
-        storageService.put('config', systemId, systemConfig);
+        storageService_1.storageService.put('config', systemId, systemConfig);
     }
     getConfigForSection(systemId, sectionId) {
-        systemId = normalizeKapetaUri(systemId);
+        systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         const systemConfig = this._forSystem(systemId);
         if (!systemConfig[sectionId]) {
             systemConfig[sectionId] = {};
@@ -54,12 +57,12 @@ class ConfigManager {
      * @returns {Promise<{systemId:string,instanceId:string}>}
      */
     async resolveIdentity(blockRef, systemId) {
-        blockRef = normalizeKapetaUri(blockRef);
+        blockRef = (0, utils_1.normalizeKapetaUri)(blockRef);
         if (systemId) {
-            systemId = normalizeKapetaUri(systemId);
+            systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         }
-        const planAssets = assetManager.getPlans();
-        const blockUri = parseKapetaUri(blockRef);
+        const planAssets = await assetManager_1.assetManager.getPlans();
+        const blockUri = (0, nodejs_utils_1.parseKapetaUri)(blockRef);
         let matchingIdentities = [];
         planAssets.forEach((planAsset) => {
             if (systemId && planAsset.ref !== systemId) {
@@ -70,10 +73,10 @@ class ConfigManager {
                 return;
             }
             planAsset.data.spec.blocks.forEach((blockInstance) => {
-                const refUri = parseKapetaUri(blockInstance.block.ref);
+                const refUri = (0, nodejs_utils_1.parseKapetaUri)(blockInstance.block.ref);
                 if (refUri.equals(blockUri)) {
                     matchingIdentities.push({
-                        systemId: normalizeKapetaUri(planAsset.ref),
+                        systemId: (0, utils_1.normalizeKapetaUri)(planAsset.ref),
                         instanceId: blockInstance.id,
                     });
                 }
@@ -94,19 +97,19 @@ class ConfigManager {
         return matchingIdentities[0];
     }
     async verifyIdentity(blockRef, systemId, instanceId) {
-        blockRef = normalizeKapetaUri(blockRef);
-        systemId = normalizeKapetaUri(systemId);
-        const planAssets = assetManager.getPlans();
-        const systemUri = systemId ? parseKapetaUri(systemId) : null;
-        const blockUri = parseKapetaUri(blockRef);
+        blockRef = (0, utils_1.normalizeKapetaUri)(blockRef);
+        systemId = (0, utils_1.normalizeKapetaUri)(systemId);
+        const planAssets = await assetManager_1.assetManager.getPlans();
+        const systemUri = systemId ? (0, nodejs_utils_1.parseKapetaUri)(systemId) : null;
+        const blockUri = (0, nodejs_utils_1.parseKapetaUri)(blockRef);
         let found = false;
         planAssets.forEach((planAsset) => {
-            if (systemUri && !parseKapetaUri(planAsset.ref).equals(systemUri)) {
+            if (systemUri && !(0, nodejs_utils_1.parseKapetaUri)(planAsset.ref).equals(systemUri)) {
                 //Skip plans that do not match systemid if provided
                 return;
             }
             planAsset.data.spec.blocks.forEach((blockInstance) => {
-                if (blockInstance.id === instanceId && parseKapetaUri(blockInstance.block.ref).equals(blockUri)) {
+                if (blockInstance.id === instanceId && (0, nodejs_utils_1.parseKapetaUri)(blockInstance.block.ref).equals(blockUri)) {
                     found = true;
                 }
             });
@@ -116,4 +119,4 @@ class ConfigManager {
         }
     }
 }
-export const configManager = new ConfigManager();
+exports.configManager = new ConfigManager();

package/dist/esm/src/containerManager.js

@@ -1,21 +1,27 @@
-import Path from 'path';
-import { storageService } from './storageService';
-import os from 'os';
-import _ from 'lodash';
-import FSExtra from 'fs-extra';
-import { Docker } from 'node-docker-api';
-import { parseKapetaUri } from '@kapeta/nodejs-utils';
-import ClusterConfiguration from '@kapeta/local-cluster-config';
-import uuid from 'node-uuid';
-import md5 from 'md5';
-import { getBlockInstanceContainerName } from './utils/utils';
-import { KapetaAPI } from '@kapeta/nodejs-api-client';
-import { taskManager } from './taskManager';
-export const CONTAINER_LABEL_PORT_PREFIX = 'kapeta_port-';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.containerManager = exports.toLocalBindVolume = exports.getExtraHosts = exports.ContainerInfo = exports.HEALTH_CHECK_TIMEOUT = exports.CONTAINER_LABEL_PORT_PREFIX = void 0;
+const path_1 = __importDefault(require("path"));
+const storageService_1 = require("./storageService");
+const os_1 = __importDefault(require("os"));
+const lodash_1 = __importDefault(require("lodash"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const node_docker_api_1 = require("node-docker-api");
+const nodejs_utils_1 = require("@kapeta/nodejs-utils");
+const local_cluster_config_1 = __importDefault(require("@kapeta/local-cluster-config"));
+const node_uuid_1 = __importDefault(require("node-uuid"));
+const md5_1 = __importDefault(require("md5"));
+const utils_1 = require("./utils/utils");
+const nodejs_api_client_1 = require("@kapeta/nodejs-api-client");
+const taskManager_1 = require("./taskManager");
+exports.CONTAINER_LABEL_PORT_PREFIX = 'kapeta_port-';
 const NANO_SECOND = 1000000;
 const HEALTH_CHECK_INTERVAL = 3000;
 const HEALTH_CHECK_MAX = 20;
-export const HEALTH_CHECK_TIMEOUT = HEALTH_CHECK_INTERVAL * HEALTH_CHECK_MAX * 2;
+exports.HEALTH_CHECK_TIMEOUT = HEALTH_CHECK_INTERVAL * HEALTH_CHECK_MAX * 2;
 const promisifyStream = (stream, handler) => new Promise((resolve, reject) => {
     stream.on('data', handler);
     stream.on('end', resolve);
@@ -31,12 +37,12 @@ class ContainerManager {
         this._docker = null;
         this._alive = false;
         this._version = '';
-        this._mountDir = Path.join(storageService.getKapetaBasedir(), 'mounts');
-        FSExtra.mkdirpSync(this._mountDir);
+        this._mountDir = path_1.default.join(storageService_1.storageService.getKapetaBasedir(), 'mounts');
+        fs_extra_1.default.mkdirpSync(this._mountDir);
     }
     async initialize() {
         // Use the value from cluster-service.yml if configured
-        const dockerConfig = ClusterConfiguration.getDockerConfig();
+        const dockerConfig = local_cluster_config_1.default.getDockerConfig();
         const connectOptions = Object.keys(dockerConfig).length > 0
             ? [dockerConfig]
             : [
@@ -46,7 +52,7 @@ class ContainerManager {
                 { socketPath: '/var/run/docker.sock' },
                 // default macOS
                 {
-                    socketPath: Path.join(os.homedir(), '.docker/run/docker.sock'),
+                    socketPath: path_1.default.join(os_1.default.homedir(), '.docker/run/docker.sock'),
                 },
                 // Default http
                 { protocol: 'http', host: 'localhost', port: 2375 },
@@ -56,7 +62,7 @@ class ContainerManager {
             ];
         for (const opts of connectOptions) {
             try {
-                const client = new Docker({
+                const client = new node_docker_api_1.Docker({
                     ...opts,
                     timeout: 10000,
                 });
@@ -101,9 +107,9 @@ class ContainerManager {
         return this._alive;
     }
     getMountPoint(systemId, ref, mountName) {
-        const kindUri = parseKapetaUri(ref);
-        const systemUri = parseKapetaUri(systemId);
-        return Path.join(this._mountDir, systemUri.handle, systemUri.name, systemUri.version, kindUri.handle, kindUri.name, kindUri.version, mountName);
+        const kindUri = (0, nodejs_utils_1.parseKapetaUri)(ref);
+        const systemUri = (0, nodejs_utils_1.parseKapetaUri)(systemId);
+        return path_1.default.join(this._mountDir, systemUri.handle, systemUri.name, systemUri.version, kindUri.handle, kindUri.name, kindUri.version, mountName);
     }
     async createMounts(systemId, kind, mountOpts) {
         const mounts = {};
@@ -111,7 +117,7 @@ class ContainerManager {
             const mountOptList = Object.entries(mountOpts);
             for (const [mountName, containerPath] of mountOptList) {
                 const hostPath = this.getMountPoint(systemId, kind, mountName);
-                await FSExtra.mkdirp(hostPath);
+                await fs_extra_1.default.mkdirp(hostPath);
                 mounts[containerPath] = hostPath;
             }
         }
@@ -167,7 +173,7 @@ class ContainerManager {
         const taskName = `Pulling image ${friendlyImageName}`;
         const processor = async (task) => {
             const timeStarted = Date.now();
-            const api = new KapetaAPI();
+            const api = new nodejs_api_client_1.KapetaAPI();
             const accessToken = api.hasToken() ? await api.getAccessToken() : null;
             const auth = accessToken && image.startsWith('docker.kapeta.com/')
                 ? {
@@ -287,7 +293,7 @@ class ContainerManager {
             };
             task.emitUpdate();
         };
-        const task = taskManager.add(`docker:image:pull:${image}`, processor, {
+        const task = taskManager_1.taskManager.add(`docker:image:pull:${image}`, processor, {
             name: taskName,
             image,
             progress: -1,
@@ -297,7 +303,7 @@ class ContainerManager {
     }
     toDockerMounts(mounts) {
         const Mounts = [];
-        _.forEach(mounts, (Source, Target) => {
+        lodash_1.default.forEach(mounts, (Source, Target) => {
             Mounts.push({
                 Target,
                 Source: toLocalBindVolume(Source),
@@ -320,7 +326,7 @@ class ContainerManager {
         if (dockerOpts?.Labels?.HASH) {
             delete dockerOpts.Labels.HASH;
         }
-        const hash = md5(JSON.stringify(dockerOpts));
+        const hash = (0, md5_1.default)(JSON.stringify(dockerOpts));
         if (!dockerOpts.Labels) {
             dockerOpts.Labels = {};
         }
@@ -425,7 +431,7 @@ class ContainerManager {
         }
     }
     async remove(container, opts) {
-        const newName = 'deleting-' + uuid.v4();
+        const newName = 'deleting-' + node_uuid_1.default.v4();
         const containerData = container.data;
         // Rename the container first to avoid name conflicts if people start the same container
         await container.rename({ name: newName });
@@ -452,7 +458,7 @@ class ContainerManager {
         return new ContainerInfo(dockerContainer);
     }
     async getLogs(instance) {
-        const containerName = getBlockInstanceContainerName(instance.systemId, instance.instanceId);
+        const containerName = (0, utils_1.getBlockInstanceContainerName)(instance.systemId, instance.instanceId);
         const containerInfo = await this.getContainerByName(containerName);
         if (!containerInfo) {
             return [
@@ -467,7 +473,7 @@ class ContainerManager {
         return containerInfo.getLogs();
     }
 }
-export class ContainerInfo {
+class ContainerInfo {
     _container;
     /**
      *
@@ -501,7 +507,7 @@ export class ContainerInfo {
         await this._container.stop();
     }
     async remove(opts) {
-        await containerManager.remove(this._container, opts);
+        await exports.containerManager.remove(this._container, opts);
     }
     async getPort(type) {
         const ports = await this.getPorts();
@@ -530,14 +536,14 @@ export class ContainerInfo {
         }
         const portTypes = {};
         const ports = {};
-        _.forEach(inspectResult.Config.Labels, (portType, name) => {
-            if (!name.startsWith(CONTAINER_LABEL_PORT_PREFIX)) {
+        lodash_1.default.forEach(inspectResult.Config.Labels, (portType, name) => {
+            if (!name.startsWith(exports.CONTAINER_LABEL_PORT_PREFIX)) {
                 return;
             }
-            const hostPort = name.substr(CONTAINER_LABEL_PORT_PREFIX.length);
+            const hostPort = name.substr(exports.CONTAINER_LABEL_PORT_PREFIX.length);
             portTypes[hostPort] = portType;
         });
-        _.forEach(inspectResult.HostConfig.PortBindings, (portBindings, containerPortSpec) => {
+        lodash_1.default.forEach(inspectResult.HostConfig.PortBindings, (portBindings, containerPortSpec) => {
             let [containerPort, protocol] = containerPortSpec.split(/\//);
             const hostPort = portBindings[0].HostPort;
             const portType = portTypes[hostPort];
@@ -606,7 +612,8 @@ export class ContainerInfo {
         return out;
     }
 }
-export function getExtraHosts(dockerVersion) {
+exports.ContainerInfo = ContainerInfo;
+function getExtraHosts(dockerVersion) {
     if (process.platform !== 'darwin' && process.platform !== 'win32') {
         const [major, minor] = dockerVersion.split('.');
         if (parseInt(major) >= 20 && parseInt(minor) >= 10) {
@@ -619,6 +626,7 @@ export function getExtraHosts(dockerVersion) {
     }
     return undefined;
 }
+exports.getExtraHosts = getExtraHosts;
 /**
  * Ensure that the volume is in the correct format for the docker daemon on the host
  *
@@ -626,7 +634,7 @@ export function getExtraHosts(dockerVersion) {
  * Linux: /path/to/volume -> /path/to/volume
  * Mac: /path/to/volume -> /path/to/volume
  */
-export function toLocalBindVolume(volume) {
+function toLocalBindVolume(volume) {
     if (process.platform === 'win32') {
         //On Windows we need to convert c:\ to /c/
         return volume
@@ -637,4 +645,5 @@ export function toLocalBindVolume(volume) {
     }
     return volume;
 }
-export const containerManager = new ContainerManager();
+exports.toLocalBindVolume = toLocalBindVolume;
+exports.containerManager = new ContainerManager();

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

@@ -1,11 +1,12 @@
 import { DefinitionInfo } from '@kapeta/local-cluster-config';
+export declare const SAMPLE_PLAN_NAME = "kapeta/sample-nodejs-plan";
 declare class DefinitionsManager {
-    private getHash;
-    private getFullKey;
-    getDefinitions(kindFilter?: string | string[]): DefinitionInfo[];
-    exists(ref: string): boolean;
-    getProviderDefinitions(): DefinitionInfo[];
-    getDefinition(ref: string): DefinitionInfo | undefined;
+    private resolveDefinitionsAndSamples;
+    private applyFilters;
+    getDefinitions(kindFilter?: string | string[]): Promise<DefinitionInfo[]>;
+    exists(ref: string): Promise<boolean>;
+    getProviderDefinitions(): Promise<DefinitionInfo[]>;
+    getDefinition(ref: string): Promise<DefinitionInfo | undefined>;
     clearCache(): void;
 }
 export declare const definitionsManager: DefinitionsManager;

package/dist/esm/src/definitionsManager.js

@@ -1,40 +1,130 @@
-import ClusterConfiguration from '@kapeta/local-cluster-config';
-import { parseKapetaUri } from '@kapeta/nodejs-utils';
-import { cacheManager, doCached } 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.definitionsManager = exports.SAMPLE_PLAN_NAME = void 0;
+const local_cluster_config_1 = __importDefault(require("@kapeta/local-cluster-config"));
+const nodejs_utils_1 = require("@kapeta/nodejs-utils");
+const cacheManager_1 = require("./cacheManager");
+const nodejs_api_client_1 = require("@kapeta/nodejs-api-client");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const utils_1 = require("./utils/utils");
+const yaml_1 = __importDefault(require("yaml"));
+const nodejs_registry_utils_1 = require("@kapeta/nodejs-registry-utils");
+const progressListener_1 = require("./progressListener");
+const path_1 = __importDefault(require("path"));
+exports.SAMPLE_PLAN_NAME = 'kapeta/sample-nodejs-plan';
+function applyHandleChange(definition, targetHandle) {
+    const originalUri = (0, nodejs_utils_1.parseKapetaUri)(definition.definition.metadata.name);
+    definition.definition.metadata.name = `${targetHandle}/${originalUri.name}`;
+    return definition;
+}
+function normalizeFilters(kindFilter) {
+    let resolvedFilters = [];
+    if (kindFilter) {
+        if (Array.isArray(kindFilter)) {
+            resolvedFilters = [...kindFilter];
+        }
+        else {
+            resolvedFilters = [kindFilter];
+        }
+    }
+    return resolvedFilters.map((k) => k.toLowerCase());
+}
 class DefinitionsManager {
-    getHash(kindFilter) {
-        if (kindFilter) {
-            if (Array.isArray(kindFilter)) {
-                return kindFilter.join(',');
+    async resolveDefinitionsAndSamples() {
+        const definitions = local_cluster_config_1.default.getDefinitions();
+        const samplePlan = definitions.find((d) => d.version === 'local' && d.definition.metadata.name === exports.SAMPLE_PLAN_NAME);
+        if (!samplePlan) {
+            return definitions;
+        }
+        // We will only rewrite the sample plan once since we change the handle to be the users handle
+        const api = new nodejs_api_client_1.KapetaAPI();
+        if (!api.hasToken()) {
+            // Not logged in yet, so we can't rewrite the sample plan
+            return definitions;
+        }
+        const profile = await api.getCurrentIdentity();
+        if (!profile) {
+            // Not logged in yet, so we can't rewrite the sample plan
+            return definitions;
+        }
+        console.log('Rewriting sample plan to use handle %s', profile.handle);
+        applyHandleChange(samplePlan, profile.handle);
+        const planDef = samplePlan.definition;
+        const blockRefs = new Set();
+        planDef.spec.blocks.forEach((b) => {
+            const blockUri = (0, nodejs_utils_1.parseKapetaUri)(b.block.ref);
+            if (blockUri.version === 'local') {
+                blockRefs.add(blockUri.id);
+                b.block.ref = (0, utils_1.normalizeKapetaUri)(`${profile.handle}/${blockUri.name}:local`);
             }
-            return kindFilter;
+        });
+        // Rewrite all blocks that are referenced by the sample plan
+        const rewrittenBlocks = Array.from(blockRefs)
+            .map((ref) => definitions.find((d) => (0, utils_1.normalizeKapetaUri)(d.definition.metadata.name + ':' + d.version) === (0, utils_1.normalizeKapetaUri)(ref)))
+            .filter((d) => d !== undefined)
+            .map((d) => applyHandleChange(d, profile.handle));
+        // Persist the rewritten assets
+        const progressListener = new progressListener_1.ProgressListener();
+        const rewrittenAssets = [samplePlan, ...rewrittenBlocks];
+        const originalRefs = [`${exports.SAMPLE_PLAN_NAME}:local`, ...Array.from(blockRefs)];
+        // Store the original paths on the assets - we'll need them later
+        for (const asset of rewrittenAssets) {
+            asset.path = await fs_extra_1.default.readlink(asset.path);
+            asset.ymlPath = path_1.default.join(asset.path, path_1.default.basename(asset.ymlPath));
+        }
+        // Uninstall the original assets
+        // This removes the symlinks
+        console.log('Uninstalling original assets', originalRefs);
+        try {
+            await nodejs_registry_utils_1.Actions.uninstall(progressListener, originalRefs);
+        }
+        catch (err) {
+            console.warn('Failed to uninstall original assets', err);
         }
-        return 'none';
+        for (const asset of rewrittenAssets) {
+            console.log('Updating %s ', asset.ymlPath);
+            await fs_extra_1.default.writeFile(asset.ymlPath, yaml_1.default.stringify(asset.definition));
+            console.log('Linking %s ', asset.path);
+            await nodejs_registry_utils_1.Actions.link(progressListener, asset.path);
+        }
+        console.log('Rewrite done for sample plan');
+        // Return the rewritten definitions
+        return local_cluster_config_1.default.getDefinitions();
     }
-    getFullKey(kindFilter) {
-        return `definitionsManager:${this.getHash(kindFilter)}`;
+    applyFilters(definitions, kindFilter) {
+        if (kindFilter.length === 0) {
+            return definitions;
+        }
+        return definitions.filter((d) => {
+            return kindFilter.includes(d.definition.kind.toLowerCase());
+        });
     }
-    getDefinitions(kindFilter) {
-        const key = this.getFullKey(kindFilter);
-        return doCached(key, () => ClusterConfiguration.getDefinitions(kindFilter));
+    async getDefinitions(kindFilter) {
+        kindFilter = normalizeFilters(kindFilter);
+        const definitions = await (0, cacheManager_1.doCached)('definitionsManager:all', () => this.resolveDefinitionsAndSamples());
+        return this.applyFilters(definitions, kindFilter);
     }
-    exists(ref) {
-        return !!this.getDefinition(ref);
+    async exists(ref) {
+        return !!(await this.getDefinition(ref));
     }
-    getProviderDefinitions() {
-        return doCached('providers', () => ClusterConfiguration.getProviderDefinitions());
+    async getProviderDefinitions() {
+        return (0, cacheManager_1.doCached)('definitionsManager:providers', () => local_cluster_config_1.default.getProviderDefinitions());
     }
-    getDefinition(ref) {
-        const uri = parseKapetaUri(ref);
-        return this.getDefinitions().find((d) => {
+    async getDefinition(ref) {
+        const uri = (0, nodejs_utils_1.parseKapetaUri)(ref);
+        const definitions = await this.getDefinitions();
+        return definitions.find((d) => {
             if (!uri.version) {
                 return d.definition.metadata.name === uri.fullName;
             }
-            return parseKapetaUri(`${d.definition.metadata.name}:${d.version}`).id === uri.id;
+            return (0, nodejs_utils_1.parseKapetaUri)(`${d.definition.metadata.name}:${d.version}`).id === uri.id;
         });
     }
     clearCache() {
-        cacheManager.removePrefix('definitionsManager:');
+        cacheManager_1.cacheManager.removePrefix('definitionsManager:');
     }
 }
-export const definitionsManager = new DefinitionsManager();
+exports.definitionsManager = new DefinitionsManager();