@routr/location 2.0.5-alpha.15 → 2.0.5-alpha.17

package/dist/client.d.ts

@@ -1,14 +1,47 @@
 import { AddRouteRequest, FindRoutesRequest, ILocationService, RemoveRoutesRequest } from "./types";
 import { Route } from "@routr/common";
+/**
+ * Location client
+ */
 export default class Location implements ILocationService {
     location: any;
     config: {
         addr: string;
     };
+    /**
+     * Create a new Location client.
+     *
+     * @param {object} config - Location client config
+     * @param {string} config.addr - Location service address
+     */
     constructor(config: {
         addr: string;
     });
+    /**
+     * Add a route to the location service.
+     *
+     * @param {AddRouteRequest} request - Add route request
+     * @param {string} request.aor - AOR of the route
+     * @param {Route} request.route - Route to add
+     * @return {Promise<void>}
+     */
     addRoute(request: AddRouteRequest): Promise<void>;
+    /**
+     * Add a route to the location service.
+     *
+     * @param {FindRoutesResponse} request - Request to find routes
+     * @param {string} request.aor - AOR of the route
+     * @param {Map<string, string>} request.labels - Optional Route labels
+     * @param {string} request.sessionAffinityRef - Optiona session affinity ref
+     * @return {Promise<void>}
+     */
     findRoutes(request: FindRoutesRequest): Promise<Route[]>;
+    /**
+     * Add a route to the location service.
+     *
+     * @param {RemoveRoutesRequest} request - Remove routes request
+     * @param {string} request.aor - AOR of the route
+     * @return {Promise<void>}
+     */
     removeRoutes(request: RemoveRoutesRequest): Promise<void>;
 }

package/dist/client.js

@@ -1,4 +1,27 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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 __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) {
@@ -10,32 +33,68 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const common_1 = require("@routr/common");
-const grpc = require("@grpc/grpc-js");
-function container(self, request, name) {
+const grpc = __importStar(require("@grpc/grpc-js"));
+const container = (self, request, name) => {
     return new Promise((resolve, reject) => {
         self.location[name](request, (err, response) => {
             if ((err === null || err === void 0 ? void 0 : err.code) === grpc.status.UNAVAILABLE) {
-                return reject(new common_1.ServiceUnavailableError(this.config.addr));
+                return reject(new common_1.ServiceUnavailableError(self.config.addr));
             }
             resolve(response);
         });
     });
-}
+};
+/**
+ * Location client
+ */
 class Location {
+    /**
+     * Create a new Location client.
+     *
+     * @param {object} config - Location client config
+     * @param {string} config.addr - Location service address
+     */
     constructor(config) {
         this.config = config;
-        this.location = new common_1.LOCATION_OBJECT_PROTO
-            .Location(config.addr, grpc.credentials.createInsecure());
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.location = new common_1.LOCATION_OBJECT_PROTO.Location(config.addr, grpc.credentials.createInsecure());
     }
+    /**
+     * Add a route to the location service.
+     *
+     * @param {AddRouteRequest} request - Add route request
+     * @param {string} request.aor - AOR of the route
+     * @param {Route} request.route - Route to add
+     * @return {Promise<void>}
+     */
     addRoute(request) {
         return container(this, request, this.addRoute.name);
     }
+    /**
+     * Add a route to the location service.
+     *
+     * @param {FindRoutesResponse} request - Request to find routes
+     * @param {string} request.aor - AOR of the route
+     * @param {Map<string, string>} request.labels - Optional Route labels
+     * @param {string} request.sessionAffinityRef - Optiona session affinity ref
+     * @return {Promise<void>}
+     */
     findRoutes(request) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            return ((_a = (yield container(this, request, this.findRoutes.name))) === null || _a === void 0 ? void 0 : _a.routes) || [];
+            return (
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            ((_a = ((yield container(this, request, this.findRoutes.name)))) === null || _a === void 0 ? void 0 : _a.routes) ||
+                []);
         });
     }
+    /**
+     * Add a route to the location service.
+     *
+     * @param {RemoveRoutesRequest} request - Remove routes request
+     * @param {string} request.aor - AOR of the route
+     * @return {Promise<void>}
+     */
     removeRoutes(request) {
         return container(this, request, this.removeRoutes.name);
     }

package/dist/config/get_config.d.ts

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

package/dist/config/get_config.js

@@ -53,9 +53,9 @@ const E = __importStar(require("fp-ts/Either"));
 const errors_1 = require("../errors");
 const ajv = new ajv_1.default();
 const validate = ajv.compile(schema_1.schema);
-const hasBadCombiniation = (backends) => backends.some((b) => b.balancingAlgorithm === types_1.LB_ALGORITHM.ROUND_ROBIN && b.sessionAffinity);
-const hasBadAlgorithm = (backends) => backends.some((b) => b.balancingAlgorithm !== types_1.LB_ALGORITHM.ROUND_ROBIN
-    && b.balancingAlgorithm !== types_1.LB_ALGORITHM.LEAST_SESSIONS);
+const hasBadCombiniation = (backends) => backends.some((b) => b.balancingAlgorithm === types_1.LB_ALGORITHM.ROUND_ROBIN && b.withSessionAffinity);
+const hasBadAlgorithm = (backends) => backends.some((b) => b.balancingAlgorithm !== types_1.LB_ALGORITHM.ROUND_ROBIN &&
+    b.balancingAlgorithm !== types_1.LB_ALGORITHM.LEAST_SESSIONS);
 const getConfig = (path) => {
     var _a, _b, _c;
     const c = JSON.parse(fs_1.default.readFileSync(path, "utf8"));
@@ -67,7 +67,8 @@ const getConfig = (path) => {
         config.backends.map((b) => {
             // Setting round-robin by default
             b.balancingAlgorithm = b.balancingAlgorithm
-                ? b.balancingAlgorithm : types_1.LB_ALGORITHM.ROUND_ROBIN;
+                ? b.balancingAlgorithm
+                : types_1.LB_ALGORITHM.ROUND_ROBIN;
             return b;
         });
         if (hasBadCombiniation(config.backends)) {

package/dist/config/schema.d.ts

@@ -47,18 +47,9 @@ export declare const schema: {
                         balancingAlgorithm: {
                             enum: string[];
                         };
-                        sessionAffinity: {
+                        withSessionAffinity: {
                             description: string;
                             type: string;
-                            properties: {
-                                enabled: {
-                                    type: string;
-                                };
-                                ref: {
-                                    type: string;
-                                };
-                            };
-                            required: string[];
                         };
                     };
                     required: string[];

package/dist/config/schema.js

@@ -20,72 +20,63 @@ exports.schema = void 0;
  * limitations under the License.
  */
 exports.schema = {
-    "$id": "https://json-schema.org/draft/2020-12/schema",
-    "title": "Location Service configuration",
-    "description": "Configuration for an instance of the Location Service",
-    "type": "object",
-    "properties": {
-        "kind": {
-            "enum": ["Location", "location"]
+    $id: "https://json-schema.org/draft/2020-12/schema",
+    title: "Location Service configuration",
+    description: "Configuration for an instance of the Location Service",
+    type: "object",
+    properties: {
+        kind: {
+            enum: ["Location", "location"]
         },
-        "apiVersion": {
-            "enum": ["v2draft1"]
+        apiVersion: {
+            enum: ["v2draft1"]
         },
-        "metadata": {
-            "description": "Resource metadata",
-            "type": "object"
+        metadata: {
+            description: "Resource metadata",
+            type: "object"
         },
-        "spec": {
-            "description": "Operations spec for Location",
-            "type": "object",
-            "properties": {
-                "bindAddr": {
-                    "description": "Ipv4 interface to accept request on",
-                    "type": "string"
+        spec: {
+            description: "Operations spec for Location",
+            type: "object",
+            properties: {
+                bindAddr: {
+                    description: "Ipv4 interface to accept request on",
+                    type: "string"
                 },
-                "cache": {
-                    "type": "object",
-                    "properties": {
-                        "provider": {
-                            "enum": ["memory", "redis"]
-                        },
-                        "parameters": {
-                            "type": "string"
+                cache: {
+                    type: "object",
+                    properties: {
+                        provider: {
+                            enum: ["memory", "redis"]
                         },
+                        parameters: {
+                            type: "string"
+                        }
                     },
-                    "required": ["provider"]
+                    required: ["provider"]
                 },
-                "backends": {
-                    "description": "Optional SIP backends",
-                    "type": "array",
-                    "items": {
-                        "type": "object"
+                backends: {
+                    description: "Optional SIP backends",
+                    type: "array",
+                    items: {
+                        type: "object"
                     },
-                    "properties": {
-                        "ref": {
-                            "type": "string"
-                        },
-                        "balancingAlgorithm": {
-                            "enum": ["round-robin", "least-sessions"]
+                    properties: {
+                        ref: {
+                            type: "string"
                         },
-                        "sessionAffinity": {
-                            "description": "Optional session affinity",
-                            "type": "object",
-                            "properties": {
-                                "enabled": {
-                                    "type": "boolean"
-                                },
-                                "ref": {
-                                    "type": "string"
-                                }
-                            },
-                            "required": ["ref"]
+                        balancingAlgorithm: {
+                            enum: ["round-robin", "least-sessions"]
                         },
+                        withSessionAffinity: {
+                            description: "Optional session affinity",
+                            type: "boolean"
+                        }
                     },
-                    "required": ["ref"]
-                },
+                    required: ["ref"]
+                }
             }
         }
     },
-    "required": ["kind", "metadata", "spec", "apiVersion"]
+    required: ["kind", "spec", "apiVersion"]
 };

package/dist/errors.d.ts

@@ -1,23 +1,59 @@
-import grpc = require("@grpc/grpc-js");
+import * as grpc from "@grpc/grpc-js";
 export declare type LocationError = UnsupportedSchema | NotRoutesFoundForAOR;
 export declare type InvalidConfiguration = BadAlgorithmAndAffinityCombination | InvalidSchemaConfiguration;
+/**
+ * Error thrown when the location service returns an unsupported schema.
+ */
 export declare class UnsupportedSchema extends Error {
     code: grpc.status;
+    /**
+     * Create a new UnsupportedSchema error.
+     *
+     * @param {string} aor - The AOR that was requested
+     */
     constructor(aor: string);
 }
+/**
+ * Error thrown when the location service returns no routes for the AOR.
+ */
 export declare class NotRoutesFoundForAOR extends Error {
     code: number;
+    /**
+     * Create a new NotRoutesFoundForAOR error.
+     *
+     * @param {string} aor - The AOR that was requested
+     */
     constructor(aor: string);
 }
+/**
+ * Error thrown when the location finds a bad configuration.
+ */
 export declare class InvalidSchemaConfiguration extends Error {
     code: grpc.status;
+    /**
+     * Create a new InvalidSchemaConfiguration error.
+     *
+     * @param {string} msg - Message from the validation error
+     */
     constructor(msg: string);
 }
+/**
+ * Error thrown when the location finds incompatible algorithm and session affinity.
+ */
 export declare class BadAlgorithmAndAffinityCombination extends Error {
     code: grpc.status;
+    /**
+     * Create a new BadAlgorithmAndAffinityCombination error.
+     */
     constructor();
 }
+/**
+ * Error thrown when the location finds an invalid balancing algorithm.
+ */
 export declare class InvalidLoadBalancerAlgorithm extends Error {
     code: grpc.status;
+    /**
+     * Create a new InvalidLoadBalancerAlgorithm error.
+     */
     constructor();
 }

package/dist/errors.js

@@ -1,4 +1,27 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidLoadBalancerAlgorithm = exports.BadAlgorithmAndAffinityCombination = exports.InvalidSchemaConfiguration = exports.NotRoutesFoundForAOR = exports.UnsupportedSchema = void 0;
 /*
@@ -19,8 +42,16 @@ exports.InvalidLoadBalancerAlgorithm = exports.BadAlgorithmAndAffinityCombinatio
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-const grpc = require("@grpc/grpc-js");
+const grpc = __importStar(require("@grpc/grpc-js"));
+/**
+ * Error thrown when the location service returns an unsupported schema.
+ */
 class UnsupportedSchema extends Error {
+    /**
+     * Create a new UnsupportedSchema error.
+     *
+     * @param {string} aor - The AOR that was requested
+     */
     constructor(aor) {
         super(`aor ${aor} has an invalid schema, only "sip:" or "backend:" are allowed`);
         this.code = grpc.status.INVALID_ARGUMENT;
@@ -29,15 +60,31 @@ class UnsupportedSchema extends Error {
     }
 }
 exports.UnsupportedSchema = UnsupportedSchema;
+/**
+ * Error thrown when the location service returns no routes for the AOR.
+ */
 class NotRoutesFoundForAOR extends Error {
+    /**
+     * Create a new NotRoutesFoundForAOR error.
+     *
+     * @param {string} aor - The AOR that was requested
+     */
     constructor(aor) {
-        super(`no routes found for aor ${aor}`);
+        super(`no routes found for aor: ${aor}`);
         this.code = grpc.status.NOT_FOUND;
         Object.setPrototypeOf(this, NotRoutesFoundForAOR.prototype);
     }
 }
 exports.NotRoutesFoundForAOR = NotRoutesFoundForAOR;
+/**
+ * Error thrown when the location finds a bad configuration.
+ */
 class InvalidSchemaConfiguration extends Error {
+    /**
+     * Create a new InvalidSchemaConfiguration error.
+     *
+     * @param {string} msg - Message from the validation error
+     */
     constructor(msg) {
         super(msg);
         this.code = grpc.status.INVALID_ARGUMENT;
@@ -45,14 +92,26 @@ class InvalidSchemaConfiguration extends Error {
     }
 }
 exports.InvalidSchemaConfiguration = InvalidSchemaConfiguration;
+/**
+ * Error thrown when the location finds incompatible algorithm and session affinity.
+ */
 class BadAlgorithmAndAffinityCombination extends Error {
+    /**
+     * Create a new BadAlgorithmAndAffinityCombination error.
+     */
     constructor() {
         super("session affinity can not be combined with round-robin load balancing");
         Object.setPrototypeOf(this, BadAlgorithmAndAffinityCombination.prototype);
     }
 }
 exports.BadAlgorithmAndAffinityCombination = BadAlgorithmAndAffinityCombination;
+/**
+ * Error thrown when the location finds an invalid balancing algorithm.
+ */
 class InvalidLoadBalancerAlgorithm extends Error {
+    /**
+     * Create a new InvalidLoadBalancerAlgorithm error.
+     */
     constructor() {
         super("found invalid load balancing algorithm. must be round-robin or least-sessions");
         Object.setPrototypeOf(this, BadAlgorithmAndAffinityCombination.prototype);

package/dist/helper.d.ts

@@ -1,3 +1,2 @@
-import { Route } from "@routr/common";
-import { MessageRequest } from "@routr/common";
+import { MessageRequest, Route } from "@routr/common";
 export declare const createRoute: (request: MessageRequest) => Route;

package/dist/helper.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createRoute = void 0;
 const processor_1 = require("@routr/processor");
-const processor_2 = require("@routr/processor");
 // TODO: Before finalizing this, consider using the old approach of saving the rport
 // and received values (like here:
 //    https://github.com/fonoster/routr/blob/59bc98af86078088aede7e658c0d82a19fa18fa4/mod/registrar/utils.js#L87)
@@ -11,15 +10,18 @@ const processor_2 = require("@routr/processor");
 // and https://github.com/fonoster/routr/blob/ee5d339888344013939d06c734385f17f0cd75c2/mod/registrar/utils.js#L131
 const createRoute = (request) => {
     const uri = request.message.contact.address.uri;
+    const sessionCount = processor_1.Extensions.getHeaderValue(request, "x-session-count")
+        ? parseInt(processor_1.Extensions.getHeaderValue(request, "x-session-count"))
+        : -1;
     return {
         edgePortRef: request.edgePortRef,
         user: uri.user,
         host: uri.host,
         port: uri.port,
-        transport: uri.transport,
+        transport: uri.transportParam,
         registeredOn: Date.now(),
-        sessionCount: processor_1.Extensions.getHeaderValue(request, "x-session-count") || -1,
-        expires: processor_2.Target.getTargetExpires(request),
+        sessionCount,
+        expires: processor_1.Target.getTargetExpires(request),
         listeningPoint: request.listeningPoint
     };
 };

package/dist/index.d.ts

@@ -1,4 +1,6 @@
 import LocationClient from "./client";
+import { ILocationService } from "./types";
 export * as Helper from "./helper";
 export * as Utils from "./utils";
-export { LocationClient };
+export * from "./errors";
+export { LocationClient, ILocationService };

package/dist/index.js

@@ -22,6 +22,9 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -49,3 +52,4 @@ const client_1 = __importDefault(require("./client"));
 exports.LocationClient = client_1.default;
 exports.Helper = __importStar(require("./helper"));
 exports.Utils = __importStar(require("./utils"));
+__exportStar(require("./errors"), exports);

package/dist/location.d.ts

@@ -1,13 +1,25 @@
 import { AddRouteRequest, Backend, FindRoutesRequest, ILocationService, ILocatorStore, RemoveRoutesRequest } from "./types";
 import { Route } from "@routr/common";
+/**
+ * A locator store that uses the location service to find routes for AORs.
+ */
 export default class Location implements ILocationService {
     private store;
     private backends;
     private rrCount;
     private affinityStore;
+    /**
+     * Creates a new Location service. Should fail if any backend has sessionAffinity and round-robin
+     *
+     * @param {ILocatorStore} store - The store to use for the location service
+     * @param {Map<string, Backend>} backends - The backends to use for the location service
+     */
     constructor(store: ILocatorStore, backends?: Map<string, Backend>);
+    /** @inheritdoc */
     addRoute(request: AddRouteRequest): Promise<void>;
+    /** @inheritdoc */
     findRoutes(request: FindRoutesRequest): Promise<Route[]>;
+    /** @inheritdoc */
     removeRoutes(request: RemoveRoutesRequest): Promise<void>;
     private next;
     private nextWithAffinity;

package/dist/location.js

@@ -30,8 +30,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const errors_1 = require("./errors");
 const types_1 = require("./types");
 const utils_1 = require("./utils");
+var AOR_SCHEME;
+(function (AOR_SCHEME) {
+    AOR_SCHEME["SIP"] = "sip:";
+    AOR_SCHEME["BACKEND"] = "backend:";
+})(AOR_SCHEME || (AOR_SCHEME = {}));
+/**
+ * A locator store that uses the location service to find routes for AORs.
+ */
 class Location {
-    // Should fail if any backend has sessionAffinity and round-robin
+    /**
+     * Creates a new Location service. Should fail if any backend has sessionAffinity and round-robin
+     *
+     * @param {ILocatorStore} store - The store to use for the location service
+     * @param {Map<string, Backend>} backends - The backends to use for the location service
+     */
     constructor(store, backends = new Map()) {
         this.store = store;
         this.backends = backends;
@@ -39,55 +52,59 @@ class Location {
         this.affinityStore = new Map();
         this.backends.forEach((value, key) => this.rrCount.set(key, 0));
     }
+    /** @inheritdoc */
     addRoute(request) {
-        if (!request.aor.startsWith('sip:') &&
-            !request.aor.startsWith('backend:')) {
+        if (!request.aor.startsWith(AOR_SCHEME.SIP) &&
+            !request.aor.startsWith(AOR_SCHEME.BACKEND)) {
             throw new errors_1.UnsupportedSchema(request.aor);
         }
         return this.store.put(request.aor, request.route);
     }
+    /** @inheritdoc */
     findRoutes(request) {
         return __awaiter(this, void 0, void 0, function* () {
             const routes = request.labels
-                ? (yield this.store.get(request.aor))
-                    .filter((0, utils_1.filterOnlyMatchingLabels)(request.labels))
+                ? (yield this.store.get(request.aor)).filter((0, utils_1.filterOnlyMatchingLabels)(request.labels))
                 : (yield this.store.get(request.aor)) || [];
-            if (request.aor.startsWith('sip:')) {
+            if (request.aor.startsWith(AOR_SCHEME.SIP)) {
                 return routes;
             }
-            else if (request.aor.startsWith('backend:')) {
+            else if (request.aor.startsWith(AOR_SCHEME.BACKEND)) {
                 const backend = this.backends.get(request.aor);
                 if (!backend) {
                     throw new errors_1.NotRoutesFoundForAOR(request.aor);
                 }
                 // If it has not affinity sesssion then get next
-                return !(0, utils_1.hasAffinitySession)(backend)
-                    ? [this.next(routes, backend)]
-                    : [this.nextWithAffinity(yield routes, backend.sessionAffinity.ref)];
+                return backend.withSessionAffinity
+                    ? [this.nextWithAffinity(routes, request.sessionAffinityRef)]
+                    : [this.next(routes, backend)];
             }
             throw new errors_1.UnsupportedSchema(request.aor);
         });
     }
+    /** @inheritdoc */
     removeRoutes(request) {
         return this.store.delete(request.aor);
     }
+    // eslint-disable-next-line require-jsdoc
     next(routes, backend) {
         if (backend.balancingAlgorithm === types_1.LB_ALGORITHM.LEAST_SESSIONS) {
             return routes.sort((r1, r2) => r1.sessionCount - r2.sessionCount)[0];
         }
         // Continues using round-robin
-        const nextPosition = this.rrCount.get(`backend:${backend.ref}`);
+        const nextPosition = this.rrCount.get(`${AOR_SCHEME.BACKEND}${backend.ref}`);
         const result = routes[nextPosition];
-        if (nextPosition >= (routes.length - 1)) {
+        if (nextPosition >= routes.length - 1) {
             // Restarting round-robin counter
-            this.rrCount.set(`backend:${backend.ref}`, 0);
+            this.rrCount.set(`${AOR_SCHEME.BACKEND}${backend.ref}`, 0);
         }
         else {
-            this.rrCount.set(`backend:${backend.ref}`, nextPosition + 1);
+            this.rrCount.set(`${AOR_SCHEME.BACKEND}${backend.ref}`, nextPosition + 1);
         }
         return result;
     }
     // Backend with session affinity does not support round-robin
+    // eslint-disable-next-line require-jsdoc
     nextWithAffinity(routes, sessionAffinityRef) {
         let route = this.affinityStore.get(sessionAffinityRef);
         if (route) {

package/dist/memory_store.d.ts

@@ -1,13 +1,26 @@
 import { Route } from "@routr/common";
 import { ILocatorStore } from "./types";
+/**
+ * In-memory store for the locator service.
+ */
 export default class MemoryStore implements ILocatorStore {
     private collections;
     private cleanupCount;
     private maxCyclesBeforeCleanup;
+    /**
+     * Creates a new in-memory store.
+     *
+     * @param {number} maxCyclesBeforeCleanup - Maximum number of cycles before cleanup
+     */
     constructor(maxCyclesBeforeCleanup?: number);
+    /** @inheritdoc */
     put(key: string, route: Route): Promise<void>;
+    /** @inheritdoc */
     get(key: string): Promise<Route[]>;
+    /** @inheritdoc */
     delete(key: string): Promise<void>;
+    /** @inheritdoc */
     size(): number;
+    /** @inheritdoc */
     cleanup(): void;
 }

package/dist/memory_store.js

@@ -2,17 +2,26 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("./utils");
 const MAX_CYCLES_BEFORE_CLEANUP = 10000;
+/**
+ * In-memory store for the locator service.
+ */
 class MemoryStore {
+    /**
+     * Creates a new in-memory store.
+     *
+     * @param {number} maxCyclesBeforeCleanup - Maximum number of cycles before cleanup
+     */
     constructor(maxCyclesBeforeCleanup = MAX_CYCLES_BEFORE_CLEANUP) {
         this.collections = new Map();
         this.maxCyclesBeforeCleanup = maxCyclesBeforeCleanup;
     }
+    /** @inheritdoc */
     put(key, route) {
-        const routes = [...this.collections.get(key) || []];
+        const routes = [...(this.collections.get(key) || [])];
         // Avoids duplicate or expired routes
         const filteredRoutes = routes
             .filter(utils_1.expiredFilter)
-            .filter(r => (0, utils_1.duplicateFilter)(r, route));
+            .filter((r) => (0, utils_1.duplicateFilter)(r, route));
         if (filteredRoutes.length > 0) {
             this.collections.set(key, [route, ...filteredRoutes]);
         }
@@ -21,6 +30,7 @@ class MemoryStore {
         }
         return;
     }
+    /** @inheritdoc */
     get(key) {
         // Cleanup every so often to avoid memory build up
         this.cleanupCount++;
@@ -30,13 +40,16 @@ class MemoryStore {
         }
         return Promise.resolve((this.collections.get(key) || []).filter(utils_1.expiredFilter));
     }
+    /** @inheritdoc */
     delete(key) {
         this.collections.delete(key);
         return;
     }
+    /** @inheritdoc */
     size() {
         return this.collections.size;
     }
+    /** @inheritdoc */
     cleanup() {
         // Remove any expired route from collection
         this.collections.forEach((routes, key) => {

package/dist/redis_store.d.ts

@@ -1,9 +1,21 @@
 import { Route } from "@routr/common";
-import { ILocatorStore, RedisStoreConfig } from "./types";
+import { ILocatorStore } from "./types";
+import { Redis } from "@routr/common";
+/**
+ * Redis store for the locator service.
+ */
 export default class RedisStore implements ILocatorStore {
     client: any;
-    constructor(config?: RedisStoreConfig);
+    /**
+     * Creates a new redis store.
+     *
+     * @param {Redis.RedisStoreConfig} config - Optional store config
+     */
+    constructor(config?: Redis.RedisStoreConfig);
+    /** @inheritdoc */
     put(key: string, route: Route): Promise<void>;
+    /** @inheritdoc */
     get(key: string): Promise<Route[]>;
+    /** @inheritdoc */
     delete(key: string): Promise<void>;
 }

package/dist/redis_store.js

@@ -15,19 +15,28 @@ var __asyncValues = (this && this.__asyncValues) || function (o) {
     function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
     function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 const redis_1 = require("redis");
-const utils_1 = require("./utils");
-const logger_1 = __importDefault(require("@fonoster/logger"));
+const common_1 = require("@routr/common");
+const logger_1 = require("@fonoster/logger");
+const logger = (0, logger_1.getLogger)({ service: "location", filePath: __filename });
+/**
+ * Redis store for the locator service.
+ */
 class RedisStore {
+    /**
+     * Creates a new redis store.
+     *
+     * @param {Redis.RedisStoreConfig} config - Optional store config
+     */
     constructor(config) {
-        this.client = config ? (0, redis_1.createClient)({ url: (0, utils_1.getUrlString)(config) }) : (0, redis_1.createClient)();
+        this.client = config
+            ? (0, redis_1.createClient)({ url: common_1.Redis.getRedisUrlFromConfig(config) })
+            : (0, redis_1.createClient)();
         this.client.connect();
-        this.client.on('error', (err) => logger_1.default.error('redis client error: ', err));
+        this.client.on("error", (err) => logger.error("redis client error: ", err));
     }
+    /** @inheritdoc */
     put(key, route) {
         return __awaiter(this, void 0, void 0, function* () {
             // Formatted the key to ensure it is unique
@@ -37,11 +46,13 @@ class RedisStore {
             return;
         });
     }
+    /** @inheritdoc */
     get(key) {
         var e_1, _a;
         return __awaiter(this, void 0, void 0, function* () {
             const routes = [];
             try {
+                // eslint-disable-next-line no-loops/no-loops
                 for (var _b = __asyncValues(yield this.client.scanIterator({
                     CURSOR: 0,
                     MATCH: `${key}:*`
@@ -60,10 +71,12 @@ class RedisStore {
             return routes;
         });
     }
+    /** @inheritdoc */
     delete(key) {
         var e_2, _a;
         return __awaiter(this, void 0, void 0, function* () {
             try {
+                // eslint-disable-next-line no-loops/no-loops
                 for (var _b = __asyncValues(yield this.client.scanIterator({
                     CURSOR: 0,
                     MATCH: `${key}:*`

package/dist/runner.js

@@ -22,14 +22,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+// eslint-disable-next-line @typescript-eslint/no-var-requires
 require("./tracer").init("dispatcher");
-const logger_1 = __importDefault(require("@fonoster/logger"));
 const service_1 = __importDefault(require("./service"));
 const get_config_1 = require("./config/get_config");
+const common_1 = require("@routr/common");
+const logger_1 = require("@fonoster/logger");
+const logger = (0, logger_1.getLogger)({ service: "location", filePath: __filename });
+common_1.Assertions.assertEnvsAreSet(["CONFIG_PATH"]);
 const result = (0, get_config_1.getConfig)(process.env.CONFIG_PATH);
-if (result._tag === 'Right') {
+if (result._tag === "Right") {
     (0, service_1.default)(result.right);
 }
 else {
-    logger_1.default.error(result.left);
+    logger.error(result.left);
 }

package/dist/service.d.ts

@@ -1,2 +1,7 @@
 import { LocationConfig } from "./types";
+/**
+ * Creates a new locator service.
+ *
+ * @param {LocationConfig} config - Service configuration
+ */
 export default function LocationService(config: LocationConfig): void;

package/dist/service.js

@@ -27,8 +27,14 @@ const utils_1 = require("./utils");
 const location_1 = __importDefault(require("./location"));
 const memory_store_1 = __importDefault(require("./memory_store"));
 const redis_store_1 = __importDefault(require("./redis_store"));
-const logger_1 = __importDefault(require("@fonoster/logger"));
+const logger_1 = require("@fonoster/logger");
+const logger = (0, logger_1.getLogger)({ service: "location", filePath: __filename });
 const allowedParameters = ["host", "port", "username", "password", "secure"];
+/**
+ * Creates a new locator service.
+ *
+ * @param {LocationConfig} config - Service configuration
+ */
 function LocationService(config) {
     const { bindAddr, cache } = config;
     let store;
@@ -39,8 +45,8 @@ function LocationService(config) {
         store = new memory_store_1.default();
     }
     const backends = new Map();
-    config.backends.forEach(b => backends.set(`backend:${b.ref}`, b));
+    config.backends.forEach((b) => backends.set(`backend:${b.ref}`, b));
     (0, common_1.createService)((0, utils_1.getServiceInfo)(bindAddr, new location_1.default(store, backends)));
-    logger_1.default.info(`using ${cache.provider} as cache provider`);
+    logger.info(`using ${cache.provider} as cache provider`);
 }
 exports.default = LocationService;

package/dist/tracer.d.ts

@@ -1 +1,7 @@
+/**
+ * This function registers the instrumentations for the service.
+ *
+ * @param {string} serviceName - The name of the service.
+ * @return {Tracer} The tracer object.
+ */
 export declare function init(serviceName: string): import("@opentelemetry/api").Tracer;

package/dist/tracer.js

@@ -30,20 +30,24 @@ const semantic_conventions_1 = require("@opentelemetry/semantic-conventions");
 const sdk_trace_base_1 = require("@opentelemetry/sdk-trace-base");
 const exporter_jaeger_1 = require("@opentelemetry/exporter-jaeger");
 const instrumentation_grpc_1 = require("@opentelemetry/instrumentation-grpc");
+/**
+ * This function registers the instrumentations for the service.
+ *
+ * @param {string} serviceName - The name of the service.
+ * @return {Tracer} The tracer object.
+ */
 function init(serviceName) {
     const provider = new sdk_trace_node_1.NodeTracerProvider({
         resource: new resources_1.Resource({
-            [semantic_conventions_1.SemanticResourceAttributes.SERVICE_NAME]: serviceName,
-        }),
+            [semantic_conventions_1.SemanticResourceAttributes.SERVICE_NAME]: serviceName
+        })
     });
     const exporter = new exporter_jaeger_1.JaegerExporter();
     provider.addSpanProcessor(new sdk_trace_base_1.SimpleSpanProcessor(exporter));
     provider.register();
     (0, instrumentation_1.registerInstrumentations)({
-        instrumentations: [
-            new instrumentation_grpc_1.GrpcInstrumentation(),
-        ],
+        instrumentations: [new instrumentation_grpc_1.GrpcInstrumentation()]
     });
-    return api_1.default.trace.getTracer('routr-tracer');
+    return api_1.default.trace.getTracer("routr-tracer");
 }
 exports.init = init;

package/dist/types.d.ts

@@ -35,17 +35,14 @@ export interface RemoveRoutesRequest {
 export interface Backend {
     ref: string;
     balancingAlgorithm?: LB_ALGORITHM;
-    sessionAffinity?: {
-        enabled: boolean;
-        ref: string;
-    };
+    withSessionAffinity?: boolean;
 }
 export interface LocationConfig {
     bindAddr: string;
     backends?: Backend[];
     cache?: {
         provider: CACHE_PROVIDER;
-        parameters: string;
+        parameters?: string;
     };
 }
 export interface RedisStoreConfig {

package/dist/utils.d.ts

@@ -1,12 +1,9 @@
-import { Route } from "@routr/common";
-import { ServiceInfo } from "@routr/common";
-import { Backend, ILocationService, RedisStoreConfig } from "./types";
+import { Route, ServiceInfo } from "@routr/common";
+import { ILocationService } from "./types";
 export declare const expiredFilter: (r: Route) => boolean;
 export declare const duplicateFilter: (r1: Route, r2: Route) => boolean;
 export declare const mergeKeyValue: (map: Map<string, string>) => string[];
 export declare const compareArrays: (arr: string[], target: string[]) => boolean;
 export declare const filterOnlyMatchingLabels: (requestLabels: Map<string, string>) => (route: Route) => boolean;
-export declare const hasAffinitySession: (backend: Backend) => boolean;
-export declare function getServiceInfo(bindAddr: string, locator: ILocationService): ServiceInfo;
+export declare const getServiceInfo: (bindAddr: string, locator: ILocationService) => ServiceInfo;
 export declare const configFromString: (params: string, allowedKeys: string[]) => Record<string, string | boolean>;
-export declare const getUrlString: (config: RedisStoreConfig) => string;

package/dist/utils.js

@@ -9,27 +9,44 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getUrlString = exports.configFromString = exports.getServiceInfo = exports.hasAffinitySession = exports.filterOnlyMatchingLabels = exports.compareArrays = exports.mergeKeyValue = exports.duplicateFilter = exports.expiredFilter = void 0;
+exports.configFromString = exports.getServiceInfo = exports.filterOnlyMatchingLabels = exports.compareArrays = exports.mergeKeyValue = exports.duplicateFilter = exports.expiredFilter = 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 common_1 = require("@routr/common");
 const errors_1 = require("./errors");
-const expiredFilter = (r) => (r.expires - (Date.now() - r.registeredOn) / 1000) > 0;
+const expiredFilter = (r) => r.expires - (Date.now() - r.registeredOn) / 1000 > 0;
 exports.expiredFilter = expiredFilter;
 const duplicateFilter = (r1, r2) => !(r1.host === r2.host && r1.port === r2.port);
 exports.duplicateFilter = duplicateFilter;
-const mergeKeyValue = (map) => Array.from(map).map(l => l[0] + l[1]);
+const mergeKeyValue = (map) => Array.from(map).map((l) => l[0] + l[1]);
 exports.mergeKeyValue = mergeKeyValue;
-const compareArrays = (arr, target) => target.every(v => arr.includes(v)) && arr.length === target.length;
+const compareArrays = (arr, target) => target.every((v) => arr.includes(v)) && arr.length === target.length;
 exports.compareArrays = compareArrays;
 const filterOnlyMatchingLabels = (requestLabels) => (route) => route.labels
     ? (0, exports.compareArrays)((0, exports.mergeKeyValue)(requestLabels), (0, exports.mergeKeyValue)(route.labels))
     : false;
 exports.filterOnlyMatchingLabels = filterOnlyMatchingLabels;
-const hasAffinitySession = (backend) => { var _a; return (_a = backend === null || backend === void 0 ? void 0 : backend.sessionAffinity) === null || _a === void 0 ? void 0 : _a.enabled; };
-exports.hasAffinitySession = hasAffinitySession;
-function getServiceInfo(bindAddr, locator) {
+const getServiceInfo = (bindAddr, locator) => {
     return {
         name: "location",
         bindAddr,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         service: common_1.LOCATION_OBJECT_PROTO.Location.service,
         handlers: {
             addRoute: (call, callback) => {
@@ -41,7 +58,7 @@ function getServiceInfo(bindAddr, locator) {
                     callback(e, null);
                 }
             },
-            findRoutes: (call, callback) => __awaiter(this, void 0, void 0, function* () {
+            findRoutes: (call, callback) => __awaiter(void 0, void 0, void 0, function* () {
                 try {
                     const routes = yield locator.findRoutes(call.request);
                     if (routes.length === 0)
@@ -54,7 +71,7 @@ function getServiceInfo(bindAddr, locator) {
                     callback(e, null);
                 }
             }),
-            removeRoutes: (call, callback) => __awaiter(this, void 0, void 0, function* () {
+            removeRoutes: (call, callback) => __awaiter(void 0, void 0, void 0, function* () {
                 try {
                     callback(null, {
                         routes: yield locator.findRoutes(call.request)
@@ -66,18 +83,18 @@ function getServiceInfo(bindAddr, locator) {
             })
         }
     };
-}
+};
 exports.getServiceInfo = getServiceInfo;
 const configFromString = (params, allowedKeys) => {
     if (params.length === 0)
         return {};
     const parameters = {};
-    params.split(',').forEach(par => {
+    params.split(",").forEach((par) => {
         try {
-            const key = par.split('=')[0];
-            const value = par.split('=')[1];
+            const key = par.split("=")[0];
+            const value = par.split("=")[1];
             if (allowedKeys.indexOf(key) === -1) {
-                throw `invalid parameter: ${key}`;
+                throw new Error(`invalid parameter: ${key}`);
             }
             else {
                 parameters[key] = value === "true" ? true : value;
@@ -90,10 +107,3 @@ const configFromString = (params, allowedKeys) => {
     return parameters;
 };
 exports.configFromString = configFromString;
-const getUrlString = (config) => {
-    return `redis${config.secure ? 's' : ''}`
-        + `://${config.username ? config.username : ''}`
-        + `${config.password ? ':' + config.password + '@' : ''}`
-        + `${config.host}:${config.port}`;
-};
-exports.getUrlString = getUrlString;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@routr/location",
-  "version": "2.0.5-alpha.15",
+  "version": "2.0.5-alpha.17",
   "description": "Creates and maintains a list of routes to all registered endpoints",
   "author": "Pedro Sanders <psanders@fonoster.com>",
   "homepage": "https://github.com/fonoster/routr#readme",
@@ -25,6 +25,7 @@
     "access": "public"
   },
   "dependencies": {
+    "@fonoster/logger": "0.3.17-alpha.2",
     "@grpc/grpc-js": "^1.5.9",
     "@opentelemetry/api": "^1.0.4",
     "@opentelemetry/exporter-jaeger": "^1.0.4",
@@ -34,8 +35,8 @@
     "@opentelemetry/sdk-trace-base": "^1.0.4",
     "@opentelemetry/sdk-trace-node": "^1.0.4",
     "@opentelemetry/semantic-conventions": "^1.0.4",
-    "@routr/common": "^2.0.5-alpha.15",
-    "@routr/processor": "^2.0.5-alpha.15",
+    "@routr/common": "^2.0.5-alpha.17",
+    "@routr/processor": "^2.0.5-alpha.17",
     "ajv": "^6.12.6",
     "fp-ts": "^2.11.8",
     "redis": "^4.0.4"
@@ -47,5 +48,5 @@
   "bugs": {
     "url": "https://github.com/fonoster/routr/issues"
   },
-  "gitHead": "3e08aa86f1596252546134bff677d17d7dd54ced"
+  "gitHead": "724e4e690f3cdd960ad6660b602a84876fc444dc"
 }