@kapeta/local-cluster-service 0.16.8 → 0.17.0

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 = 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 = 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.js

@@ -1,6 +1,12 @@
-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 = 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");
 class DefinitionsManager {
     getHash(kindFilter) {
         if (kindFilter) {
@@ -16,25 +22,25 @@ class DefinitionsManager {
     }
     getDefinitions(kindFilter) {
         const key = this.getFullKey(kindFilter);
-        return doCached(key, () => ClusterConfiguration.getDefinitions(kindFilter));
+        return (0, cacheManager_1.doCached)(key, () => local_cluster_config_1.default.getDefinitions(kindFilter));
     }
     exists(ref) {
         return !!this.getDefinition(ref);
     }
     getProviderDefinitions() {
-        return doCached('providers', () => ClusterConfiguration.getProviderDefinitions());
+        return (0, cacheManager_1.doCached)('providers', () => local_cluster_config_1.default.getProviderDefinitions());
     }
     getDefinition(ref) {
-        const uri = parseKapetaUri(ref);
+        const uri = (0, nodejs_utils_1.parseKapetaUri)(ref);
         return this.getDefinitions().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();

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

@@ -1,18 +1,23 @@
-import Router from 'express-promise-router';
-import { stringBody } from '../middleware/stringBody';
-import { filesystemManager } from '../filesystemManager';
-import { corsHandler } from '../middleware/cors';
-let router = Router();
-router.use('/', corsHandler);
+"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 stringBody_1 = require("../middleware/stringBody");
+const filesystemManager_1 = require("../filesystemManager");
+const cors_1 = require("../middleware/cors");
+let router = (0, express_promise_router_1.default)();
+router.use('/', cors_1.corsHandler);
 router.get('/root', (req, res) => {
-    res.send(filesystemManager.getRootFolder());
+    res.send(filesystemManager_1.filesystemManager.getRootFolder());
 });
 router.get('/project/root', (req, res) => {
-    res.send(filesystemManager.getProjectRootFolder());
+    res.send(filesystemManager_1.filesystemManager.getProjectRootFolder());
 });
-router.use('/project/root', stringBody);
+router.use('/project/root', stringBody_1.stringBody);
 router.post('/project/root', (req, res) => {
-    filesystemManager.setProjectRootFolder(req.stringBody ?? '');
+    filesystemManager_1.filesystemManager.setProjectRootFolder(req.stringBody ?? '');
     res.sendStatus(204);
 });
 router.use('/', (req, res, next) => {
@@ -25,7 +30,7 @@ router.use('/', (req, res, next) => {
 router.get('/list', async (req, res) => {
     let pathArg = req.query.path;
     try {
-        res.send(await filesystemManager.readDirectory(pathArg));
+        res.send(await filesystemManager_1.filesystemManager.readDirectory(pathArg));
     }
     catch (err) {
         res.status(400).send({ error: '' + err });
@@ -34,7 +39,7 @@ router.get('/list', async (req, res) => {
 router.get('/readfile', async (req, res) => {
     let pathArg = req.query.path;
     try {
-        res.send(await filesystemManager.readFile(pathArg));
+        res.send(await filesystemManager_1.filesystemManager.readFile(pathArg));
     }
     catch (err) {
         res.status(400).send({ error: '' + err });
@@ -43,22 +48,22 @@ router.get('/readfile', async (req, res) => {
 router.put('/mkdir', async (req, res) => {
     let pathArg = req.query.path;
     try {
-        await filesystemManager.createFolder(pathArg);
+        await filesystemManager_1.filesystemManager.createFolder(pathArg);
         res.sendStatus(204);
     }
     catch (err) {
         res.status(400).send({ error: '' + err });
     }
 });
-router.use('/writefile', stringBody);
+router.use('/writefile', stringBody_1.stringBody);
 router.post('/writefile', async (req, res) => {
     let pathArg = req.query.path;
     try {
-        await filesystemManager.writeFile(pathArg, req.stringBody ?? '');
+        await filesystemManager_1.filesystemManager.writeFile(pathArg, req.stringBody ?? '');
         res.sendStatus(204);
     }
     catch (err) {
         res.status(400).send({ error: '' + err });
     }
 });
-export default router;
+exports.default = router;

package/dist/esm/src/filesystemManager.js

@@ -1,12 +1,18 @@
-import Path from 'path';
-import FS from 'fs';
-import FSExtra from 'fs-extra';
-import { storageService } from './storageService';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filesystemManager = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const storageService_1 = require("./storageService");
 const SECTION_ID = 'filesystem';
 const PROJECT_ROOT = 'project_root';
 function isFile(path) {
     try {
-        return FS.statSync(path).isFile();
+        return fs_1.default.statSync(path).isFile();
     }
     catch (error) {
         return false;
@@ -14,15 +20,15 @@ function isFile(path) {
 }
 class FilesystemManager {
     async writeFile(path, data) {
-        const dirName = Path.dirname(path);
-        if (!FS.existsSync(dirName)) {
-            FSExtra.mkdirpSync(dirName, {});
+        const dirName = path_1.default.dirname(path);
+        if (!fs_1.default.existsSync(dirName)) {
+            fs_extra_1.default.mkdirpSync(dirName, {});
         }
-        FS.writeFileSync(path, data);
+        fs_1.default.writeFileSync(path, data);
     }
     async createFolder(path) {
         return new Promise((resolve, reject) => {
-            FS.mkdir(path, (err) => {
+            fs_1.default.mkdir(path, (err) => {
                 if (err) {
                     err.message += '. You can only create one single folder at a time.';
                     reject(err.message);
@@ -35,15 +41,15 @@ class FilesystemManager {
     async readDirectory(path) {
         return new Promise((resolve, reject) => {
             let response = [];
-            FS.readdir(path, (err, files) => {
+            fs_1.default.readdir(path, (err, files) => {
                 if (err) {
                     reject(new Error(err));
                     return;
                 }
                 files.forEach((file) => {
                     response.push({
-                        path: Path.join(path, file),
-                        folder: FS.lstatSync(Path.join(path, file)).isDirectory(),
+                        path: path_1.default.join(path, file),
+                        folder: fs_1.default.lstatSync(path_1.default.join(path, file)).isDirectory(),
                     });
                 });
                 resolve(response);
@@ -56,7 +62,7 @@ class FilesystemManager {
                 reject(new Error('The path provided is invalid.Please check that the path and file name that were provided are spelled correctly. '));
             }
             else {
-                FS.readFile(path, (err, data) => {
+                fs_1.default.readFile(path, (err, data) => {
                     if (err) {
                         reject(new Error(err.message));
                         return;
@@ -70,10 +76,10 @@ class FilesystemManager {
         return require('os').homedir();
     }
     getProjectRootFolder() {
-        return storageService.get(SECTION_ID, PROJECT_ROOT);
+        return storageService_1.storageService.get(SECTION_ID, PROJECT_ROOT);
     }
     setProjectRootFolder(folder) {
-        storageService.put(SECTION_ID, PROJECT_ROOT, folder);
+        storageService_1.storageService.put(SECTION_ID, PROJECT_ROOT, folder);
     }
 }
-export const filesystemManager = new FilesystemManager();
+exports.filesystemManager = new FilesystemManager();

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

@@ -1,11 +1,16 @@
-import Router from 'express-promise-router';
-import { KapetaAPI } from '@kapeta/nodejs-api-client';
-import { corsHandler } from '../middleware/cors';
-const router = Router();
-router.use('/', corsHandler);
+"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 router = (0, express_promise_router_1.default)();
+router.use('/', cors_1.corsHandler);
 router.get('/current', async (req, res) => {
     try {
-        const api = new KapetaAPI();
+        const api = new nodejs_api_client_1.KapetaAPI();
         if (api.hasToken()) {
             res.send(await api.getCurrentIdentity());
         }
@@ -19,7 +24,7 @@ router.get('/current', async (req, res) => {
 });
 router.get('/:identityId/memberships', async (req, res) => {
     try {
-        const api = new KapetaAPI();
+        const api = new nodejs_api_client_1.KapetaAPI();
         if (api.hasToken()) {
             res.send(await api.getMemberships(req.params.identityId));
         }
@@ -31,4 +36,4 @@ router.get('/:identityId/memberships', async (req, res) => {
         res.status(e.status ?? 500).send(e);
     }
 });
-export default router;
+exports.default = router;