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

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

@@ -0,0 +1,165 @@
+"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 yaml_1 = __importDefault(require("yaml"));
+const assetManager_1 = require("../assetManager");
+const cors_1 = require("../middleware/cors");
+const stringBody_1 = require("../middleware/stringBody");
+const definitionsManager_1 = require("../definitionsManager");
+function parseBody(req) {
+    switch (req.headers['content-type']) {
+        case 'application/json':
+        case 'application/x-json':
+        case 'text/json':
+            return JSON.parse(req.stringBody ?? '{}');
+        case 'application/yaml':
+        case 'application/x-yaml':
+        case 'text/yaml':
+        case 'text/x-yaml':
+        default:
+            return yaml_1.default.parse(req.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('/', async (req, res) => {
+    res.send(await assetManager_1.assetManager.getAssets([]));
+});
+/**
+ * Get single asset
+ */
+router.get('/read', async (req, res) => {
+    if (!req.query.ref) {
+        res.status(400).send({ error: 'Query parameter "ref" is missing' });
+        return;
+    }
+    const ensure = req.query.ensure !== 'false';
+    try {
+        const asset = await assetManager_1.assetManager.getAsset(req.query.ref, true, ensure);
+        if (asset) {
+            res.send(asset);
+        }
+        else {
+            res.status(404).send({ error: 'Asset not found' });
+        }
+    }
+    catch (err) {
+        res.status(400).send({ error: err.message });
+    }
+});
+/**
+ * Get all versions for asset name
+ */
+router.get('/versions', async (req, res) => {
+    if (!req.query.ref) {
+        res.status(400).send({ error: 'Query parameter "ref" is missing' });
+        return;
+    }
+    const ensure = req.query.ensure !== 'false';
+    try {
+        const versions = await definitionsManager_1.definitionsManager.getVersions(req.query.ref);
+        if (versions) {
+            res.send(versions);
+        }
+        else {
+            res.status(404).send({ error: 'Asset not found' });
+        }
+    }
+    catch (err) {
+        res.status(400).send({ error: err.message });
+    }
+});
+/**
+ * Creates a new local file and registers it as an asset
+ */
+router.post('/create', async (req, res) => {
+    if (!req.query.path) {
+        res.status(400).send({ error: 'Query parameter "path" is missing' });
+        return;
+    }
+    const content = parseBody(req);
+    try {
+        const assets = await assetManager_1.assetManager.createAsset(req.query.path, content, 'user');
+        res.status(200).send(assets);
+    }
+    catch (err) {
+        console.log('Failed while creating asset', req.query.path, err.message);
+        res.status(400).send({ error: err.message });
+    }
+});
+/**
+ * Updates reference with new content
+ */
+router.put('/update', async (req, res) => {
+    if (!req.query.ref) {
+        res.status(400).send({ error: 'Query parameter "ref" is missing' });
+        return;
+    }
+    const content = parseBody(req);
+    try {
+        await assetManager_1.assetManager.updateAsset(req.query.ref, content, 'user');
+        res.sendStatus(204);
+    }
+    catch (err) {
+        console.log('Failed while updating asset', req.query.ref, err.message);
+        res.status(400).send({ error: err.message });
+    }
+});
+/**
+ * Unregisters an asset (doesn't delete the asset)
+ */
+router.delete('/', async (req, res) => {
+    if (!req.query.ref) {
+        res.status(400).send({ error: 'Query parameter "ref" is missing' });
+        return;
+    }
+    try {
+        await assetManager_1.assetManager.unregisterAsset(req.query.ref);
+        res.status(204).send();
+    }
+    catch (err) {
+        res.status(400).send({ error: err.message });
+    }
+});
+/**
+ * Registers an existing file as an asset
+ */
+router.put('/import', async (req, res) => {
+    if (!req.query.ref) {
+        res.status(400).send({ error: 'Query parameter "ref" is missing' });
+        return;
+    }
+    try {
+        const assets = await assetManager_1.assetManager.importFile(req.query.ref);
+        res.status(200).send(assets);
+    }
+    catch (err) {
+        res.status(400).send({ error: err.message });
+    }
+});
+router.put('/install', async (req, res) => {
+    if (!req.query.ref) {
+        res.status(400).send({ error: 'Query parameter "ref" is missing' });
+        return;
+    }
+    try {
+        const tasks = await assetManager_1.assetManager.installAsset(req.query.ref, !!req.query.wait);
+        const taskIds = tasks?.map((t) => t.id) ?? [];
+        res.status(200).send(taskIds);
+    }
+    catch (err) {
+        res.status(400).send({ error: err.message });
+    }
+});
+exports.default = router;

package/dist/esm/src/attachments/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;

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

@@ -0,0 +1,72 @@
+"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 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_1.storageService.get('endpoints', 'registry', DEFAULT_REGISTRY_BASE);
+    return `${endpoint}/v1/registry`;
+}
+router.use('/', cors_1.corsHandler);
+router.put('/:handle/:name', async (req, res) => {
+    if (!api.hasToken()) {
+        res.status(401).send({
+            status: 401,
+            error: 'Unauthorized',
+        });
+        return;
+    }
+    const endpoint = getBaseUrl();
+    if (!req.headers['content-type']) {
+        res.status(400).send({
+            status: 400,
+            error: 'Missing content-type header',
+        });
+        return;
+    }
+    if (!req.headers['content-length']) {
+        res.status(400).send({
+            status: 400,
+            error: 'Missing content-length header',
+        });
+        return;
+    }
+    if (!req.headers['content-disposition']) {
+        res.status(400).send({
+            status: 400,
+            error: 'Missing content-disposition header',
+        });
+        return;
+    }
+    try {
+        const { handle, name } = req.params;
+        const url = `${endpoint}/${handle}/${name}/attachments`;
+        const result = await api.send({
+            method: 'PUT',
+            url,
+            auth: true,
+            headers: {
+                'content-type': req.headers['content-type'],
+                'content-length': req.headers['content-length'],
+                'content-disposition': req.headers['content-disposition'],
+            },
+            body: req,
+        });
+        res.send(result);
+    }
+    catch (e) {
+        res.status(e.status ?? 500).send(e);
+    }
+});
+exports.default = router;

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

@@ -0,0 +1,16 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+/// <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,64 @@
+"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.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.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+export interface CacheEntry<T = any> {
+    expires: number;
+    data: T;
+}
+export declare class CacheManager {
+    private cache;
+    flush(): void;
+    doCached<T>(key: string, getter: () => T, ttl?: number): T;
+    get<T>(key: string): T | undefined;
+    set<T>(key: string, data: T, ttl?: number): void;
+    has(key: string): boolean;
+    remove(key: string): number;
+    removePrefix(key: string): void;
+}
+export declare const cacheManager: CacheManager;
+export declare const doCached: <T>(key: string, getter: () => T, ttl?: number) => T;

package/dist/esm/src/cacheManager.js

@@ -0,0 +1,51 @@
+"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.doCached = exports.cacheManager = exports.CacheManager = void 0;
+const node_cache_1 = __importDefault(require("node-cache"));
+const DEFAULT_CACHE_TTL = 60 * 1000; // 1 min
+class CacheManager {
+    cache = new node_cache_1.default();
+    flush() {
+        this.cache.flushAll();
+    }
+    doCached(key, getter, ttl = DEFAULT_CACHE_TTL) {
+        const data = this.cache.get(key);
+        if (data !== undefined) {
+            return data;
+        }
+        const result = getter();
+        this.cache.set(key, result, ttl);
+        return result;
+    }
+    get(key) {
+        return this.cache.get(key);
+    }
+    set(key, data, ttl = DEFAULT_CACHE_TTL) {
+        this.cache.set(key, data, ttl);
+    }
+    has(key) {
+        return this.cache.has(key);
+    }
+    remove(key) {
+        return this.cache.del(key);
+    }
+    removePrefix(key) {
+        const keys = this.cache.keys();
+        for (const k of keys) {
+            if (k.startsWith(key)) {
+                this.remove(k);
+            }
+        }
+    }
+}
+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.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+declare class ClusterService {
+    private _port;
+    private _currentPort;
+    private _initialized;
+    private _reservedPorts;
+    private _host;
+    constructor();
+    reservePort(port: number | string): void;
+    init(): Promise<void>;
+    _findClusterServicePort(): Promise<void>;
+    /**
+     * Gets next available port
+     * @return {Promise<number>}
+     */
+    getNextAvailablePort(): Promise<number>;
+    _checkIfPortIsUsed(port: number, host?: string): Promise<unknown>;
+    /**
+     * The port of this local cluster service itself
+     */
+    getClusterServicePort(): number;
+    getClusterServiceHost(): string;
+    /**
+     * Set the port to be used for this local service
+     * @param port
+     */
+    setClusterServicePort(port: number): void;
+    setClusterServiceHost(host: string): void;
+    /**
+     * Gets that proxy path of a given request
+     *
+     * @param systemId
+     * @param consumerInstanceId
+     * @param consumerResourceName
+     * @param portType
+     * @return {string}
+     */
+    getProxyPath(systemId: string, consumerInstanceId: string, consumerResourceName: string, portType: string): string;
+}
+export declare const clusterService: ClusterService;
+export {};

package/dist/esm/src/clusterService.js

@@ -0,0 +1,120 @@
+"use strict";
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clusterService = void 0;
+const nodejs_utils_1 = require("@kapeta/nodejs-utils");
+const net = require('net');
+const DEFAULT_SERVER_PORT = 35100;
+const DEFAULT_START_PORT = 40000;
+const DEFAULT_HOST = '127.0.0.1';
+class ClusterService {
+    _port;
+    _currentPort;
+    _initialized;
+    _reservedPorts;
+    _host;
+    constructor() {
+        this._port = DEFAULT_SERVER_PORT;
+        this._currentPort = DEFAULT_START_PORT;
+        this._initialized = false;
+        this._reservedPorts = [];
+        this._host = DEFAULT_HOST;
+    }
+    reservePort(port) {
+        const intPort = parseInt(port);
+        if (this._reservedPorts.indexOf(intPort) > -1) {
+            throw new Error('Port already reserved: ' + intPort);
+        }
+        this._reservedPorts.push(intPort);
+    }
+    async init() {
+        if (this._initialized) {
+            return;
+        }
+        this._initialized = true;
+        await this._findClusterServicePort();
+    }
+    async _findClusterServicePort() {
+        while (true) {
+            const isUsed = await this._checkIfPortIsUsed(this._port);
+            if (!isUsed) {
+                break;
+            }
+            this._port++;
+        }
+    }
+    /**
+     * Gets next available port
+     * @return {Promise<number>}
+     */
+    async getNextAvailablePort() {
+        while (true) {
+            while (this._reservedPorts.indexOf(this._currentPort) > -1) {
+                this._currentPort++;
+            }
+            const nextPort = this._currentPort++;
+            const isUsed = await this._checkIfPortIsUsed(nextPort);
+            if (!isUsed) {
+                return nextPort;
+            }
+        }
+    }
+    _checkIfPortIsUsed(port, host = this._host) {
+        return new Promise((resolve, reject) => {
+            const server = net.createServer();
+            server.once('error', function (err) {
+                if (err.code === 'EADDRINUSE') {
+                    server.close();
+                    resolve(true);
+                    return;
+                }
+                server.close();
+                reject(err);
+            });
+            server.once('listening', function () {
+                server.close();
+                resolve(false);
+            });
+            server.listen(port, host);
+        });
+    }
+    /**
+     * The port of this local cluster service itself
+     */
+    getClusterServicePort() {
+        return this._port;
+    }
+    /*
+     *Gets the host name ( 127.0.0.1 ) on which Express JS is listening
+     */
+    getClusterServiceHost() {
+        return this._host;
+    }
+    /**
+     * Set the port to be used for this local service
+     * @param port
+     */
+    setClusterServicePort(port) {
+        this._port = port;
+    }
+    setClusterServiceHost(host) {
+        this._host = host;
+    }
+    /**
+     * Gets that proxy path of a given request
+     *
+     * @param systemId
+     * @param consumerInstanceId
+     * @param consumerResourceName
+     * @param portType
+     * @return {string}
+     */
+    getProxyPath(systemId, consumerInstanceId, consumerResourceName, portType) {
+        systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
+        return `/proxy/${encodeURIComponent(systemId)}/${encodeURIComponent(consumerInstanceId)}/${encodeURIComponent(consumerResourceName)}/${encodeURIComponent(portType)}/`;
+    }
+}
+exports.clusterService = new ClusterService();

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

@@ -0,0 +1,14 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+import { Definition } from '@kapeta/local-cluster-config';
+declare class CodeGeneratorManager {
+    private ensureLanguageTargetInRegistry;
+    reload(): Promise<void>;
+    initialize(): Promise<void>;
+    canGenerateCode(yamlContent: Definition): Promise<boolean>;
+    generate(yamlFile: string, yamlContent: Definition): Promise<void>;
+}
+export declare const codeGeneratorManager: CodeGeneratorManager;
+export {};

package/dist/esm/src/codeGeneratorManager.js

@@ -0,0 +1,93 @@
+"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.codeGeneratorManager = void 0;
+const path_1 = __importDefault(require("path"));
+const codegen_1 = require("@kapeta/codegen");
+const definitionsManager_1 = require("./definitionsManager");
+const assetManager_1 = require("./assetManager");
+const nodejs_utils_1 = require("@kapeta/nodejs-utils");
+const repositoryManager_1 = require("./repositoryManager");
+const TARGET_KIND = 'core/language-target';
+const BLOCK_TYPE_KIND = 'core/block-type';
+class CodeGeneratorManager {
+    async ensureLanguageTargetInRegistry(path, version, definition) {
+        const key = `${definition.metadata.name}:${version}`;
+        try {
+            if (await codegen_1.registry.get(key)) {
+                return;
+            }
+        }
+        catch (e) { }
+        try {
+            const target = require(path);
+            if (target.default) {
+                codegen_1.registry.register(key, target.default);
+            }
+            else {
+                codegen_1.registry.register(key, target);
+            }
+        }
+        catch (e) {
+            console.error('Failed to load target: %s', key, e);
+        }
+    }
+    async reload() {
+        codegen_1.registry.reset();
+        const languageTargets = await definitionsManager_1.definitionsManager.getDefinitions(TARGET_KIND);
+        for (const languageTarget of languageTargets) {
+            await this.ensureLanguageTargetInRegistry(languageTarget.path, languageTarget.version, languageTarget.definition);
+        }
+    }
+    async initialize() {
+        await this.reload();
+        repositoryManager_1.repositoryManager.on('change', async () => {
+            // Reload code generators when the repository changes
+            try {
+                await this.reload();
+            }
+            catch (e) {
+                console.error('Failed to reload code generators', e);
+            }
+        });
+    }
+    async canGenerateCode(yamlContent) {
+        if (!yamlContent.spec?.target?.kind || !yamlContent.kind) {
+            //Not all block types have targets
+            return false;
+        }
+        const kindUri = (0, nodejs_utils_1.parseKapetaUri)(yamlContent.kind);
+        const blockTypes = await definitionsManager_1.definitionsManager.getDefinitions(BLOCK_TYPE_KIND);
+        const blockTypeKinds = blockTypes.map((blockType) => (0, nodejs_utils_1.parseKapetaUri)(blockType.definition.metadata.name).fullName);
+        return blockTypeKinds.includes(kindUri.fullName);
+    }
+    async generate(yamlFile, yamlContent) {
+        if (!yamlContent.spec.target?.kind) {
+            //Not all block types have targets
+            return;
+        }
+        const targetRef = (0, nodejs_utils_1.normalizeKapetaUri)(yamlContent.spec.target?.kind);
+        // Automatically downloads target if not available
+        const targetAsset = await assetManager_1.assetManager.getAsset(targetRef);
+        if (!targetAsset) {
+            console.error('Language target not found: %s', yamlContent.spec.target?.kind);
+            return;
+        }
+        await this.ensureLanguageTargetInRegistry(targetAsset?.path, targetAsset?.version, targetAsset?.data);
+        const baseDir = path_1.default.dirname(yamlFile);
+        console.log('Generating code for path: %s', baseDir);
+        const codeGenerator = new codegen_1.BlockCodeGenerator(yamlContent);
+        const output = await codeGenerator.generate();
+        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);
+    }
+}
+exports.codeGeneratorManager = new CodeGeneratorManager();

package/dist/esm/src/config/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;