@routr/common 2.0.8-alpha.9 → 2.0.13

package/dist/assertions.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.assertEnvsAreSet = void 0;
 /*
- * Copyright (C) 2022 by Fonoster Inc (https://fonoster.com)
+ * Copyright (C) 2023 by Fonoster Inc (https://fonoster.com)
  * http://github.com/fonoster/routr
  *
  * This file is part of Routr
@@ -29,7 +29,7 @@ const logger = (0, logger_1.getLogger)({ service: "common", filePath: __filename
 function assertEnvsAreSet(variables) {
     variables.forEach((variable) => {
         if (!(variable in process.env)) {
-            logger.error(`The environment variable ${variable} is required but was not found`);
+            logger.error(`the environment variable ${variable} is required but was not found`);
             process.exit(1);
         }
     });

package/dist/auth.d.ts

@@ -1,10 +1,10 @@
-import { AuthChallengeRequest, AuthChallengeResponse } from "./types";
+import { AuthChallengeRequest, AuthChallengeResponse, ResponseType } from "./types";
 export declare const generateNonce: (algorithm?: string) => string;
 export declare const buildAuthChallenge: (request: AuthChallengeRequest) => {
     realm: string;
-    scheme: string;
-    algorithm: string;
-    qop: string;
+    scheme: "Digest";
+    algorithm: "MD5";
+    qop: import("./types").Qop;
     opaque: string;
     stale: boolean;
     nonce: string;
@@ -25,7 +25,8 @@ export declare const createUnauthorizedResponse: (realm: string, params?: {
     algorithm: string;
 }) => {
     message: {
-        responseType: number;
+        responseType: ResponseType;
+        reasonPhrase: string;
         wwwAuthenticate: {
             scheme: string;
             realm: string;
@@ -37,18 +38,24 @@ export declare const createUnauthorizedResponse: (realm: string, params?: {
         };
     };
 };
-export declare const createUnauthorizedResponseWithoutChallenge: () => {
+export declare const createUnauthorizedResponseWithoutChallenge: (metadata?: Record<string, string>) => {
+    metadata: Record<string, string>;
     message: {
-        responseType: number;
+        responseType: ResponseType;
+        reasonPhrase: string;
     };
 };
-export declare const createServerInternalErrorResponse: () => {
+export declare const createServerInternalErrorResponse: (metadata?: Record<string, string>) => {
+    metadata: Record<string, string>;
     message: {
-        responseType: number;
+        responseType: ResponseType;
+        reasonPhrase: string;
     };
 };
-export declare const createForbideenResponse: () => {
+export declare const createForbideenResponse: (metadata?: Record<string, string>) => {
+    metadata: Record<string, string>;
     message: {
-        responseType: number;
+        responseType: ResponseType;
+        reasonPhrase: string;
     };
 };

package/dist/auth.js

@@ -4,6 +4,25 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createForbideenResponse = exports.createServerInternalErrorResponse = exports.createUnauthorizedResponseWithoutChallenge = exports.createUnauthorizedResponse = exports.getCredentials = exports.calculateAuthResponse = exports.buildAuthChallenge = exports.generateNonce = void 0;
+/*
+ * Copyright (C) 2023 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 types_1 = require("./types");
 const crypto_1 = __importDefault(require("crypto"));
 const DEFAULT_ALGORITHM = "MD5";
 const md5hex = (str, algorithm = DEFAULT_ALGORITHM) => crypto_1.default.createHash(algorithm).update(str).digest("hex");
@@ -37,11 +56,11 @@ const calculateAuthResponse = (res, credentials) => {
 exports.calculateAuthResponse = calculateAuthResponse;
 const getCredentials = (username, users) => users.find((user) => user.username === username);
 exports.getCredentials = getCredentials;
-const createUnauthorizedResponse = (realm, params = { qop: "auth", algorithm: "MD5" }) => {
+const createUnauthorizedResponse = (realm, params = { qop: "auth", algorithm: DEFAULT_ALGORITHM }) => {
     return {
         message: {
-            // Unauthorized Code
-            responseType: 17,
+            responseType: types_1.ResponseType.UNAUTHORIZED,
+            reasonPhrase: "Unauthorized",
             wwwAuthenticate: {
                 scheme: "Digest",
                 realm: realm,
@@ -55,29 +74,32 @@ const createUnauthorizedResponse = (realm, params = { qop: "auth", algorithm: "M
     };
 };
 exports.createUnauthorizedResponse = createUnauthorizedResponse;
-const createUnauthorizedResponseWithoutChallenge = () => {
+const createUnauthorizedResponseWithoutChallenge = (metadata) => {
     return {
+        metadata,
         message: {
-            // Unauthorized Code
-            responseType: 17
+            responseType: types_1.ResponseType.UNAUTHORIZED,
+            reasonPhrase: "Unauthorized"
         }
     };
 };
 exports.createUnauthorizedResponseWithoutChallenge = createUnauthorizedResponseWithoutChallenge;
-const createServerInternalErrorResponse = () => {
+const createServerInternalErrorResponse = (metadata) => {
     return {
+        metadata,
         message: {
-            // Unauthorized Code
-            responseType: 46
+            responseType: types_1.ResponseType.SERVER_INTERNAL_ERROR,
+            reasonPhrase: "Server Internal Error"
         }
     };
 };
 exports.createServerInternalErrorResponse = createServerInternalErrorResponse;
-const createForbideenResponse = () => {
+const createForbideenResponse = (metadata) => {
     return {
+        metadata,
         message: {
-            // Forbideen Code
-            responseType: 19
+            responseType: types_1.ResponseType.FORBIDDEN,
+            reasonPhrase: "Forbidden"
         }
     };
 };

package/dist/connect/api/client.d.ts

@@ -0,0 +1,3 @@
+import { APIClient, DataAPIOptions, ServiceAPI, ServiceAPIOptions } from "./types";
+export declare function apiClient(options: DataAPIOptions): APIClient;
+export declare function serviceAPI<R>(options: ServiceAPIOptions): ServiceAPI<R>;

package/dist/connect/api/client.js

@@ -0,0 +1,158 @@
+"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.serviceAPI = exports.apiClient = void 0;
+/*
+ * Copyright (C) 2023 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.
+ */
+/* eslint-disable require-jsdoc */
+const grpc = __importStar(require("@grpc/grpc-js"));
+const pb_util_1 = require("pb-util");
+const errors_1 = require("../../errors");
+const client_1 = require("../client");
+const types_1 = require("../types");
+function fire(err, apiAddr) {
+    if (err.code === grpc.status.UNAVAILABLE) {
+        return new errors_1.ServiceUnavailableError(apiAddr);
+    }
+    return err;
+}
+function apiClient(options) {
+    return {
+        agents: serviceAPI(Object.assign({ kind: types_1.Kind.AGENT }, options)),
+        domains: serviceAPI(Object.assign({ kind: types_1.Kind.DOMAIN }, options)),
+        trunks: serviceAPI(Object.assign({ kind: types_1.Kind.TRUNK }, options)),
+        credentials: serviceAPI(Object.assign({ kind: types_1.Kind.CREDENTIALS }, options)),
+        acl: serviceAPI(Object.assign({ kind: types_1.Kind.ACL }, options)),
+        peers: serviceAPI(Object.assign({ kind: types_1.Kind.PEER }, options)),
+        numbers: serviceAPI(Object.assign({ kind: types_1.Kind.NUMBER }, options))
+    };
+}
+exports.apiClient = apiClient;
+function serviceAPI(options) {
+    const { kind, apiAddr, credentials, metadata } = options;
+    // Workaround for issue not allowing to pass metadata to grpc-js
+    const meta = new grpc.Metadata();
+    if (metadata) {
+        Object.keys(metadata.toJSON()).forEach((key) => {
+            meta.set(key, metadata.getMap()[key]);
+        });
+    }
+    const client = (0, client_1.createConnectClient)({
+        kind,
+        apiAddr,
+        credentials: credentials !== null && credentials !== void 0 ? credentials : grpc.credentials.createInsecure()
+    });
+    return {
+        create: (request) => new Promise((resolve, reject) => {
+            if (request.extended) {
+                request.extended = pb_util_1.struct.encode(request.extended);
+            }
+            client.create(request, meta, (err, response) => {
+                if (err) {
+                    return reject(fire(err, apiAddr));
+                }
+                if (response.extended) {
+                    response.extended = pb_util_1.struct.decode(response.extended);
+                }
+                resolve(response);
+            });
+        }),
+        update: (request) => new Promise((resolve, reject) => {
+            if (request.extended) {
+                request.extended = pb_util_1.struct.encode(request.extended);
+            }
+            client.update(request, meta, (err, response) => {
+                if (err) {
+                    return reject(fire(err, apiAddr));
+                }
+                if (response.extended) {
+                    response.extended = pb_util_1.struct.decode(response.extended);
+                }
+                resolve(response);
+            });
+        }),
+        get: (ref) => new Promise((resolve, reject) => {
+            client.get({ ref }, meta, (err, response) => {
+                if (err) {
+                    return reject(fire(err, apiAddr));
+                }
+                if (response.extended) {
+                    response.extended = pb_util_1.struct.decode(response.extended);
+                }
+                resolve(response);
+            });
+        }),
+        list: (request) => new Promise((resolve, reject) => {
+            client.list(request, meta, (err, response) => {
+                var _a;
+                if (err) {
+                    return reject(fire(err, apiAddr));
+                }
+                response.items.forEach((item) => {
+                    if (item.extended) {
+                        item.extended = pb_util_1.struct.decode(item.extended);
+                    }
+                });
+                resolve({
+                    items: (_a = response === null || response === void 0 ? void 0 : response.items) !== null && _a !== void 0 ? _a : [],
+                    nextPageToken: response.nextPageToken
+                });
+            });
+        }),
+        findBy: (request) => new Promise((resolve, reject) => {
+            client.findBy(request, meta, (err, response) => {
+                if (err) {
+                    return reject(fire(err, apiAddr));
+                }
+                response.items.forEach((item) => {
+                    if (item.extended) {
+                        item.extended = pb_util_1.struct.decode(item.extended);
+                    }
+                });
+                resolve(response);
+            });
+        }),
+        del: (ref) => new Promise((resolve, reject) => {
+            client.delete({ ref }, meta, (err) => err ? reject(fire(err, apiAddr)) : resolve());
+        })
+    };
+}
+exports.serviceAPI = serviceAPI;

package/dist/connect/api/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./client";
+export * from "./types";

package/dist/connect/api/index.js

@@ -0,0 +1,36 @@
+"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 __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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/*
+ * Copyright (C) 2023 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster
+ *
+ * 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.
+ */
+__exportStar(require("./client"), exports);
+__exportStar(require("./types"), exports);

package/dist/connect/api/types.d.ts

@@ -0,0 +1,51 @@
+import * as grpc from "@grpc/grpc-js";
+import { JsonObject } from "pb-util/build";
+import { AccessControlList, Agent, Credentials, Domain, INumber, Kind, Peer, Trunk } from "../types";
+export interface DataAPIOptions {
+    apiAddr: string;
+    credentials?: grpc.ChannelCredentials;
+    metadata?: grpc.Metadata;
+}
+export interface ServiceAPIOptions {
+    apiAddr: string;
+    kind: Kind;
+    credentials?: grpc.ChannelCredentials;
+    metadata?: grpc.Metadata;
+}
+export interface FindByRequest {
+    fieldName: string;
+    fieldValue: string | boolean | number;
+}
+export interface ListRequest {
+    pageSize: number;
+    pageToken: string;
+}
+export interface ListResponse<R> {
+    items: R[];
+    nextPageToken: string;
+}
+export interface FindByResponse<R> {
+    items: R[];
+}
+export type APIClient = {
+    agents: ServiceAPI<Agent>;
+    domains: ServiceAPI<Domain>;
+    trunks: ServiceAPI<Trunk>;
+    credentials: ServiceAPI<Credentials>;
+    acl: ServiceAPI<AccessControlList>;
+    peers: ServiceAPI<Peer>;
+    numbers: ServiceAPI<INumber>;
+};
+export type ServiceAPI<R extends {
+    extended?: JsonObject;
+}> = {
+    create: (request: unknown) => Promise<R>;
+    update: (request: unknown) => Promise<R>;
+    get: (ref: string) => Promise<R>;
+    del: (ref: string) => Promise<void>;
+    list: (request: {
+        pageSize: number;
+        pageToken: string;
+    }) => Promise<ListResponse<R>>;
+    findBy: (request: FindByRequest) => Promise<FindByResponse<R>>;
+};

package/dist/connect/api/types.js

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

package/dist/connect/assertions.d.ts

@@ -0,0 +1,37 @@
+import { LoadBalancingAlgorithm } from "../types";
+import { TrunkURI } from "./types";
+export declare const hasValidHeadersOrThrow: (headers: {
+    name: string;
+    value: string;
+}[]) => void;
+export declare const isValidBalancingAlgorithmOrThrow: (aor: string, algorithm: LoadBalancingAlgorithm) => void;
+export declare const hasACLRulesOrThrow: (acl: {
+    deny: string[];
+    allow: string[];
+}) => void;
+export declare const hasValidACLRulesOrThrow: (acl: {
+    deny: string[];
+    allow: string[];
+}) => void;
+export declare const hasRefenceOrThrow: (ref: string) => void;
+export declare const hasNameOrThrow: (name: string) => void;
+export declare const isValidNameOrThrow: (name: string) => void;
+export declare const hasUsernameOrThrow: (username: string) => void;
+export declare const isValidUsernameOrThrow: (username: string) => void;
+export declare const hasPasswordOrThrow: (password: string) => void;
+export declare const hasDomainUriOrThrow: (domainUri: string) => void;
+export declare const isValidDomainUriOrThrow: (domainUri: string) => void;
+export declare const hasTelUrlOrThrow: (telUrl: string) => void;
+export declare const isValidSessionAffinityHeaderOrThrow: (sessionAffinityHeader: string) => void;
+export declare const hasCityOrThrow: (city: string) => void;
+export declare const hasCountryOrThrow: (country: string) => void;
+export declare const hasCountryISOCodeOrThrow: (countryIsoCode: string) => void;
+export declare const hasInboundUriOrThrow: (inboundUri: string) => void;
+export declare const isValidInboundUriOrThrow: (inboundUri: string) => void;
+export declare const hasAOROrThrow: (aor: string) => void;
+export declare const isValidAOROrThrow: (aor: string) => void;
+export declare const hasAORLinkOrThrow: (aorLink: string) => void;
+export declare const isValidAORLinkOrThrow: (aorLink: string) => void;
+export declare const isValidContactAddressOrThrow: (contactAddress: string) => void;
+export declare const isValidE164OrThrow: (e164Number: string, countryISOCode: string, validateMobilePrefix: boolean) => void;
+export declare const hasValidOutboundUrisOrThrow: (outboundUris: TrunkURI[]) => void;

package/dist/connect/assertions.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasValidOutboundUrisOrThrow = exports.isValidE164OrThrow = exports.isValidContactAddressOrThrow = exports.isValidAORLinkOrThrow = exports.hasAORLinkOrThrow = exports.isValidAOROrThrow = exports.hasAOROrThrow = exports.isValidInboundUriOrThrow = exports.hasInboundUriOrThrow = exports.hasCountryISOCodeOrThrow = exports.hasCountryOrThrow = exports.hasCityOrThrow = exports.isValidSessionAffinityHeaderOrThrow = exports.hasTelUrlOrThrow = exports.isValidDomainUriOrThrow = exports.hasDomainUriOrThrow = exports.hasPasswordOrThrow = exports.isValidUsernameOrThrow = exports.hasUsernameOrThrow = exports.isValidNameOrThrow = exports.hasNameOrThrow = exports.hasRefenceOrThrow = exports.hasValidACLRulesOrThrow = exports.hasACLRulesOrThrow = exports.isValidBalancingAlgorithmOrThrow = exports.hasValidHeadersOrThrow = void 0;
+/*
+ * Copyright (C) 2023 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster
+ *
+ * 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 validations_1 = require("./validations");
+const validOrThrow = (method, value) => {
+    const R = method(value);
+    if (R instanceof errors_1.BadRequestError) {
+        throw R;
+    }
+};
+const hasValidHeadersOrThrow = (headers) => {
+    const E = (0, validations_1.hasValidHeaders)(headers);
+    if (E instanceof errors_1.BadRequestError) {
+        throw E;
+    }
+};
+exports.hasValidHeadersOrThrow = hasValidHeadersOrThrow;
+const isValidBalancingAlgorithmOrThrow = (aor, algorithm) => {
+    const E = (0, validations_1.isValidBalancingAlgorithm)(aor, algorithm);
+    if (E instanceof errors_1.BadRequestError) {
+        throw E;
+    }
+};
+exports.isValidBalancingAlgorithmOrThrow = isValidBalancingAlgorithmOrThrow;
+const hasACLRulesOrThrow = (acl) => validOrThrow(validations_1.hasACLRules, acl);
+exports.hasACLRulesOrThrow = hasACLRulesOrThrow;
+const hasValidACLRulesOrThrow = (acl) => validOrThrow(validations_1.hasValidACLRules, acl);
+exports.hasValidACLRulesOrThrow = hasValidACLRulesOrThrow;
+const hasRefenceOrThrow = (ref) => validOrThrow(validations_1.hasReference, ref);
+exports.hasRefenceOrThrow = hasRefenceOrThrow;
+const hasNameOrThrow = (name) => validOrThrow(validations_1.hasName, name);
+exports.hasNameOrThrow = hasNameOrThrow;
+const isValidNameOrThrow = (name) => validOrThrow(validations_1.isValidName, name);
+exports.isValidNameOrThrow = isValidNameOrThrow;
+const hasUsernameOrThrow = (username) => validOrThrow(validations_1.hasUsername, username);
+exports.hasUsernameOrThrow = hasUsernameOrThrow;
+const isValidUsernameOrThrow = (username) => validOrThrow(validations_1.isValidUsername, username);
+exports.isValidUsernameOrThrow = isValidUsernameOrThrow;
+const hasPasswordOrThrow = (password) => validOrThrow(validations_1.hasPassword, password);
+exports.hasPasswordOrThrow = hasPasswordOrThrow;
+const hasDomainUriOrThrow = (domainUri) => validOrThrow(validations_1.hasDomainUri, domainUri);
+exports.hasDomainUriOrThrow = hasDomainUriOrThrow;
+const isValidDomainUriOrThrow = (domainUri) => validOrThrow(validations_1.isValidDomainUri, domainUri);
+exports.isValidDomainUriOrThrow = isValidDomainUriOrThrow;
+const hasTelUrlOrThrow = (telUrl) => validOrThrow(validations_1.hasTelUrl, telUrl);
+exports.hasTelUrlOrThrow = hasTelUrlOrThrow;
+const isValidSessionAffinityHeaderOrThrow = (sessionAffinityHeader) => validOrThrow(validations_1.isValidSessionAffinityHeader, sessionAffinityHeader);
+exports.isValidSessionAffinityHeaderOrThrow = isValidSessionAffinityHeaderOrThrow;
+const hasCityOrThrow = (city) => validOrThrow(validations_1.hasCity, city);
+exports.hasCityOrThrow = hasCityOrThrow;
+const hasCountryOrThrow = (country) => validOrThrow(validations_1.hasCountry, country);
+exports.hasCountryOrThrow = hasCountryOrThrow;
+const hasCountryISOCodeOrThrow = (countryIsoCode) => validOrThrow(validations_1.hasCountryISOCode, countryIsoCode);
+exports.hasCountryISOCodeOrThrow = hasCountryISOCodeOrThrow;
+const hasInboundUriOrThrow = (inboundUri) => validOrThrow(validations_1.hasInboundUri, inboundUri);
+exports.hasInboundUriOrThrow = hasInboundUriOrThrow;
+const isValidInboundUriOrThrow = (inboundUri) => validOrThrow(validations_1.isValidInboundUri, inboundUri);
+exports.isValidInboundUriOrThrow = isValidInboundUriOrThrow;
+const hasAOROrThrow = (aor) => validOrThrow(validations_1.hasAOR, aor);
+exports.hasAOROrThrow = hasAOROrThrow;
+const isValidAOROrThrow = (aor) => validOrThrow(validations_1.isValidAOR, aor);
+exports.isValidAOROrThrow = isValidAOROrThrow;
+const hasAORLinkOrThrow = (aorLink) => validOrThrow(validations_1.hasAORLink, aorLink);
+exports.hasAORLinkOrThrow = hasAORLinkOrThrow;
+const isValidAORLinkOrThrow = (aorLink) => validOrThrow(validations_1.isValidAORLink, aorLink);
+exports.isValidAORLinkOrThrow = isValidAORLinkOrThrow;
+const isValidContactAddressOrThrow = (contactAddress) => validOrThrow(validations_1.isValidContactAddress, contactAddress);
+exports.isValidContactAddressOrThrow = isValidContactAddressOrThrow;
+const isValidE164OrThrow = (e164Number, countryISOCode, validateMobilePrefix) => {
+    const R = (0, validations_1.isValidE164)(e164Number, countryISOCode, validateMobilePrefix);
+    if (R instanceof errors_1.BadRequestError) {
+        throw R;
+    }
+};
+exports.isValidE164OrThrow = isValidE164OrThrow;
+const hasValidOutboundUrisOrThrow = (outboundUris) => outboundUris === null || outboundUris === void 0 ? void 0 : outboundUris.forEach((uri) => {
+    if ((0, validations_1.hasHost)(uri.host) instanceof errors_1.BadRequestError) {
+        throw (0, validations_1.hasHost)(uri.host);
+    }
+    if ((0, validations_1.isValidHost)(uri.host) instanceof errors_1.BadRequestError) {
+        throw (0, validations_1.isValidHost)(uri.host);
+    }
+    if ((0, validations_1.isValidPort)(uri.port + "") instanceof errors_1.BadRequestError) {
+        throw (0, validations_1.isValidPort)(uri.port + "");
+    }
+    if ((0, validations_1.isValidPriority)(uri.priority + "") instanceof errors_1.BadRequestError) {
+        throw (0, validations_1.isValidPriority)(uri.priority + "");
+    }
+    if ((0, validations_1.isValidWeight)(uri.weight + "") instanceof errors_1.BadRequestError) {
+        throw (0, validations_1.isValidWeight)(uri.priority + "");
+    }
+});
+exports.hasValidOutboundUrisOrThrow = hasValidOutboundUrisOrThrow;

package/dist/connect/client.d.ts

@@ -0,0 +1,8 @@
+import * as grpc from "@grpc/grpc-js";
+import { Kind, KindWithoutUnknown } from "./types";
+export declare function createConnectClient(options: {
+    kind: Kind;
+    credentials: grpc.ChannelCredentials;
+    apiAddr: string;
+}): any;
+export declare function createConnectService(kind: KindWithoutUnknown): any;

package/dist/connect/client.js

@@ -0,0 +1,94 @@
+"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.createConnectService = exports.createConnectClient = void 0;
+/*
+ * Copyright (C) 2023 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.
+ */
+/* eslint-disable require-jsdoc */
+const grpc = __importStar(require("@grpc/grpc-js"));
+const protoLoader = require("@grpc/proto-loader");
+const helper_1 = require("../helper");
+const types_1 = require("./types");
+const protoOptions = {
+    keepCase: false,
+    longs: String,
+    enums: String,
+    defaults: true,
+    oneofs: true
+};
+function getProtoPath(kind) {
+    switch (kind) {
+        case types_1.Kind.ACL:
+            return __dirname + "/protos/acl.proto";
+        case types_1.Kind.CREDENTIALS:
+            return __dirname + "/protos/credentials.proto";
+        default:
+            return __dirname + `/protos/${kind}s.proto`;
+    }
+}
+function createConnectClient(options) {
+    const def = protoLoader.loadSync(getProtoPath(options.kind), protoOptions);
+    const descriptor = grpc.loadPackageDefinition(def);
+    const base = descriptor.fonoster.routr.connect;
+    switch (options.kind) {
+        case types_1.Kind.ACL:
+            return new base.acl.v2beta1.ACLService(options.apiAddr, options.credentials);
+        case types_1.Kind.CREDENTIALS:
+            return new base.credentials.v2beta1.CredentialsService(options.apiAddr, options.credentials);
+        default:
+            return new base[options.kind + "s"].v2beta1[(0, helper_1.toPascaleCase)(options.kind) + "s"](options.apiAddr, options.credentials);
+    }
+}
+exports.createConnectClient = createConnectClient;
+function createConnectService(kind) {
+    const def = protoLoader.loadSync(getProtoPath(kind), protoOptions);
+    const descriptor = grpc.loadPackageDefinition(def);
+    const base = descriptor.fonoster.routr.connect;
+    switch (kind) {
+        case types_1.Kind.ACL:
+            return base.acl.v2beta1.ACLService.service;
+        case types_1.Kind.CREDENTIALS:
+            return base.credentials.v2beta1.CredentialsService.service;
+        default:
+            return base[kind + "s"].v2beta1[(0, helper_1.toPascaleCase)(kind) + "s"].service;
+    }
+}
+exports.createConnectService = createConnectService;