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

package/dist/esm/src/operatorManager.js

@@ -0,0 +1,211 @@
+"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.operatorManager = void 0;
+const path_1 = __importDefault(require("path"));
+const md5_1 = __importDefault(require("md5"));
+const serviceManager_1 = require("./serviceManager");
+const storageService_1 = require("./storageService");
+const containerManager_1 = require("./containerManager");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const types_1 = require("./types");
+const definitionsManager_1 = require("./definitionsManager");
+const utils_1 = require("./utils/utils");
+const nodejs_utils_1 = require("@kapeta/nodejs-utils");
+const lodash_1 = __importDefault(require("lodash"));
+const async_lock_1 = __importDefault(require("async-lock"));
+const taskManager_1 = require("./taskManager");
+const KIND_PLAN = 'core/plan';
+class Operator {
+    _data;
+    constructor(data) {
+        this._data = data;
+    }
+    getLocalData() {
+        return this._data.definition.spec.local;
+    }
+    getDefinitionInfo() {
+        return this._data;
+    }
+    getCredentials() {
+        return this._data.definition.spec.local.credentials;
+    }
+}
+class OperatorManager {
+    _mountDir;
+    operatorLock = new async_lock_1.default();
+    constructor() {
+        this._mountDir = path_1.default.join(storageService_1.storageService.getKapetaBasedir(), 'mounts');
+        fs_extra_1.default.mkdirpSync(this._mountDir);
+    }
+    _getMountPoint(operatorType, mountName) {
+        return path_1.default.join(this._mountDir, operatorType, mountName);
+    }
+    /**
+     * Get operator definition for resource type
+     */
+    async getOperator(fullName, version) {
+        const operators = await definitionsManager_1.definitionsManager.getDefinitions([types_1.KIND_RESOURCE_OPERATOR, types_1.KIND_BLOCK_TYPE_OPERATOR]);
+        const operator = operators.find((operator) => operator.definition &&
+            operator.definition.metadata &&
+            operator.definition.metadata.name &&
+            operator.definition.metadata.name.toLowerCase() === fullName.toLowerCase() &&
+            operator.version === version);
+        if (!operator) {
+            throw new Error(`Unknown operator type: ${fullName}:${version}`);
+        }
+        if (!operator.definition.spec || !operator.definition.spec.local) {
+            throw new Error(`Operator missing local definition: ${fullName}:${version}`);
+        }
+        return new Operator(operator);
+    }
+    /**
+     * Get information about a specific consumed resource
+     */
+    async getConsumerResourceInfo(systemId, fromServiceId, resourceType, portType, name, environment, ensureContainer = true) {
+        systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
+        const plans = await definitionsManager_1.definitionsManager.getDefinitions(KIND_PLAN);
+        const planUri = (0, nodejs_utils_1.parseKapetaUri)(systemId);
+        const currentPlan = plans.find((plan) => plan.definition.metadata.name === planUri.fullName && plan.version === planUri.version);
+        if (!currentPlan) {
+            throw new Error(`Unknown plan: ${systemId}`);
+        }
+        const currentInstance = currentPlan.definition.spec.blocks?.find((instance) => instance.id === fromServiceId);
+        if (!currentInstance) {
+            throw new Error(`Unknown instance: ${fromServiceId} in plan ${systemId}`);
+        }
+        const blockDefinition = await definitionsManager_1.definitionsManager.getDefinition(currentInstance.block.ref);
+        if (!blockDefinition) {
+            throw new Error(`Unknown block: ${currentInstance.block.ref} in plan ${systemId}`);
+        }
+        const blockResource = blockDefinition.definition.spec?.consumers?.find((resource) => {
+            if (resource.metadata.name !== name) {
+                return false;
+            }
+            return (0, nodejs_utils_1.parseKapetaUri)(resource.kind).fullName === resourceType;
+        });
+        if (!blockResource) {
+            throw new Error(`Unknown resource: ${name} in block ${currentInstance.block.ref} in plan ${systemId}`);
+        }
+        const kindUri = (0, nodejs_utils_1.parseKapetaUri)(blockResource.kind);
+        const operator = await this.getOperator(resourceType, kindUri.version);
+        const credentials = operator.getCredentials();
+        if (ensureContainer) {
+            await this.ensureOperator(systemId, resourceType, kindUri.version);
+        }
+        const hostPort = await serviceManager_1.serviceManager.ensureServicePort(systemId, resourceType, portType);
+        if (!hostPort) {
+            throw new Error('Unknown resource port type : ' + resourceType + '#' + portType);
+        }
+        const dbName = name + '_' + fromServiceId.replace(/[^a-z0-9]/gi, '');
+        const safeName = dbName.replace('_', '-');
+        return {
+            host: (0, utils_1.getRemoteHostForEnvironment)(environment),
+            port: hostPort,
+            type: portType,
+            protocol: 'tcp',
+            options: {
+                // expose as fullName since that is not operator specific, but unique
+                fullName: safeName,
+                dbName,
+            },
+            credentials,
+        };
+    }
+    async getOperatorPorts(systemId, kind, version) {
+        const operator = await this.getOperator(kind, version);
+        const operatorData = operator.getLocalData();
+        const portTypes = Object.keys(operatorData.ports);
+        portTypes.sort();
+        const ports = {};
+        for (let i = 0; i < portTypes.length; i++) {
+            const portType = portTypes[i];
+            let containerPortInfo = operatorData.ports[portType];
+            const hostPort = await serviceManager_1.serviceManager.ensureServicePort(systemId, kind, portType);
+            const portInfo = (0, utils_1.toPortInfo)(containerPortInfo);
+            const portId = portInfo.port + '/' + portInfo.type;
+            ports[portId] = {
+                type: portType,
+                hostPort,
+                protocol: portInfo.type,
+            };
+        }
+        return ports;
+    }
+    /**
+     * Ensure we have a running operator of given type
+     *
+     * @param systemId the plan ref
+     * @param kind the full name - e.g. myhandle/rabbitmq
+     * @param version the version of the operator
+     */
+    async ensureOperator(systemId, kind, version) {
+        systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
+        const key = `${systemId}#${kind}:${version}`;
+        return await this.operatorLock.acquire(key, async () => {
+            const operator = await this.getOperator(kind, version);
+            const operatorData = operator.getLocalData();
+            const ports = await this.getOperatorPorts(systemId, kind, version);
+            const nameParts = [systemId, kind.toLowerCase(), version];
+            const containerName = `kapeta-resource-${(0, md5_1.default)(nameParts.join('_'))}`;
+            const PortBindings = {};
+            const Env = [];
+            const systemUri = (0, nodejs_utils_1.parseKapetaUri)(systemId);
+            const Labels = {
+                kapeta: 'true',
+                [containerManager_1.COMPOSE_LABEL_PROJECT]: systemUri.id.replace(/[^a-z0-9]/gi, '_'),
+                [containerManager_1.COMPOSE_LABEL_SERVICE]: [kind, version].join('_').replace(/[^a-z0-9]/gi, '_'),
+            };
+            const operatorMetadata = operator.getDefinitionInfo().definition.metadata;
+            const hostIp = (0, utils_1.getDockerHostIp)();
+            const ExposedPorts = {};
+            lodash_1.default.forEach(ports, (portInfo, containerPort) => {
+                ExposedPorts['' + containerPort] = {};
+                PortBindings['' + containerPort] = [
+                    {
+                        HostPort: '' + portInfo.hostPort,
+                        HostIp: hostIp,
+                    },
+                ];
+                Labels[containerManager_1.CONTAINER_LABEL_PORT_PREFIX + portInfo.hostPort] = portInfo.type;
+            });
+            const Mounts = await containerManager_1.containerManager.createVolumes(systemId, kind, operatorData.mounts);
+            lodash_1.default.forEach(operatorData.env, (value, name) => {
+                Env.push(name + '=' + value);
+            });
+            const task = taskManager_1.taskManager.add(`operator:ensure:${key}`, async () => {
+                let HealthCheck = undefined;
+                if (operatorData.health) {
+                    HealthCheck = containerManager_1.containerManager.toDockerHealth(operatorData.health);
+                }
+                const container = await containerManager_1.containerManager.ensureContainer({
+                    name: containerName,
+                    Image: operatorData.image,
+                    Hostname: containerName + '.kapeta',
+                    Labels,
+                    Cmd: operatorData.cmd,
+                    ExposedPorts,
+                    Env,
+                    HealthCheck,
+                    HostConfig: {
+                        PortBindings,
+                        Mounts,
+                    },
+                });
+                await containerManager_1.containerManager.waitForReady(container);
+                return new containerManager_1.ContainerInfo(container);
+            }, {
+                name: `Ensuring ${operatorMetadata.title ?? operatorMetadata.name}`,
+                systemId,
+            });
+            return task.wait();
+        });
+    }
+}
+exports.operatorManager = new OperatorManager();

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

@@ -0,0 +1,31 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+/// <reference types="node" />
+import { LogEntry } from './types';
+import { Task } from './taskManager';
+export declare class ProgressListener {
+    private readonly systemId;
+    private readonly instanceId;
+    constructor(systemId?: string, instanceId?: string);
+    protected emitLog(payload: Omit<LogEntry, 'time' | 'source'>): void;
+    run(command: string, directory?: string): Promise<{
+        exit: number;
+        signal: NodeJS.Signals | null;
+        output: string;
+    }>;
+    progress(label: string, callback: () => void | Promise<void>): Promise<void>;
+    check(message: string, ok: boolean | Promise<boolean> | (() => Promise<boolean>)): Promise<void>;
+    start(label: string): void;
+    showValue(label: string, value: any): void;
+    error(msg: string, ...args: any[]): void;
+    warn(msg: string, ...args: any[]): void;
+    info(msg: string, ...args: any[]): void;
+    debug(msg: string, ...args: any[]): void;
+}
+export declare class TaskProgressListener extends ProgressListener {
+    private readonly task;
+    constructor(task: Task);
+    protected emitLog(payload: Omit<LogEntry, 'time' | 'source'>): void;
+}

package/dist/esm/src/progressListener.js

@@ -0,0 +1,133 @@
+"use strict";
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskProgressListener = exports.ProgressListener = void 0;
+const nodejs_process_1 = require("@kapeta/nodejs-process");
+const socketManager_1 = require("./socketManager");
+const node_util_1 = require("node:util");
+class ProgressListener {
+    systemId;
+    instanceId;
+    constructor(systemId, instanceId) {
+        this.systemId = systemId;
+        this.instanceId = instanceId;
+    }
+    emitLog(payload) {
+        const logEntry = {
+            ...payload,
+            source: 'stdout',
+            time: Date.now(),
+        };
+        if (this.systemId && this.instanceId) {
+            socketManager_1.socketManager.emitInstanceLog(this.systemId, this.instanceId, logEntry);
+            return;
+        }
+        if (this.systemId) {
+            socketManager_1.socketManager.emitSystemLog(this.systemId, logEntry);
+            return;
+        }
+        socketManager_1.socketManager.emitGlobalLog(logEntry);
+    }
+    run(command, directory) {
+        this.info(`Running command "${command}"`);
+        return new Promise(async (resolve, reject) => {
+            try {
+                const chunks = [];
+                const child = (0, nodejs_process_1.spawn)(command, [], {
+                    cwd: directory ? directory : process.cwd(),
+                    shell: true,
+                });
+                child.onData((data) => {
+                    this.emitLog({
+                        level: data.type === 'stdout' ? 'INFO' : 'WARN',
+                        message: data.line,
+                    });
+                });
+                if (child.process.stdout) {
+                    child.process.stdout.on('data', (data) => {
+                        chunks.push(data);
+                    });
+                }
+                child.process.on('exit', (exit, signal) => {
+                    if (exit !== 0) {
+                        this.warn(`Command "${command}" failed: ${exit}`);
+                        reject(new Error(`Command "${command}" exited with code ${exit}`));
+                    }
+                    else {
+                        this.info(`Command OK: "${command}"`);
+                        resolve({ exit, signal, output: Buffer.concat(chunks).toString() });
+                    }
+                });
+                child.process.on('error', (err) => {
+                    this.warn(`"${command}" failed: "${err.message}"`);
+                    reject(err);
+                });
+                await child.wait();
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
+    }
+    async progress(label, callback) {
+        this.info(`${label}: started`);
+        try {
+            const result = await callback();
+            this.info(`${label}: done`);
+            return result;
+        }
+        catch (e) {
+            this.warn(`${label}: failed. ${e.message}`);
+            throw e;
+        }
+    }
+    async check(message, ok) {
+        const wasOk = await ok;
+        this.info(`${message}: ${wasOk}`);
+    }
+    start(label) {
+        this.info(label);
+    }
+    showValue(label, value) {
+        this.info(`${label}: ${value}`);
+    }
+    error(msg, ...args) {
+        this.emitLog({
+            message: (0, node_util_1.format)(msg, args),
+            level: 'ERROR',
+        });
+    }
+    warn(msg, ...args) {
+        this.emitLog({
+            message: (0, node_util_1.format)(msg, args),
+            level: 'WARN',
+        });
+    }
+    info(msg, ...args) {
+        this.emitLog({
+            message: (0, node_util_1.format)(msg, args),
+            level: 'INFO',
+        });
+    }
+    debug(msg, ...args) {
+        this.emitLog({
+            message: (0, node_util_1.format)(msg, args),
+            level: 'DEBUG',
+        });
+    }
+}
+exports.ProgressListener = ProgressListener;
+class TaskProgressListener extends ProgressListener {
+    task;
+    constructor(task) {
+        super();
+        this.task = task;
+    }
+    emitLog(payload) {
+        this.task.addLog(payload.message, payload.level);
+    }
+}
+exports.TaskProgressListener = TaskProgressListener;

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

@@ -0,0 +1,11 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+import { DefinitionInfo } from '@kapeta/local-cluster-config';
+declare class ProviderManager {
+    getWebProviders(): Promise<DefinitionInfo[]>;
+    getProviderWebJS(handle: string, name: string, version: string, sourceMap?: boolean): Promise<unknown>;
+}
+export declare const providerManager: ProviderManager;
+export {};

package/dist/esm/src/providerManager.js

@@ -0,0 +1,84 @@
+"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.providerManager = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const definitionsManager_1 = require("./definitionsManager");
+const cacheManager_1 = require("./cacheManager");
+const request_1 = __importDefault(require("request"));
+const PROVIDER_FILE_BASE = 'https://providers.kapeta.com/files';
+class ProviderManager {
+    async getWebProviders() {
+        const providers = await definitionsManager_1.definitionsManager.getProviderDefinitions();
+        return providers.filter((providerDefinition) => providerDefinition.hasWeb);
+    }
+    async getProviderWebJS(handle, name, version, sourceMap = false) {
+        const fullName = `${handle}/${name}`;
+        const id = `${handle}/${name}/${version}/web.js${sourceMap ? '.map' : ''}`;
+        const cacheKey = `provider:web:${id}`;
+        const file = cacheManager_1.cacheManager.get(cacheKey);
+        if (file && (await fs_extra_1.default.pathExists(file))) {
+            return fs_extra_1.default.readFile(file, 'utf8');
+        }
+        const providers = await this.getWebProviders();
+        const installedProvider = providers.find((providerDefinition) => {
+            return providerDefinition.definition.metadata.name === fullName && providerDefinition.version === version;
+        });
+        if (installedProvider) {
+            //Check locally installed providers
+            const path = path_1.default.join(installedProvider.path, 'web', handle, `${name}.js${sourceMap ? '.map' : ''}`);
+            if (await fs_extra_1.default.pathExists(path)) {
+                cacheManager_1.cacheManager.set(cacheKey, path, 24 * 60 * 60 * 1000);
+                return fs_extra_1.default.readFile(path);
+            }
+        }
+        if (version === 'local') {
+            return null;
+        }
+        const url = `${PROVIDER_FILE_BASE}/${id}`;
+        return new Promise((resolve, reject) => {
+            console.log('Loading provider from %s', url);
+            request_1.default.get(url, (error, response, body) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                if (response.statusCode === 404) {
+                    resolve(null);
+                    return;
+                }
+                if (response.statusCode !== 200) {
+                    reject(new Error(`Failed to load provider from ${url}: ${body}`));
+                    return;
+                }
+                resolve(body);
+            });
+        });
+    }
+}
+definitionsManager_1.definitionsManager
+    .getProviderDefinitions()
+    .then((providerDefinitions) => {
+    if (providerDefinitions.length > 0) {
+        console.log('## Loaded the following providers ##');
+        providerDefinitions.forEach((providerDefinition) => {
+            console.log(' - %s[%s:%s]', providerDefinition.definition.kind, providerDefinition.definition.metadata.name, providerDefinition.version);
+            console.log('   from %s', providerDefinition.path);
+        });
+        console.log('##');
+    }
+    else {
+        console.log('## No providers found ##');
+    }
+})
+    .catch((e) => {
+    console.error('Failed to load providers', e);
+});
+exports.providerManager = new ProviderManager();

package/dist/esm/src/providers/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/providers/routes.js

@@ -0,0 +1,46 @@
+"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 providerManager_1 = require("../providerManager");
+const cors_1 = require("../middleware/cors");
+const router = (0, express_promise_router_1.default)();
+router.use('/', cors_1.corsHandler);
+router.get('/', async (req, res) => {
+    const result = await providerManager_1.providerManager.getWebProviders();
+    res.send(result);
+});
+router.get('/asset/:handle/:name/:version/web.js', async (req, res) => {
+    const { handle, name, version } = req.params;
+    let result = await providerManager_1.providerManager.getProviderWebJS(handle, name, version);
+    if (!result) {
+        res.status(404).send('');
+    }
+    else {
+        if (version !== 'local') {
+            res.setHeader('Cache-Control', 'max-age=31536000, immutable');
+        }
+        res.send(result.toString().replace(`${name}.js.map`, 'web.js.map'));
+    }
+});
+router.get('/asset/:handle/:name/:version/web.js.map', async (req, res) => {
+    const { handle, name, version } = req.params;
+    const result = await providerManager_1.providerManager.getProviderWebJS(handle, name, version, true);
+    if (!result) {
+        res.status(404).send('');
+    }
+    else {
+        // Only cache successful requests
+        if (version !== 'local') {
+            res.setHeader('Cache-Control', 'max-age=31536000, immutable');
+        }
+        res.send(result);
+    }
+});
+exports.default = router;

package/dist/esm/src/proxy/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/proxy/routes.js

@@ -0,0 +1,115 @@
+"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 rest_1 = require("./types/rest");
+const web_1 = require("./types/web");
+const stringBody_1 = require("../middleware/stringBody");
+const serviceManager_1 = require("../serviceManager");
+const clusterService_1 = require("../clusterService");
+const assetManager_1 = require("../assetManager");
+const lodash_1 = __importDefault(require("lodash"));
+const router = (0, express_promise_router_1.default)();
+/**
+ * @var {{[key:string]:ProxyRequestHandler}}
+ */
+const TYPE_HANDLERS = {
+    rest: rest_1.proxyRestRequest,
+    http: web_1.proxyHttpRequest,
+};
+function getResource(resources, resourceName) {
+    return resources.find((resource) => {
+        return resource.metadata.name.toLowerCase() === resourceName.toLowerCase();
+    });
+}
+router.use('/:systemId/:consumerInstanceId/:consumerResourceName', stringBody_1.stringBody);
+router.all('/:systemId/:consumerInstanceId/:consumerResourceName/:type/*', async (req, res) => {
+    try {
+        let typeHandler = TYPE_HANDLERS[req.params.type.toLowerCase()];
+        if (!typeHandler) {
+            // Default to http
+            typeHandler = TYPE_HANDLERS['http'];
+        }
+        const plan = await assetManager_1.assetManager.getPlan(req.params.systemId);
+        // We can find the connection by the consumer information alone since
+        // only 1 provider can be connected to a consumer resource at a time
+        const connection = plan.spec.connections.find((connection) => {
+            return (connection.consumer.blockId.toLowerCase() === req.params.consumerInstanceId.toLowerCase() &&
+                connection.consumer.resourceName.toLowerCase() === req.params.consumerResourceName.toLowerCase());
+        });
+        if (!connection) {
+            res.status(401).send({
+                error: `No connection found for consumer "${req.params.consumerInstanceId}::${req.params.consumerResourceName}"`,
+            });
+            return;
+        }
+        const toBlockInstance = lodash_1.default.find(plan.spec.blocks, (blockInstance) => {
+            return blockInstance.id.toLowerCase() === connection.consumer.blockId.toLowerCase();
+        });
+        if (!toBlockInstance) {
+            res.status(401).send({ error: `Block instance not found "${req.params.consumerInstanceId}` });
+            return;
+        }
+        const toBlockAsset = await assetManager_1.assetManager.getAsset(toBlockInstance.block.ref);
+        if (!toBlockAsset) {
+            res.status(401).send({ error: `Block asset not found "${toBlockInstance.block.ref}` });
+            return;
+        }
+        const consumerResource = getResource(toBlockAsset.data.spec.consumers, req.params.consumerResourceName);
+        if (!consumerResource) {
+            res.status(401).send({
+                error: `Block resource not found "${req.params.consumerInstanceId}::${req.params.consumerResourceName}`,
+            });
+            return;
+        }
+        const basePath = clusterService_1.clusterService.getProxyPath(req.params.systemId, req.params.consumerInstanceId, req.params.consumerResourceName, req.params.type);
+        const fromBlockInstance = lodash_1.default.find(plan.spec.blocks, (blockInstance) => {
+            return blockInstance.id.toLowerCase() === connection.provider.blockId.toLowerCase();
+        });
+        if (!fromBlockInstance) {
+            res.status(401).send({ error: `Block instance not found "${connection.provider.blockId}` });
+            return;
+        }
+        const fromBlockAsset = await assetManager_1.assetManager.getAsset(fromBlockInstance.block.ref);
+        if (!fromBlockAsset) {
+            res.status(401).send({ error: `Block asset not found "${fromBlockInstance.block.ref}` });
+            return;
+        }
+        const providerResource = getResource(fromBlockAsset.data.spec.providers, connection.provider.resourceName);
+        if (!providerResource) {
+            res.status(401).send({
+                error: `Block resource not found "${connection.provider.blockId}::${connection.provider.resourceName}`,
+            });
+            return;
+        }
+        //Get target address
+        let address = await serviceManager_1.serviceManager.getProviderAddress(req.params.systemId, connection.provider.blockId, req.params.type);
+        while (address.endsWith('/')) {
+            address = address.substring(0, address.length - 1);
+        }
+        /*
+     Get the path the consumer requested.
+     Note that this might not match the path the destination is expecting so we need to identify the method
+     that is being called and identify the destination path from the connection.
+     */
+        const consumerPath = req.originalUrl.substring(basePath.length - 1);
+        typeHandler(req, res, {
+            consumerPath,
+            address,
+            consumerResource,
+            providerResource,
+            connection,
+        });
+    }
+    catch (err) {
+        console.warn('Failed to process proxy request', err);
+        res.status(400).send({ error: err.message });
+    }
+});
+exports.default = router;

package/dist/esm/src/proxy/types/rest.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+import { Response } from 'express';
+import { ProxyRequestInfo } from '../../types';
+import { StringBodyRequest } from '../../middleware/stringBody';
+import { Resource } from '@kapeta/schemas';
+export declare function getRestMethodId(restResource: Resource, httpMethod: string, httpPath: string): string | undefined;
+export declare function proxyRestRequest(req: StringBodyRequest, res: Response, opts: ProxyRequestInfo): void;