@kapeta/local-cluster-service 0.6.1 → 0.7.1

package/dist/cjs/src/networkManager.js

@@ -0,0 +1,109 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.networkManager = void 0;
+const node_uuid_1 = __importDefault(require("node-uuid"));
+class NetworkManager {
+    _connections;
+    _sources;
+    _targets;
+    static toConnectionId(connection) {
+        return [
+            connection.provider.blockId,
+            connection.provider.resourceName,
+            connection.consumer.blockId,
+            connection.consumer.resourceName,
+        ].join('_');
+    }
+    constructor() {
+        this._connections = {};
+        this._sources = {};
+        this._targets = {};
+    }
+    _ensureSystem(systemId) {
+        if (!this._connections[systemId]) {
+            this._connections[systemId] = {};
+        }
+        if (!this._sources[systemId]) {
+            this._sources[systemId] = {};
+        }
+        if (!this._targets[systemId]) {
+            this._targets[systemId] = {};
+        }
+    }
+    _ensureConnection(systemId, connectionId) {
+        this._ensureSystem(systemId);
+        if (!this._connections[systemId][connectionId]) {
+            this._connections[systemId][connectionId] = [];
+        }
+        return this._connections[systemId][connectionId];
+    }
+    _ensureSource(systemId, sourceBlockInstanceId) {
+        this._ensureSystem(systemId);
+        if (!this._sources[systemId][sourceBlockInstanceId]) {
+            this._sources[systemId][sourceBlockInstanceId] = [];
+        }
+        return this._sources[systemId][sourceBlockInstanceId];
+    }
+    _ensureTarget(systemId, targetBlockInstanceId) {
+        this._ensureSystem(systemId);
+        if (!this._targets[systemId][targetBlockInstanceId]) {
+            this._targets[systemId][targetBlockInstanceId] = [];
+        }
+        return this._targets[systemId][targetBlockInstanceId];
+    }
+    addRequest(systemId, connection, request, consumerMethodId, providerMethodId) {
+        const traffic = new Traffic(connection, request, consumerMethodId, providerMethodId);
+        this._ensureConnection(systemId, traffic.connectionId).push(traffic);
+        this._ensureSource(systemId, connection.provider.blockId).push(traffic);
+        this._ensureTarget(systemId, connection.consumer.blockId).push(traffic);
+        return traffic;
+    }
+    getTrafficForConnection(systemId, connectionId) {
+        return this._ensureConnection(systemId, connectionId);
+    }
+    getTrafficForSource(systemId, blockInstanceId) {
+        return this._ensureSource(systemId, blockInstanceId);
+    }
+    getTrafficForTarget(systemId, blockInstanceId) {
+        return this._ensureTarget(systemId, blockInstanceId);
+    }
+}
+class Traffic {
+    id;
+    connectionId;
+    consumerMethodId;
+    providerMethodId;
+    created;
+    request;
+    ended;
+    error;
+    response;
+    constructor(connection, request, consumerMethodId, providerMethodId) {
+        this.id = node_uuid_1.default.v4();
+        this.connectionId = NetworkManager.toConnectionId(connection);
+        this.consumerMethodId = consumerMethodId;
+        this.providerMethodId = providerMethodId;
+        this.request = request;
+        this.response = null;
+        this.error = null;
+        this.ended = null;
+        this.created = new Date().getTime();
+    }
+    asError(err) {
+        this.ended = new Date().getTime();
+        this.response = {
+            code: 0,
+            headers: {},
+            body: null,
+        };
+        this.error = err + '';
+    }
+    withResponse(response) {
+        this.ended = new Date().getTime();
+        this.response = response;
+    }
+}
+exports.networkManager = new NetworkManager();

package/dist/cjs/src/operatorManager.d.ts

@@ -0,0 +1,36 @@
+import { ContainerInfo } from './containerManager';
+import { EnvironmentType, OperatorInfo } from './types';
+declare class Operator {
+    private _data;
+    constructor(data: any);
+    getData(): any;
+    getCredentials(): any;
+}
+declare class OperatorManager {
+    private _mountDir;
+    constructor();
+    _getMountPoint(operatorType: string, mountName: string): string;
+    /**
+     * Get operator definition for resource type
+     *
+     * @param {string} resourceType
+     * @param {string} version
+     * @return {Operator}
+     */
+    getOperator(resourceType: string, version: string): Operator;
+    /**
+     * Get information about a specific consumed resource
+     */
+    getConsumerResourceInfo(systemId: string, fromServiceId: string, resourceType: string, portType: string, name: string, environment?: EnvironmentType): Promise<OperatorInfo>;
+    /**
+     * Ensure we have a running operator of given type
+     *
+     * @param {string} systemId
+     * @param {string} resourceType
+     * @param {string} version
+     * @return {Promise<ContainerInfo>}
+     */
+    ensureResource(systemId: string, resourceType: string, version: string): Promise<ContainerInfo>;
+}
+export declare const operatorManager: OperatorManager;
+export {};

package/dist/cjs/src/operatorManager.js

@@ -0,0 +1,165 @@
+"use strict";
+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 local_cluster_config_1 = __importDefault(require("@kapeta/local-cluster-config"));
+const path_1 = __importDefault(require("path"));
+const md5_1 = __importDefault(require("md5"));
+const nodejs_utils_1 = require("@kapeta/nodejs-utils");
+const serviceManager_1 = require("./serviceManager");
+const storageService_1 = require("./storageService");
+const containerManager_1 = require("./containerManager");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const KIND_OPERATOR = 'core/resource-type-operator';
+class Operator {
+    _data;
+    constructor(data) {
+        this._data = data;
+    }
+    getData() {
+        return this._data;
+    }
+    getCredentials() {
+        return this._data.credentials;
+    }
+}
+class OperatorManager {
+    _mountDir;
+    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
+     *
+     * @param {string} resourceType
+     * @param {string} version
+     * @return {Operator}
+     */
+    getOperator(resourceType, version) {
+        const operators = local_cluster_config_1.default.getDefinitions(KIND_OPERATOR);
+        const operator = operators.find((operator) => operator.definition &&
+            operator.definition.metadata &&
+            operator.definition.metadata.name &&
+            operator.definition.metadata.name.toLowerCase() === resourceType.toLowerCase() &&
+            operator.version === version);
+        if (!operator) {
+            throw new Error(`Unknown resource type: ${resourceType}:${version}`);
+        }
+        if (!operator.definition.spec || !operator.definition.spec.local) {
+            throw new Error(`Operator missing local definition: ${resourceType}:${version}`);
+        }
+        return new Operator(operator.definition.spec.local);
+    }
+    /**
+     * Get information about a specific consumed resource
+     */
+    async getConsumerResourceInfo(systemId, fromServiceId, resourceType, portType, name, environment) {
+        const plans = local_cluster_config_1.default.getDefinitions('core/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 blockUri = (0, nodejs_utils_1.parseKapetaUri)(currentInstance.block.ref);
+        const blockDefinition = local_cluster_config_1.default.getDefinitions().find((definition) => definition.version === blockUri.version && definition.definition.metadata.name === blockUri.fullName);
+        if (!blockDefinition) {
+            throw new Error(`Unknown block: ${currentInstance.block.ref} in plan ${systemId}`);
+        }
+        const blockResource = blockDefinition.definition.spec?.consumers?.find((resource) => resource.metadata.name === name);
+        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 = this.getOperator(resourceType, kindUri.version);
+        const credentials = operator.getCredentials();
+        const container = await this.ensureResource(systemId, resourceType, kindUri.version);
+        const portInfo = await container.getPort(portType);
+        if (!portInfo) {
+            throw new Error('Unknown resource port type : ' + resourceType + '#' + portType);
+        }
+        const dbName = name + '_' + fromServiceId.replace(/[^a-z0-9]/gi, '');
+        return {
+            host: environment === 'docker' ? 'host.docker.internal' : '127.0.0.1',
+            port: portInfo.hostPort,
+            type: portType,
+            protocol: portInfo.protocol,
+            options: {
+                dbName,
+            },
+            credentials,
+        };
+    }
+    /**
+     * Ensure we have a running operator of given type
+     *
+     * @param {string} systemId
+     * @param {string} resourceType
+     * @param {string} version
+     * @return {Promise<ContainerInfo>}
+     */
+    async ensureResource(systemId, resourceType, version) {
+        const operator = this.getOperator(resourceType, version);
+        const operatorData = operator.getData();
+        const portTypes = Object.keys(operatorData.ports);
+        portTypes.sort();
+        const containerBaseName = 'kapeta-resource';
+        const nameParts = [resourceType.toLowerCase()];
+        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(resourceType, portType);
+            if (typeof containerPortInfo === 'number' || typeof containerPortInfo === 'string') {
+                containerPortInfo = { port: containerPortInfo, type: 'tcp' };
+            }
+            if (!containerPortInfo.type) {
+                containerPortInfo.type = 'tcp';
+            }
+            const portId = containerPortInfo.port + '/' + containerPortInfo.type;
+            nameParts.push(portType + '-' + portId + '-' + hostPort);
+            ports[portId] = {
+                type: portType,
+                hostPort,
+            };
+        }
+        const mounts = containerManager_1.containerManager.createMounts(resourceType, operatorData.mounts);
+        const containerName = containerBaseName + '-' + (0, md5_1.default)(nameParts.join('_'));
+        let container = await containerManager_1.containerManager.get(containerName);
+        const isRunning = container ? await container.isRunning() : false;
+        if (container && !isRunning) {
+            await container.start();
+        }
+        if (!container) {
+            container = await containerManager_1.containerManager.run(operatorData.image, containerName, {
+                mounts,
+                ports,
+                health: operatorData.health,
+                env: operatorData.env,
+                cmd: operatorData.cmd,
+            });
+        }
+        try {
+            if (operatorData.health) {
+                await containerManager_1.containerManager.waitForHealthy(container.native);
+            }
+            else {
+                await containerManager_1.containerManager.waitForReady(container.native);
+            }
+        }
+        catch (e) {
+            console.error(e.message);
+        }
+        return container;
+    }
+}
+exports.operatorManager = new OperatorManager();

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

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+import { SocketManager } from './socketManager';
+declare class ProgressListener {
+    private socketManager;
+    constructor(socketManager: SocketManager);
+    run(command: string, directory?: string): Promise<{
+        exit: number;
+        signal: NodeJS.Signals | null;
+    }>;
+    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 const progressListener: ProgressListener;
+export {};

package/dist/cjs/src/progressListener.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.progressListener = void 0;
+const child_process_1 = require("child_process");
+const socketManager_1 = require("./socketManager");
+class ProgressListener {
+    socketManager;
+    constructor(socketManager) {
+        this.socketManager = socketManager;
+    }
+    run(command, directory) {
+        this.socketManager.emit(`install`, 'install:log', {
+            type: 'info',
+            message: `Running command "${command}"`,
+        });
+        return new Promise((resolve, reject) => {
+            const child = (0, child_process_1.spawn)(command, {
+                cwd: directory ? directory : process.cwd(),
+                detached: true,
+                shell: true,
+            });
+            child.stdout.on('data', (data) => {
+                this.socketManager.emit(`install`, 'install:log', { type: 'info', message: data.toString() });
+            });
+            child.stderr.on('data', (data) => {
+                this.socketManager.emit(`install`, 'install:log', { type: 'info', message: data.toString() });
+            });
+            child.on('exit', (exit, signal) => {
+                if (exit !== 0) {
+                    this.socketManager.emit(`install`, 'install:log', {
+                        type: 'info',
+                        message: `"${command}" failed: "${exit}"`,
+                    });
+                    reject(new Error(`Command "${command}" exited with code ${exit}`));
+                }
+                else {
+                    this.socketManager.emit(`install`, 'install:log', {
+                        type: 'info',
+                        message: `Command OK: "${command}"`,
+                    });
+                    resolve({ exit, signal });
+                }
+            });
+            child.on('error', (err) => {
+                this.socketManager.emit(`install`, 'install:log', {
+                    type: 'info',
+                    message: `"${command}" failed: "${err.message}"`,
+                });
+                reject(err);
+            });
+        });
+    }
+    async progress(label, callback) {
+        this.socketManager.emit(`install`, 'install:log', { type: 'info', message: `${label}: started` });
+        try {
+            const result = await callback();
+            this.socketManager.emit(`install`, 'install:log', { type: 'info', message: `${label}: done` });
+            return result;
+        }
+        catch (e) {
+            this.socketManager.emit(`install`, 'install:log', {
+                type: 'info',
+                message: `${label}: failed. ${e.message}`,
+            });
+            throw e;
+        }
+    }
+    async check(message, ok) {
+        const wasOk = await ok;
+        this.socketManager.emit(`install`, 'install:log', { type: 'info', message: `${message}: ${wasOk}` });
+    }
+    start(label) {
+        this.socketManager.emit(`install`, 'install:log', { type: 'info', message: label });
+    }
+    showValue(label, value) {
+        this.socketManager.emit(`install`, 'install:log', { type: 'info', message: `${label}: ${value}` });
+    }
+    error(msg, ...args) {
+        this.socketManager.emit(`install`, 'install:log', { type: 'error', message: msg });
+    }
+    warn(msg, ...args) {
+        this.socketManager.emit(`install`, 'install:log', { type: 'warn', message: msg });
+    }
+    info(msg, ...args) {
+        this.socketManager.emit(`install`, 'install:log', { type: 'info', message: msg });
+    }
+    debug(msg, ...args) {
+        this.socketManager.emit(`install`, 'install:log', { type: 'debug', message: msg });
+    }
+}
+exports.progressListener = new ProgressListener(socketManager_1.socketManager);

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

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+declare class ProviderManager {
+    private _webAssetCache;
+    constructor();
+    getWebProviders(): import("@kapeta/local-cluster-config").DefinitionInfo[];
+    getAsset(handle: string, name: string, version: string, sourceMap?: boolean): Promise<string | Buffer | null>;
+}
+export declare const providerManager: ProviderManager;
+export {};

package/dist/cjs/src/providerManager.js

@@ -0,0 +1,51 @@
+"use strict";
+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 repositoryManager_1 = require("./repositoryManager");
+const local_cluster_config_1 = __importDefault(require("@kapeta/local-cluster-config"));
+class ProviderManager {
+    _webAssetCache;
+    constructor() {
+        this._webAssetCache = {};
+    }
+    getWebProviders() {
+        return local_cluster_config_1.default.getProviderDefinitions().filter((providerDefinition) => providerDefinition.hasWeb);
+    }
+    async getAsset(handle, name, version, sourceMap = false) {
+        const fullName = `${handle}/${name}`;
+        const id = `${handle}/${name}/${version}/web.js${sourceMap ? '.map' : ''}`;
+        if (this._webAssetCache[id] && (await fs_extra_1.default.pathExists(this._webAssetCache[id]))) {
+            return fs_extra_1.default.readFile(this._webAssetCache[id], 'utf8');
+        }
+        await repositoryManager_1.repositoryManager.ensureAsset(handle, name, version);
+        const installedProvider = this.getWebProviders().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)) {
+                this._webAssetCache[id] = path;
+                return fs_extra_1.default.readFile(path);
+            }
+        }
+        return null;
+    }
+}
+const providerDefinitions = local_cluster_config_1.default.getProviderDefinitions();
+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);
+    });
+}
+else {
+    console.log('## No providers found ##');
+}
+exports.providerManager = new ProviderManager();

package/dist/cjs/src/providers/routes.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="express" />
+declare const router: import("express").Router;
+export default router;

package/dist/cjs/src/providers/routes.js

@@ -0,0 +1,42 @@
+"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 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.getAsset(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.getAsset(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/cjs/src/proxy/routes.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="express" />
+declare const router: import("express").Router;
+export default router;

package/dist/cjs/src/proxy/routes.js

@@ -0,0 +1,111 @@
+"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 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,
+    web: web_1.proxyWebRequest,
+};
+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 {
+        const typeHandler = TYPE_HANDLERS[req.params.type.toLowerCase()];
+        if (!typeHandler) {
+            res.status(401).send({ error: 'Unknown connection type: ' + req.params.type });
+            return;
+        }
+        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 = lodash_1.default.find(plan.spec.connections, (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/cjs/src/proxy/types/rest.d.ts

@@ -0,0 +1,4 @@
+import { Response } from 'express';
+import { ProxyRequestInfo } from '../../types';
+import { StringBodyRequest } from '../../middleware/stringBody';
+export declare function proxyRestRequest(req: StringBodyRequest, res: Response, opts: ProxyRequestInfo): void;