@fonoster/apiserver 0.5.5 → 0.6.1-alpha.0

package/dist/calls/createTrackCallSubscriber.js

@@ -0,0 +1,53 @@
+"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.createTrackCallSubscriber = void 0;
+/*
+ * Copyright (C) 2024 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * 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 events_1 = __importDefault(require("events"));
+const nats_1 = require("nats");
+const envs_1 = require("../envs");
+function createTrackCallSubscriber(natsUrl) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const nc = yield (0, nats_1.connect)({ servers: natsUrl });
+        return () => {
+            const events = new events_1.default();
+            const subscription = nc.subscribe(envs_1.CALLS_TRACK_CALL_SUBJECT);
+            subscription.callback = (err, msg) => {
+                if (err) {
+                    events.emit("error", err);
+                }
+                events.emit("status", msg.json());
+            };
+            return { events };
+        };
+    });
+}
+exports.createTrackCallSubscriber = createTrackCallSubscriber;

package/dist/calls/getCall.d.ts

@@ -0,0 +1,6 @@
+import { GrpcErrorMessage } from "@fonoster/common";
+import { CallDetailRecord, GetCallRequest, InfluxDBClient } from "./types";
+declare function getCall(influx: InfluxDBClient): (call: {
+    request: GetCallRequest;
+}, callback: (error: GrpcErrorMessage, response?: CallDetailRecord) => void) => Promise<void>;
+export { getCall };

package/dist/calls/getCall.js

@@ -0,0 +1,60 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCall = void 0;
+/*
+ * Copyright (C) 2024 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * 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("@fonoster/common");
+const identity_1 = require("@fonoster/identity");
+const logger_1 = require("@fonoster/logger");
+const zod_1 = require("zod");
+const createFetchSingleCall_1 = require("./createFetchSingleCall");
+const notFoundError_1 = require("../core/notFoundError");
+const logger = (0, logger_1.getLogger)({ service: "apiserver", filePath: __filename });
+const GetCallRequestSchema = zod_1.z.object({
+    ref: zod_1.z.string({ message: "Invalid call reference" })
+});
+function getCall(influx) {
+    const fetchSingleCall = (0, createFetchSingleCall_1.createFetchSingleCall)(influx);
+    return (call, callback) => __awaiter(this, void 0, void 0, function* () {
+        try {
+            const { ref } = call.request;
+            GetCallRequestSchema.parse({ ref });
+            const accessKeyId = (0, identity_1.getAccessKeyIdFromCall)(call);
+            logger.verbose("call to getCall", { accessKeyId, ref });
+            const response = yield fetchSingleCall(accessKeyId, ref);
+            if (!response) {
+                throw (0, notFoundError_1.notFoundError)(`Call not found: ${ref}`);
+            }
+            callback(null, response);
+        }
+        catch (error) {
+            (0, common_1.handleError)(error, callback);
+        }
+    });
+}
+exports.getCall = getCall;

package/dist/calls/index.d.ts

@@ -0,0 +1 @@
+export { buildService as buildCallsService } from "./buildService";

package/dist/calls/index.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCallsService = void 0;
+/*
+ * Copyright (C) 2024 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * 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.
+ */
+var buildService_1 = require("./buildService");
+Object.defineProperty(exports, "buildCallsService", { enumerable: true, get: function () { return buildService_1.buildService; } });

package/dist/calls/influxdb.d.ts

@@ -0,0 +1,2 @@
+declare const influxdb: import("@influxdata/influxdb-client").QueryApi;
+export { influxdb };

package/dist/calls/influxdb.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.influxdb = void 0;
+/*
+ * Copyright (C) 2024 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * 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 influxdb_client_1 = require("@influxdata/influxdb-client");
+const envs_1 = require("../envs");
+const client = new influxdb_client_1.InfluxDB({
+    url: envs_1.INFLUXDB_URL,
+    token: envs_1.INFLUXDB_TOKEN
+});
+const influxdb = client.getQueryApi(envs_1.INFLUXDB_ORG);
+exports.influxdb = influxdb;

package/dist/calls/listCalls.d.ts

@@ -0,0 +1,6 @@
+import { GrpcErrorMessage } from "@fonoster/common";
+import { InfluxDBClient, ListCallsRequest, ListCallsResponse } from "./types";
+declare function listCalls(influx: InfluxDBClient): (call: {
+    request: ListCallsRequest;
+}, callback: (error: GrpcErrorMessage, response?: ListCallsResponse) => void) => Promise<void>;
+export { listCalls };

package/dist/calls/listCalls.js

@@ -0,0 +1,52 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listCalls = void 0;
+/*
+ * Copyright (C) 2024 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * 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("@fonoster/common");
+const identity_1 = require("@fonoster/identity");
+const logger_1 = require("@fonoster/logger");
+const createFetchCalls_1 = require("./createFetchCalls");
+const ListCallsRequestSchema_1 = require("./ListCallsRequestSchema");
+const logger = (0, logger_1.getLogger)({ service: "apiserver", filePath: __filename });
+function listCalls(influx) {
+    const fetchCalls = (0, createFetchCalls_1.createFetchCalls)(influx);
+    return (call, callback) => __awaiter(this, void 0, void 0, function* () {
+        try {
+            const parsedRequest = ListCallsRequestSchema_1.ListCallsRequestSchema.parse(call.request);
+            const accessKeyId = (0, identity_1.getAccessKeyIdFromCall)(call);
+            logger.verbose("call to listCalls", { parsedRequest, accessKeyId });
+            const result = yield fetchCalls(accessKeyId, parsedRequest);
+            callback(null, result);
+        }
+        catch (error) {
+            (0, common_1.handleError)(error, callback);
+        }
+    });
+}
+exports.listCalls = listCalls;

package/dist/calls/runCallManager.d.ts

@@ -0,0 +1,8 @@
+type CallManagerConfig = {
+    natsUrl: string;
+    ariProxyUrl: string;
+    ariUsername: string;
+    ariPassword: string;
+};
+declare function createCreateCallSubscriber(config: CallManagerConfig): Promise<void>;
+export { createCreateCallSubscriber };

package/dist/calls/runCallManager.js

@@ -0,0 +1,82 @@
+"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.createCreateCallSubscriber = void 0;
+/*
+ * Copyright (C) 2024 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * 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 logger_1 = require("@fonoster/logger");
+const ari_client_1 = __importDefault(require("ari-client"));
+const nats_1 = require("nats");
+const envs_1 = require("../envs");
+const logger = (0, logger_1.getLogger)({ service: "apiserver", filePath: __filename });
+function createCreateCallSubscriber(config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { natsUrl, ariProxyUrl, ariUsername, ariPassword } = config;
+        try {
+            logger.verbose("connecting to nats", { natsUrl });
+            const nc = yield (0, nats_1.connect)({ servers: natsUrl });
+            logger.verbose("subscribing to call create subject", {
+                subject: envs_1.CALLS_CREATE_SUBJECT
+            });
+            const subscription = nc.subscribe(envs_1.CALLS_CREATE_SUBJECT, {
+                queue: envs_1.DEFAULT_NATS_QUEUE_GROUP
+            });
+            logger.verbose("connecting to ari", { ariProxyUrl });
+            const ariConn = yield ari_client_1.default.connect(ariProxyUrl, ariUsername, ariPassword);
+            subscription.callback = (err, msg) => __awaiter(this, void 0, void 0, function* () {
+                if (err) {
+                    logger.error(err);
+                }
+                const { ref, from, to, appRef } = msg.json();
+                logger.info("received a new call request", Object.assign({ callRef: ref }, msg.json()));
+                // eslint-disable-next-line new-cap
+                const channel = ariConn.Channel();
+                channel
+                    .originate({
+                    context: envs_1.ASTERISK_CONTEXT,
+                    extension: envs_1.ASTERISK_EXTENSION,
+                    endpoint: `PJSIP/${envs_1.ASTERISK_TRUNK}/sip:${to}@${envs_1.ASTERISK_SYSTEM_DOMAIN}`,
+                    variables: {
+                        "PJSIP_HEADER(add,X-DOD-Number)": from,
+                        INGRESS_NUMBER: from,
+                        APP_REF: appRef
+                    }
+                })
+                    .catch((err) => {
+                    logger.error("error creating call", { err });
+                });
+            });
+        }
+        catch (e) {
+            logger.error("error connecting to ari", { e });
+        }
+    });
+}
+exports.createCreateCallSubscriber = createCreateCallSubscriber;

package/dist/calls/trackCall.d.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+import { TrackCallSubscriber } from "./types";
+declare const TrackCallRequestSchema: z.ZodObject<{
+    ref: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    ref?: string;
+}, {
+    ref?: string;
+}>;
+type TrackCallRequest = z.infer<typeof TrackCallRequestSchema>;
+declare function trackCall(subs: TrackCallSubscriber): (call: {
+    request: TrackCallRequest;
+}) => void;
+export { trackCall };

package/dist/calls/trackCall.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trackCall = void 0;
+/*
+ * Copyright (C) 2024 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * 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 logger_1 = require("@fonoster/logger");
+const grpc_js_1 = require("@grpc/grpc-js");
+const zod_1 = require("zod");
+const types_1 = require("./types");
+const FINAL_STATUSES = [
+    types_1.CallStatus.COMPLETED,
+    types_1.CallStatus.FAILED,
+    types_1.CallStatus.BUSY,
+    types_1.CallStatus.NO_ANSWER,
+    types_1.CallStatus.CANCELED,
+    types_1.CallStatus.REJECTED,
+    types_1.CallStatus.TIMEOUT,
+    types_1.CallStatus.UNKNOWN
+];
+const logger = (0, logger_1.getLogger)({ service: "apiserver", filePath: __filename });
+const TrackCallRequestSchema = zod_1.z.object({
+    ref: zod_1.z.string()
+});
+function trackCall(subs) {
+    return (call) => {
+        const stream = call;
+        const { events } = subs;
+        const { ref } = call.request;
+        logger.verbose("call to trackCall", { ref });
+        stream.write({ ref, status: types_1.CallStatus.QUEUED });
+        events.on("status", (data) => {
+            logger.verbose("tracked call status change", Object.assign({}, data));
+            if (data instanceof Error) {
+                logger.error("tracked call status change error", Object.assign({}, data));
+                stream.write({ code: grpc_js_1.status.INTERNAL, message: data.message });
+                stream.end();
+                return;
+            }
+            if (data.ref === ref) {
+                stream.write(data);
+                if (FINAL_STATUSES.includes(data.status)) {
+                    stream.end();
+                }
+            }
+        });
+    };
+}
+exports.trackCall = trackCall;

package/dist/calls/types.d.ts

@@ -0,0 +1,96 @@
+import { GrpcErrorMessage } from "@fonoster/common";
+import { ParameterizedQuery } from "@influxdata/influxdb-client";
+declare const CALL_DETAIL_RECORD_MEASUREMENT = "cdr";
+declare enum CallType {
+    PROGRAMMABLE = "PROGRAMMABLE",
+    SIP_TRUNKING = "SIP_TRUNKING"
+}
+declare enum HangupCause {
+    NORMAL_CLEARING = "NORMAL_CLEARING",
+    CALL_REJECTED = "CALL_REJECTED",
+    UNALLOCATED = "UNALLOCATED",
+    NO_USER_RESPONSE = "NO_USER_RESPONSE",
+    NO_ROUTE_DESTINATION = "NO_ROUTE_DESTINATION",
+    NO_ANSWER = "NO_ANSWER",
+    USER_BUSY = "USER_BUSY",
+    NOT_ACCEPTABLE_HERE = "NOT_ACCEPTABLE_HERE",
+    SERVICE_UNAVAILABLE = "SERVICE_UNAVAILABLE",
+    INVALID_NUMBER_FORMAT = "INVALID_NUMBER_FORMAT"
+}
+declare enum CallStatus {
+    QUEUED = "QUEUED",
+    RINGING = "RINGING",
+    IN_PROGRESS = "IN_PROGRESS",
+    COMPLETED = "COMPLETED",
+    FAILED = "FAILED",
+    BUSY = "BUSY",
+    NO_ANSWER = "NO_ANSWER",
+    CANCELED = "CANCELED",
+    REJECTED = "REJECTED",
+    TIMEOUT = "TIMEOUT",
+    UNKNOWN = "UNKNOWN"
+}
+declare enum CallDirection {
+    INBOUND = "INBOUND",
+    OUTBOUND = "OUTBOUND"
+}
+type CallDetailRecord = {
+    ref: string;
+    type: CallType;
+    status: CallStatus;
+    hangupCause: HangupCause;
+    from: string;
+    to: string;
+    duration: number;
+    direction: CallDirection;
+    startedAt: number;
+    endedAt: number;
+};
+type ListCallsRequest = {
+    after?: string;
+    before?: string;
+    type?: CallType;
+    status?: CallStatus;
+    hangupCause?: HangupCause;
+    from?: string;
+    to?: string;
+    pageSize?: number;
+    pageToken?: string;
+};
+type ListCallsResponse = {
+    nextPageToken?: string;
+    items: CallDetailRecord[];
+};
+type GetCallRequest = {
+    ref: string;
+};
+type InfluxDBClient = {
+    collectRows(query: ParameterizedQuery): Promise<unknown[]>;
+};
+type CreateCallRequest = {
+    from: string;
+    to: string;
+    appRef?: string;
+};
+type CreateCallResponse = {
+    ref: string;
+};
+type CallPublisher = {
+    publishCall: (event: CreateCallRequest & {
+        ref: string;
+    }) => void;
+};
+type TrackCallResponse = {
+    ref: string;
+    status: CallStatus;
+};
+type CallStream = {
+    write: (data: TrackCallResponse | GrpcErrorMessage) => void;
+    end: () => void;
+};
+type TrackCallSubscriber = {
+    events: {
+        on: (event: string, cb: (data: TrackCallResponse | Error) => void) => void;
+    };
+};
+export { CALL_DETAIL_RECORD_MEASUREMENT, CallDetailRecord, ListCallsRequest, ListCallsResponse, GetCallRequest, CallType, CallStatus, CallDirection, InfluxDBClient, CreateCallRequest, CreateCallResponse, CallPublisher, TrackCallResponse, CallStream, TrackCallSubscriber, HangupCause };

package/dist/calls/types.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HangupCause = exports.CallDirection = exports.CallStatus = exports.CallType = exports.CALL_DETAIL_RECORD_MEASUREMENT = void 0;
+const CALL_DETAIL_RECORD_MEASUREMENT = "cdr";
+exports.CALL_DETAIL_RECORD_MEASUREMENT = CALL_DETAIL_RECORD_MEASUREMENT;
+var CallType;
+(function (CallType) {
+    CallType["PROGRAMMABLE"] = "PROGRAMMABLE";
+    CallType["SIP_TRUNKING"] = "SIP_TRUNKING";
+})(CallType || (exports.CallType = CallType = {}));
+var HangupCause;
+(function (HangupCause) {
+    HangupCause["NORMAL_CLEARING"] = "NORMAL_CLEARING";
+    HangupCause["CALL_REJECTED"] = "CALL_REJECTED";
+    HangupCause["UNALLOCATED"] = "UNALLOCATED";
+    HangupCause["NO_USER_RESPONSE"] = "NO_USER_RESPONSE";
+    HangupCause["NO_ROUTE_DESTINATION"] = "NO_ROUTE_DESTINATION";
+    HangupCause["NO_ANSWER"] = "NO_ANSWER";
+    HangupCause["USER_BUSY"] = "USER_BUSY";
+    HangupCause["NOT_ACCEPTABLE_HERE"] = "NOT_ACCEPTABLE_HERE";
+    HangupCause["SERVICE_UNAVAILABLE"] = "SERVICE_UNAVAILABLE";
+    HangupCause["INVALID_NUMBER_FORMAT"] = "INVALID_NUMBER_FORMAT";
+})(HangupCause || (exports.HangupCause = HangupCause = {}));
+var CallStatus;
+(function (CallStatus) {
+    CallStatus["QUEUED"] = "QUEUED";
+    CallStatus["RINGING"] = "RINGING";
+    CallStatus["IN_PROGRESS"] = "IN_PROGRESS";
+    CallStatus["COMPLETED"] = "COMPLETED";
+    CallStatus["FAILED"] = "FAILED";
+    CallStatus["BUSY"] = "BUSY";
+    CallStatus["NO_ANSWER"] = "NO_ANSWER";
+    CallStatus["CANCELED"] = "CANCELED";
+    CallStatus["REJECTED"] = "REJECTED";
+    CallStatus["TIMEOUT"] = "TIMEOUT";
+    CallStatus["UNKNOWN"] = "UNKNOWN";
+})(CallStatus || (exports.CallStatus = CallStatus = {}));
+var CallDirection;
+(function (CallDirection) {
+    CallDirection["INBOUND"] = "INBOUND";
+    CallDirection["OUTBOUND"] = "OUTBOUND";
+})(CallDirection || (exports.CallDirection = CallDirection = {}));

package/dist/core/allowList.d.ts

@@ -0,0 +1,2 @@
+declare const allowList: string[];
+export { allowList };

package/dist/core/allowList.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.allowList = void 0;
+/*
+ * Copyright (C) 2024 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * 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 allowList = [
+    "/grpc.health.v1.Health/Check",
+    "/fonoster.identity.v1beta2.Identity/CreateUser",
+    "/fonoster.identity.v1beta2.Identity/CreateWorkspace",
+    "/fonoster.identity.v1beta2.Identity/ExchangeApiKey",
+    "/fonoster.identity.v1beta2.Identity/ExchangeCredentials",
+    "/fonoster.identity.v1beta2.Identity/ExchangeRefreshToken",
+    "/fonoster.identity.v1beta2.Identity/GetPublicKey"
+];
+exports.allowList = allowList;

package/dist/core/db.d.ts

@@ -0,0 +1,13 @@
+declare const prisma: import("@prisma/client/runtime/library").DynamicClientExtensionThis<import(".prisma/client").Prisma.TypeMap<import("@prisma/client/runtime/library").InternalArgs & {
+    result: {};
+    model: {};
+    query: {};
+    client: {};
+}>, import(".prisma/client").Prisma.TypeMapCb, {
+    result: {};
+    model: {};
+    query: {};
+    client: {};
+}>;
+type Prisma = typeof prisma;
+export { prisma, Prisma };

package/dist/core/db.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prisma = void 0;
+/*
+ * Copyright (C) 2024 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * 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 client_1 = require("@prisma/client");
+const prisma_field_encryption_1 = require("prisma-field-encryption");
+const envs_1 = require("../envs");
+// We encrypt all fields marked with /// encrypted in the schema
+const prisma = new client_1.PrismaClient().$extends((0, prisma_field_encryption_1.fieldEncryptionExtension)({
+    encryptionKey: envs_1.CLOAK_ENCRYPTION_KEY
+}));
+exports.prisma = prisma;

package/dist/core/filesServer.d.ts

@@ -0,0 +1,5 @@
+declare function filesServer(params: {
+    pathToFiles: string;
+    port: number;
+}): void;
+export { filesServer };