@routr/dispatcher 2.0.5-alpha.10

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Fonoster Inc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/config/get_config.d.ts

@@ -0,0 +1,3 @@
+import { MessageDispatcherConfig } from "../types";
+import * as E from 'fp-ts/Either';
+export declare const getConfig: (path: string) => E.Either<Error, MessageDispatcherConfig>;

package/dist/config/get_config.js

@@ -0,0 +1,46 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfig = void 0;
+const fs_1 = __importDefault(require("fs"));
+const schema_1 = require("./schema");
+const ajv_1 = __importDefault(require("ajv"));
+const E = __importStar(require("fp-ts/Either"));
+const ajv = new ajv_1.default();
+const validate = ajv.compile(schema_1.schema);
+const getConfig = (path) => {
+    const c = JSON.parse(fs_1.default.readFileSync(path, "utf8"));
+    if (!validate(Object.assign({}, c))) {
+        return E.left(new Error(JSON.stringify(validate.errors[0].message)));
+    }
+    // convert funcMatch to actual functions
+    const processors = c.spec.processors.map((p) => {
+        const { ref, isFallback, addr, methods, matchFunc } = p;
+        return { ref, isFallback, addr, methods, matchFunc: eval(`(${p.matchFunc})`) };
+    });
+    // Re-insert processors with matchFunc now as a function
+    c.spec.processors = processors;
+    return E.right(c.spec);
+};
+exports.getConfig = getConfig;

package/dist/config/schema.d.ts

@@ -0,0 +1,82 @@
+export declare const schema: {
+    $id: string;
+    title: string;
+    description: string;
+    type: string;
+    properties: {
+        kind: {
+            description: string;
+            type: string;
+        };
+        apiVersion: {
+            description: string;
+            type: string;
+        };
+        metadata: {
+            description: string;
+            type: string;
+            properties: {
+                ref: {
+                    description: string;
+                    type: string;
+                };
+            };
+            required: string[];
+        };
+        spec: {
+            description: string;
+            type: string;
+            properties: {
+                bindAddr: {
+                    description: string;
+                    type: string;
+                };
+                middlewares: {
+                    description: string;
+                    type: string;
+                    items: {
+                        type: string;
+                    };
+                    properties: {
+                        ref: {
+                            type: string;
+                        };
+                        addr: {
+                            type: string;
+                        };
+                    };
+                    required: string[];
+                };
+                processors: {
+                    description: string;
+                    type: string;
+                    items: {
+                        type: string;
+                    };
+                    properties: {
+                        ref: {
+                            type: string;
+                        };
+                        isFallback: {
+                            type: string;
+                        };
+                        addr: {
+                            type: string;
+                        };
+                        matchFunc: {
+                            type: string;
+                        };
+                        methods: {
+                            type: string;
+                            items: {
+                                type: string;
+                            };
+                        };
+                    };
+                    required: string[];
+                };
+            };
+        };
+    };
+    required: string[];
+};

package/dist/config/schema.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schema = void 0;
+/*
+ * Copyright (C) 2022 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/routr
+ *
+ * This file is part of Routr
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+exports.schema = {
+    "$id": "https://json-schema.org/draft/2020-12/schema",
+    "title": "Message Dispatcher configuration",
+    "description": "Configuration for a Message Dispatcher instance",
+    "type": "object",
+    "properties": {
+        "kind": {
+            "description": "Resouce type",
+            "type": "string"
+        },
+        "apiVersion": {
+            "description": "Resource version",
+            "type": "string"
+        },
+        "metadata": {
+            "description": "Resource metadata",
+            "type": "object",
+            "properties": {
+                "ref": {
+                    "description": "EdgePort reference",
+                    "type": "string"
+                }
+            },
+            "required": ["ref"]
+        },
+        "spec": {
+            "description": "Operations spec for EdgePort",
+            "type": "object",
+            "properties": {
+                "bindAddr": {
+                    "description": "Ipv4 interface to accept request on",
+                    "type": "string"
+                },
+                "middlewares": {
+                    "description": "Middleware Processors",
+                    "type": "array",
+                    "items": {
+                        "type": "object"
+                    },
+                    "properties": {
+                        "ref": {
+                            "type": "string"
+                        },
+                        "addr": {
+                            "type": "string"
+                        }
+                    },
+                    "required": ["ref", "addr"]
+                },
+                "processors": {
+                    "description": "Message Processors",
+                    "type": "array",
+                    "items": {
+                        "type": "object"
+                    },
+                    "properties": {
+                        "ref": {
+                            "type": "string"
+                        },
+                        "isFallback": {
+                            "type": "boolean"
+                        },
+                        "addr": {
+                            "type": "string"
+                        },
+                        "matchFunc": {
+                            "type": "string"
+                        },
+                        "methods": {
+                            "type": "array",
+                            "items": {
+                                "type": "string"
+                            }
+                        }
+                    },
+                    "required": ["ref", "addr", "methods", "matchFunc"]
+                }
+            }
+        }
+    },
+    "required": ["kind", "metadata", "spec", "apiVersion"]
+};

package/dist/connections.d.ts

@@ -0,0 +1,12 @@
+import { ProcessorGPRCConnection } from "./types";
+/**
+ * Creates a connection to all the backend processors. The function will
+ * fail if any of the backends is unavailable during initialization.
+ *
+ * @param processors list of backend processors
+ * @returns list of connections
+ */
+export default function connectToBackend(processors: {
+    ref: string;
+    addr: string;
+}[]): Map<string, ProcessorGPRCConnection>;

package/dist/connections.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const common_1 = require("@routr/common");
+const grpc = require("@grpc/grpc-js");
+/**
+ * Creates a connection to all the backend processors. The function will
+ * fail if any of the backends is unavailable during initialization.
+ *
+ * @param processors list of backend processors
+ * @returns list of connections
+ */
+function connectToBackend(processors) {
+    const procs = processors ? [...processors] : [];
+    const connections = new Map();
+    for (const processor of procs) {
+        connections.set(processor.ref, new common_1.PROCESSOR_OBJECT_PROTO.Processor(processor.addr, grpc.credentials.createInsecure()));
+    }
+    return connections;
+}
+exports.default = connectToBackend;

package/dist/errors.d.ts

@@ -0,0 +1,13 @@
+import grpc = require("@grpc/grpc-js");
+export declare class NotMatchingProcessorFound extends Error {
+    code: grpc.status;
+    constructor(ref: string);
+}
+export declare class ProcessorUnavailableError extends Error {
+    code: number;
+    constructor(ref: string);
+}
+export declare class MiddlewareUnavailableError extends Error {
+    code: number;
+    constructor(ref: string);
+}

package/dist/errors.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MiddlewareUnavailableError = exports.ProcessorUnavailableError = exports.NotMatchingProcessorFound = void 0;
+/*
+ * Copyright (C) 2022 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/routr
+ *
+ * This file is part of Routr
+ *
+ * Licensed under the MIT License (the "License")
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const grpc = require("@grpc/grpc-js");
+class NotMatchingProcessorFound extends Error {
+    constructor(ref) {
+        super(`not matching processor found for request ref: ${ref}`);
+        this.code = grpc.status.NOT_FOUND;
+        // Set the prototype explicitly.
+        Object.setPrototypeOf(this, NotMatchingProcessorFound.prototype);
+    }
+}
+exports.NotMatchingProcessorFound = NotMatchingProcessorFound;
+class ProcessorUnavailableError extends Error {
+    constructor(ref) {
+        super(`processor ref = ${ref} is unavailable`);
+        this.code = grpc.status.UNAVAILABLE;
+        // Set the prototype explicitly.
+        Object.setPrototypeOf(this, ProcessorUnavailableError.prototype);
+    }
+}
+exports.ProcessorUnavailableError = ProcessorUnavailableError;
+class MiddlewareUnavailableError extends Error {
+    constructor(ref) {
+        super(`middleware ref = ${ref} is unavailable`);
+        this.code = grpc.status.UNAVAILABLE;
+        // Set the prototype explicitly.
+        Object.setPrototypeOf(this, MiddlewareUnavailableError.prototype);
+    }
+}
+exports.MiddlewareUnavailableError = MiddlewareUnavailableError;

package/dist/find_processor.d.ts

@@ -0,0 +1,5 @@
+import { MessageRequest, ProcessorConfig } from "@routr/common";
+import { NotMatchingProcessorFound } from "./errors";
+export declare const hasMethod: (config: ProcessorConfig, request: MessageRequest) => boolean;
+export declare const filter: (request: MessageRequest, config: ProcessorConfig) => boolean;
+export declare const findProcessor: (list: Array<ProcessorConfig>) => (request: MessageRequest) => NotMatchingProcessorFound | ProcessorConfig;

package/dist/find_processor.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findProcessor = exports.filter = exports.hasMethod = void 0;
+const errors_1 = require("./errors");
+const hasMethod = (config, request) => config.methods.includes(request.method);
+exports.hasMethod = hasMethod;
+// TODO: We need a way to test the matching function
+const filter = (request, config) => exports.hasMethod(config, request)
+    && (config.isFallback || config.matchFunc(request));
+exports.filter = filter;
+const findProcessor = (list) => (request) => list.find((config) => exports.filter(request, config))
+    || new errors_1.NotMatchingProcessorFound(request.ref);
+exports.findProcessor = findProcessor;

package/dist/processor.d.ts

@@ -0,0 +1,7 @@
+import { ProcessorConfig } from "@routr/common";
+import { ProcessorCallback } from "./types";
+import { MiddlewareConfig } from "@routr/common/src/types";
+export default function processor(params: {
+    processors: ProcessorConfig[];
+    middlewares?: MiddlewareConfig[];
+}): (call: any, callback: ProcessorCallback) => void;

package/dist/processor.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 });
+/*
+ * Copyright (C) 2022 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/routr
+ *
+ * This file is part of Routr
+ *
+ * Licensed under the MIT License (the "License")
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const connections_1 = __importDefault(require("./connections"));
+const run_processor_1 = require("./run_processor");
+const run_middlewares_1 = require("./run_middlewares");
+const logger_1 = __importDefault(require("@fonoster/logger"));
+function processor(params) {
+    const { processors, middlewares } = params;
+    const procConns = connections_1.default(processors);
+    const middConns = connections_1.default(middlewares);
+    // Upstream request and callback
+    return (call, callback) => {
+        const { request } = call;
+        // Messages type reponse will not be sent to middleware chain
+        if (request.message.messageType === 'responseType') {
+            return run_processor_1.runProcessor({ callback, request, processors, connections: procConns });
+        }
+        run_middlewares_1.runMiddlewares({ callback, request, middlewares, connections: middConns })
+            .then((req) => {
+            // Since the chain was broken we need to skip the processor and return the updated request
+            if (req.message.messageType === "responseType") {
+                logger_1.default.verbose("skipped processsing request ref " + req.ref);
+                return callback(null, req);
+            }
+            run_processor_1.runProcessor({ callback, request: req, processors, connections: procConns });
+        })
+            .catch(callback);
+    };
+}
+exports.default = processor;

package/dist/run_middlewares.d.ts

@@ -0,0 +1,3 @@
+import { RunMiddlewaresParams } from "./types";
+import { MessageRequest } from "@routr/common";
+export declare function runMiddlewares(params: RunMiddlewaresParams): Promise<MessageRequest>;

package/dist/run_middlewares.js

@@ -0,0 +1,73 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runMiddlewares = void 0;
+/*
+ * Copyright (C) 2022 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/routr
+ *
+ * This file is part of Routr
+ *
+ * Licensed under the MIT License (the "License")
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const errors_1 = require("./errors");
+const grpc = require("@grpc/grpc-js");
+const logger_1 = __importDefault(require("@fonoster/logger"));
+function processMessage(middlewareRef, conn, request) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise((resolve, reject) => {
+            conn.processMessage(request, (err, response) => {
+                return (err === null || err === void 0 ? void 0 : err.code) === grpc.status.UNAVAILABLE
+                    ? reject(new errors_1.MiddlewareUnavailableError(middlewareRef))
+                    : resolve(response);
+            });
+        });
+    });
+}
+function runMiddlewares(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { connections, request, middlewares = [] } = params;
+        const req = Object.assign({}, request);
+        return new Promise((resolve, rejects) => __awaiter(this, void 0, void 0, function* () {
+            for (const midd of middlewares) {
+                logger_1.default.verbose("forwarding request to middleware with ref => " + midd.ref);
+                // Get the next middleware
+                const conn = connections.get(midd.ref);
+                // Send message and re-insert response for next middleware
+                try {
+                    req.message = (yield processMessage(midd.ref, conn, req)).message;
+                    if (req.message.messageType === "responseType") {
+                        logger_1.default.verbose("found messageType to be responseType and broke the chain");
+                        break;
+                    }
+                }
+                catch (e) {
+                    rejects(e);
+                }
+            }
+            resolve(req);
+        }));
+    });
+}
+exports.runMiddlewares = runMiddlewares;

package/dist/run_processor.d.ts

@@ -0,0 +1,2 @@
+import { RunProcessorParams } from "./types";
+export declare function runProcessor(params: RunProcessorParams): any;

package/dist/run_processor.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runProcessor = void 0;
+/*
+ * Copyright (C) 2022 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/routr
+ *
+ * This file is part of Routr
+ *
+ * Licensed under the MIT License (the "License")
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const errors_1 = require("./errors");
+const find_processor_1 = require("./find_processor");
+const grpc = require("@grpc/grpc-js");
+const logger_1 = __importDefault(require("@fonoster/logger"));
+function runProcessor(params) {
+    const { callback, connections, processors, request } = params;
+    const matchResult = find_processor_1.findProcessor(processors)(request);
+    if ('code' in matchResult) {
+        return callback(matchResult);
+    }
+    logger_1.default.verbose("forwarding request to processor with ref => " + matchResult.ref);
+    const conn = connections.get(matchResult.ref);
+    // Connects to downstream processor
+    conn.processMessage(request, (err, response) => {
+        if ((err === null || err === void 0 ? void 0 : err.code) === grpc.status.UNAVAILABLE) {
+            // We augment the error to indicate which processor failed
+            callback(new errors_1.ProcessorUnavailableError(matchResult.ref));
+            return;
+        }
+        callback(err, response);
+    });
+}
+exports.runProcessor = runProcessor;

package/dist/runner.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/runner.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/*
+ * Copyright (C) 2022 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/routr
+ *
+ * This file is part of Routr
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const service_1 = __importDefault(require("./service"));
+const get_config_1 = require("./config/get_config");
+const logger_1 = __importDefault(require("@fonoster/logger"));
+const result = get_config_1.getConfig(process.env.CONFIG_PATH);
+if (result._tag === 'Right') {
+    service_1.default(result.right);
+}
+else {
+    logger_1.default.error(result.left);
+}

package/dist/service.d.ts

@@ -0,0 +1,2 @@
+import { MessageDispatcherConfig } from "./types";
+export default function MessageDispatcher(config: MessageDispatcherConfig): void;

package/dist/service.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const common_1 = require("@routr/common");
+const util_1 = require("./util");
+function MessageDispatcher(config) {
+    const { bindAddr, processors, middlewares } = config;
+    common_1.createService(util_1.getServiceInfo(bindAddr, { processors, middlewares }));
+}
+exports.default = MessageDispatcher;

package/dist/types.d.ts

@@ -0,0 +1,25 @@
+import { MessageRequest, ProcessorConfig } from "@routr/common";
+import { MiddlewareConfig } from "@routr/common/src/types";
+import { NotMatchingProcessorFound, ProcessorUnavailableError } from "./errors";
+export interface MessageDispatcherConfig {
+    bindAddr: string;
+    processors: ProcessorConfig[];
+    middlewares: MiddlewareConfig[];
+}
+export interface ProcessorGPRCConnection {
+    processMessage: (request: unknown, callback: Function) => void;
+}
+export declare type CallbackErrors = NotMatchingProcessorFound | ProcessorUnavailableError | Error;
+export declare type ProcessorCallback = (err: CallbackErrors, reponse?: MessageRequest) => void;
+export interface RunProcessorParams {
+    callback: Function;
+    connections: Map<string, ProcessorGPRCConnection>;
+    processors: ProcessorConfig[];
+    request: MessageRequest;
+}
+export interface RunMiddlewaresParams {
+    callback: Function;
+    connections: Map<string, ProcessorGPRCConnection>;
+    middlewares: MiddlewareConfig[];
+    request: MessageRequest;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/util.d.ts

@@ -0,0 +1,6 @@
+import { ProcessorConfig, ServiceInfo } from "@routr/common";
+import { MiddlewareConfig } from "@routr/common/src/types";
+export declare function getServiceInfo(bindAddr: string, backends: {
+    middlewares: MiddlewareConfig[];
+    processors: ProcessorConfig[];
+}): ServiceInfo;

package/dist/util.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getServiceInfo = void 0;
+/*
+ * Copyright (C) 2022 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/routr
+ *
+ * This file is part of Routr
+ *
+ * Licensed under the MIT License (the "License")
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const processor_1 = __importDefault(require("./processor"));
+const common_1 = require("@routr/common");
+function getServiceInfo(bindAddr, backends) {
+    return {
+        name: "dispatcher",
+        bindAddr,
+        service: common_1.PROCESSOR_OBJECT_PROTO.Processor.service,
+        handlers: {
+            processMessage: processor_1.default(backends)
+        }
+    };
+}
+exports.getServiceInfo = getServiceInfo;

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@routr/dispatcher",
+  "version": "2.0.5-alpha.10",
+  "description": "Receives SIP messages and forwards them to the corresponding Message Processor",
+  "author": "Pedro Sanders <psanders@fonoster.com>",
+  "homepage": "https://github.com/fonoster/routr#readme",
+  "license": "MIT",
+  "main": "dist/dispatcher",
+  "types": "dist/dispatcher",
+  "scripts": {
+    "prebuild": "rimraf ./dist tsconfig.tsbuildinfo",
+    "build": "tsc -b tsconfig.json"
+  },
+  "bin": {
+    "run_dispatcher": "dist/runner.js"
+  },
+  "directories": {
+    "src": "src",
+    "test": "test"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@grpc/grpc-js": "^1.5.9",
+    "@routr/common": "^2.0.5-alpha.10",
+    "ajv": "^6.12.6",
+    "fp-ts": "^2.11.8"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fonoster/routr.git"
+  },
+  "bugs": {
+    "url": "https://github.com/fonoster/routr/issues"
+  },
+  "gitHead": "10c6ff135a370a4a4634478fdaf5f42c5c13e28c"
+}