@fonoster/apiserver 0.5.5 → 0.6.1-alpha.0

package/dist/applications/utils/getApplicationValidationSchema.d.ts

@@ -0,0 +1,64 @@
+import { z } from "zod";
+declare function getApplicationValidationSchema(request: {
+    ttsEngineName: string;
+    sttEngineName: string;
+}): z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodNativeEnum<{
+        PROGRAMMABLE_VOICE: "PROGRAMMABLE_VOICE";
+    }>;
+    appEndpoint: z.ZodEffects<z.ZodNullable<z.ZodOptional<z.ZodString>>, string, string>;
+    textToSpeech: z.ZodUndefined | z.ZodObject<{
+        productRef: z.ZodString;
+        config: any;
+    }, "strip", z.ZodTypeAny, {
+        [x: string]: any;
+        productRef?: unknown;
+        config?: unknown;
+    }, {
+        [x: string]: any;
+        productRef?: unknown;
+        config?: unknown;
+    }>;
+    speechToText: z.ZodUndefined | z.ZodObject<{
+        productRef: z.ZodString;
+        config: any;
+    }, "strip", z.ZodTypeAny, {
+        [x: string]: any;
+        productRef?: unknown;
+        config?: unknown;
+    }, {
+        [x: string]: any;
+        productRef?: unknown;
+        config?: unknown;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    name?: string;
+    type?: "PROGRAMMABLE_VOICE";
+    textToSpeech?: {
+        [x: string]: any;
+        productRef?: unknown;
+        config?: unknown;
+    };
+    speechToText?: {
+        [x: string]: any;
+        productRef?: unknown;
+        config?: unknown;
+    };
+    appEndpoint?: string;
+}, {
+    name?: string;
+    type?: "PROGRAMMABLE_VOICE";
+    textToSpeech?: {
+        [x: string]: any;
+        productRef?: unknown;
+        config?: unknown;
+    };
+    speechToText?: {
+        [x: string]: any;
+        productRef?: unknown;
+        config?: unknown;
+    };
+    appEndpoint?: string;
+}>;
+export { getApplicationValidationSchema };

package/dist/applications/utils/getApplicationValidationSchema.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getApplicationValidationSchema = 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 zod_1 = require("zod");
+const Google_1 = require("../../voice/stt/Google");
+const Azure_1 = require("../../voice/tts/Azure");
+const Google_2 = require("../../voice/tts/Google");
+const hostOrHostPortSchema_1 = require("../hostOrHostPortSchema");
+const validators = {
+    ttsConfigValidators: {
+        "tts.google": Google_2.Google.getConfigValidationSchema,
+        "tts.azure": Azure_1.Azure.getConfigValidationSchema
+    },
+    ttsCredentialsValidators: {
+        "tts.google": Google_2.Google.getCredentialsValidationSchema,
+        "tts.azure": Azure_1.Azure.getCredentialsValidationSchema
+    },
+    sttConfigValidators: {
+        "stt.google": Google_1.Google.getConfigValidationSchema
+    },
+    sttCredentialsValidators: {
+        "stt.google": Google_1.Google.getCredentialsValidationSchema
+    }
+};
+function getApplicationValidationSchema(request) {
+    const { ttsEngineName, sttEngineName } = request;
+    return zod_1.z.object({
+        name: zod_1.z.string(),
+        type: zod_1.z.nativeEnum(client_1.ApplicationType),
+        appEndpoint: hostOrHostPortSchema_1.hostOrHostPortSchema,
+        textToSpeech: ttsEngineName
+            ? zod_1.z.object({
+                productRef: zod_1.z.string(),
+                config: validators.ttsConfigValidators[ttsEngineName]()
+            })
+            : zod_1.z.undefined(),
+        speechToText: sttEngineName
+            ? zod_1.z.object({
+                productRef: zod_1.z.string(),
+                config: validators.sttConfigValidators[sttEngineName]()
+            })
+            : zod_1.z.undefined()
+    });
+}
+exports.getApplicationValidationSchema = getApplicationValidationSchema;

package/dist/applications/utils/prepareForValidation.d.ts

@@ -0,0 +1,3 @@
+import { Application, CreateApplicationRequest, UpdateApplicationRequest } from "@fonoster/common";
+declare function prepareForValidation(request: CreateApplicationRequest | UpdateApplicationRequest): Application;
+export { prepareForValidation };

package/dist/applications/utils/prepareForValidation.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareForValidation = void 0;
+const client_1 = require("@prisma/client");
+const pb_util_1 = require("pb-util");
+function prepareForValidation(request) {
+    const type = request.type || client_1.ApplicationType.PROGRAMMABLE_VOICE;
+    const result = {
+        ref: request.ref, // Only for UpdateApplicationRequest
+        name: request.name,
+        type,
+        appEndpoint: request.appEndpoint
+    };
+    const createProperty = (property) => {
+        return property
+            ? {
+                productRef: property.productRef,
+                credentials: property.credentials
+                    ? pb_util_1.struct.decode(property.credentials)
+                    : undefined,
+                config: property.config ? pb_util_1.struct.decode(property.config) : null
+            }
+            : undefined;
+    };
+    if (request.textToSpeech) {
+        result.textToSpeech = createProperty(request.textToSpeech);
+    }
+    if (request.speechToText) {
+        result.speechToText = createProperty(request.speechToText);
+    }
+    if (request.intelligence) {
+        result.intelligence = createProperty(request.intelligence);
+    }
+    return result;
+}
+exports.prepareForValidation = prepareForValidation;

package/dist/applications/utils/validOrThrow.d.ts

@@ -0,0 +1,3 @@
+import { CreateApplicationRequest, UpdateApplicationRequest } from "@fonoster/common";
+declare function validOrThrow(request: CreateApplicationRequest | UpdateApplicationRequest): void;
+export { validOrThrow };

package/dist/applications/utils/validOrThrow.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validOrThrow = void 0;
+const getApplicationValidationSchema_1 = require("./getApplicationValidationSchema");
+const prepareForValidation_1 = require("./prepareForValidation");
+function validOrThrow(request) {
+    var _a, _b;
+    const data = (0, prepareForValidation_1.prepareForValidation)(request);
+    const schema = (0, getApplicationValidationSchema_1.getApplicationValidationSchema)({
+        ttsEngineName: (_a = request.textToSpeech) === null || _a === void 0 ? void 0 : _a.productRef,
+        sttEngineName: (_b = request.speechToText) === null || _b === void 0 ? void 0 : _b.productRef
+    });
+    schema.parse(data);
+}
+exports.validOrThrow = validOrThrow;

package/dist/calls/ListCallsRequestSchema.d.ts

@@ -0,0 +1,28 @@
+import { z } from "zod";
+import { CallStatus, CallType, HangupCause } from "./types";
+declare const ListCallsRequestSchema: z.ZodObject<{
+    after: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    before: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    pageSize: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    type: z.ZodNullable<z.ZodOptional<z.ZodNativeEnum<typeof CallType>>>;
+    hangupCause: z.ZodNullable<z.ZodOptional<z.ZodNativeEnum<typeof HangupCause>>>;
+    status: z.ZodNullable<z.ZodOptional<z.ZodNativeEnum<typeof CallStatus>>>;
+    pageToken: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    type?: CallType;
+    status?: CallStatus;
+    pageSize?: number;
+    pageToken?: string;
+    after?: string;
+    before?: string;
+    hangupCause?: HangupCause;
+}, {
+    type?: CallType;
+    status?: CallStatus;
+    pageSize?: number;
+    pageToken?: string;
+    after?: string;
+    before?: string;
+    hangupCause?: HangupCause;
+}>;
+export { ListCallsRequestSchema };

package/dist/calls/ListCallsRequestSchema.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListCallsRequestSchema = 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 zod_1 = require("zod");
+const types_1 = require("./types");
+const ListCallsRequestSchema = zod_1.z.object({
+    after: zod_1.z
+        .string()
+        .datetime({ offset: true, message: "The date must be a valid ISO 8601" })
+        .optional()
+        .nullable(),
+    before: zod_1.z
+        .string()
+        .datetime({ offset: true, message: "The date must be a valid ISO 8601" })
+        .optional()
+        .nullable(),
+    pageSize: zod_1.z
+        .number({ message: "Invalid pageSize value" })
+        .optional()
+        .nullable(),
+    type: zod_1.z
+        .nativeEnum(types_1.CallType, {
+        message: "Invalid call type"
+    })
+        .optional()
+        .nullable(),
+    hangupCause: zod_1.z
+        .nativeEnum(types_1.HangupCause, { message: "Invalid hangup cause" })
+        .optional()
+        .nullable(),
+    status: zod_1.z
+        .nativeEnum(types_1.CallStatus, { message: "Invalid call status" })
+        .optional()
+        .nullable(),
+    pageToken: zod_1.z
+        .string({ message: "The pageToken must be a string" })
+        .optional()
+        .nullable()
+});
+exports.ListCallsRequestSchema = ListCallsRequestSchema;

package/dist/calls/buildService.d.ts

@@ -0,0 +1,26 @@
+import { InfluxDBClient } from "./types";
+declare function buildService(influxdb: InfluxDBClient): Promise<{
+    definition: {
+        serviceName: string;
+        pckg: string;
+        version: string;
+        proto: string;
+    };
+    handlers: {
+        createCall: (call: {
+            request: import("./types").CreateCallRequest;
+        }, callback: (error?: import("@fonoster/common").GrpcErrorMessage, response?: import("./types").CreateCallResponse) => void) => Promise<void>;
+        listCalls: (call: {
+            request: import("./types").ListCallsRequest;
+        }, callback: (error: import("@fonoster/common").GrpcErrorMessage, response?: import("./types").ListCallsResponse) => void) => Promise<void>;
+        getCall: (call: {
+            request: import("./types").GetCallRequest;
+        }, callback: (error: import("@fonoster/common").GrpcErrorMessage, response?: import("./types").CallDetailRecord) => void) => Promise<void>;
+        trackCall: (call: {
+            request: {
+                ref?: string;
+            };
+        }) => void;
+    };
+}>;
+export { buildService };

package/dist/calls/buildService.js

@@ -0,0 +1,58 @@
+"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.buildService = 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 createCall_1 = require("./createCall");
+const createCallPublisher_1 = require("./createCallPublisher");
+const createTrackCallSubscriber_1 = require("./createTrackCallSubscriber");
+const getCall_1 = require("./getCall");
+const listCalls_1 = require("./listCalls");
+const trackCall_1 = require("./trackCall");
+const envs_1 = require("../envs");
+function buildService(influxdb) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const trackCallSubscriber = yield (0, createTrackCallSubscriber_1.createTrackCallSubscriber)(envs_1.NATS_URL);
+        const callPublisher = yield (0, createCallPublisher_1.createCallPublisher)(envs_1.NATS_URL);
+        return {
+            definition: {
+                serviceName: "Calls",
+                pckg: "calls",
+                version: "v1beta2",
+                proto: "calls.proto"
+            },
+            handlers: {
+                createCall: (0, createCall_1.createCall)(callPublisher),
+                listCalls: (0, listCalls_1.listCalls)(influxdb),
+                getCall: (0, getCall_1.getCall)(influxdb),
+                trackCall: (0, trackCall_1.trackCall)(trackCallSubscriber())
+            }
+        };
+    });
+}
+exports.buildService = buildService;

package/dist/calls/createCall.d.ts

@@ -0,0 +1,6 @@
+import { GrpcErrorMessage } from "@fonoster/common";
+import { CallPublisher, CreateCallRequest, CreateCallResponse } from "./types";
+declare function createCall(publisher: CallPublisher): (call: {
+    request: CreateCallRequest;
+}, callback: (error?: GrpcErrorMessage, response?: CreateCallResponse) => void) => Promise<void>;
+export { createCall };

package/dist/calls/createCall.js

@@ -0,0 +1,64 @@
+"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.createCall = 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 uuid_1 = require("uuid");
+const zod_1 = require("zod");
+const logger = (0, logger_1.getLogger)({ service: "apiserver", filePath: __filename });
+const CreateCallRequestSchema = zod_1.z.object({
+    from: zod_1.z.string(),
+    to: zod_1.z.string(),
+    appRef: zod_1.z.string()
+});
+function createCall(publisher) {
+    return (call, callback) => __awaiter(this, void 0, void 0, function* () {
+        try {
+            const { from, to, appRef } = call.request;
+            CreateCallRequestSchema.parse(call.request);
+            const ref = (0, uuid_1.v4)();
+            const accessKeyId = (0, identity_1.getAccessKeyIdFromCall)(call);
+            logger.verbose("call to createCall", {
+                accessKeyId,
+                ref,
+                from,
+                to,
+                appRef
+            });
+            publisher.publishCall({ ref, from, to, appRef });
+            callback(null, { ref });
+        }
+        catch (error) {
+            (0, common_1.handleError)(error, callback);
+        }
+    });
+}
+exports.createCall = createCall;

package/dist/calls/createCallPublisher.d.ts

@@ -0,0 +1,7 @@
+import { CreateCallRequest } from "./types";
+declare function createCallPublisher(natsUrl: string): Promise<{
+    publishCall: (request: CreateCallRequest & {
+        ref: string;
+    }) => Promise<void>;
+}>;
+export { createCallPublisher };

package/dist/calls/createCallPublisher.js

@@ -0,0 +1,47 @@
+"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.createCallPublisher = 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 nats_1 = require("nats");
+const envs_1 = require("../envs");
+const logger = (0, logger_1.getLogger)({ service: "apiserver", filePath: __filename });
+function createCallPublisher(natsUrl) {
+    return __awaiter(this, void 0, void 0, function* () {
+        logger.verbose("connecting to nats", { natsUrl });
+        const nc = yield (0, nats_1.connect)({ servers: natsUrl });
+        return {
+            publishCall: (request) => __awaiter(this, void 0, void 0, function* () {
+                logger.verbose("publishing call", { ref: request.ref });
+                nc.publish(envs_1.CALLS_CREATE_SUBJECT, JSON.stringify(request));
+            })
+        };
+    });
+}
+exports.createCallPublisher = createCallPublisher;

package/dist/calls/createFetchCalls.d.ts

@@ -0,0 +1,3 @@
+import { InfluxDBClient, ListCallsRequest, ListCallsResponse } from "./types";
+declare function createFetchCalls(influxdb: InfluxDBClient): (accessKeyId: string, request: ListCallsRequest) => Promise<ListCallsResponse>;
+export { createFetchCalls };

package/dist/calls/createFetchCalls.js

@@ -0,0 +1,87 @@
+"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.createFetchCalls = 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 influxdb_client_1 = require("@influxdata/influxdb-client");
+const types_1 = require("./types");
+const envs_1 = require("../envs");
+const logger = (0, logger_1.getLogger)({ service: "apiserver", filePath: __filename });
+function createFetchCalls(influxdb) {
+    return (accessKeyId, request) => __awaiter(this, void 0, void 0, function* () {
+        const { after, before, type, from, to, status, hangupCause, pageSize, pageToken } = request;
+        const accessKeyIdFilter = accessKeyId
+            ? (0, influxdb_client_1.flux) `and r.accessKeyId == "${accessKeyId}"`
+            : (0, influxdb_client_1.flux) ``;
+        const typeFilter = type ? (0, influxdb_client_1.flux) `and r.type == "${type}"` : (0, influxdb_client_1.flux) ``;
+        const fromFilter = from ? (0, influxdb_client_1.flux) `and r.from == "${from}"` : (0, influxdb_client_1.flux) ``;
+        const toFilter = to ? (0, influxdb_client_1.flux) `and r.to == "${to}"` : (0, influxdb_client_1.flux) ``;
+        const statusFilter = status ? (0, influxdb_client_1.flux) `and r.status == "${status}"` : (0, influxdb_client_1.flux) ``;
+        const hangupCauseFilter = hangupCause
+            ? (0, influxdb_client_1.flux) `and r.hangupCause == "${hangupCause}"`
+            : (0, influxdb_client_1.flux) ``;
+        const pageTokenFilter = pageToken
+            ? (0, influxdb_client_1.flux) `|> filter(fn: (r) => r.startedAtParsed < int(v: ${pageToken}))`
+            : (0, influxdb_client_1.flux) ``;
+        const limit = (0, influxdb_client_1.flux) `|> limit(n: ${pageSize || 50})`;
+        const parsedAfter = after ? new Date(after).getTime() / 1000 : (0, influxdb_client_1.flux) `-30d`;
+        const parsedBefore = before
+            ? new Date(before).getTime() / 1000
+            : new Date().getTime() / 1000;
+        const query = (0, influxdb_client_1.flux) `from(bucket: "${envs_1.INFLUXDB_BUCKET}")
+      |> range(start: ${parsedAfter})
+      |> pivot(rowKey: ["ref"], columnKey: ["_field"], valueColumn: "_value")
+      |> map(fn: (r) => ({
+          r with
+          duration: (int(v: r.endedAt) - int(v: r.startedAt)) / 1000,
+          startedAtParsed: int(v: r.startedAt) / 1000,
+        }))
+      |> filter(fn: (r) =>
+        r._measurement == "${types_1.CALL_DETAIL_RECORD_MEASUREMENT}"
+        and r.startedAtParsed < ${parsedBefore}
+        ${accessKeyIdFilter}
+        ${typeFilter}
+        ${fromFilter}
+        ${toFilter}
+        ${statusFilter}
+        ${hangupCauseFilter})
+      |> group()
+      |> sort(columns: ["startedAtParsed"], desc: true)
+      ${pageTokenFilter}
+      ${limit}`;
+        logger.verbose("list calls request", { accessKeyId, after, before });
+        const items = (yield influxdb.collectRows(query));
+        const nextPageToken = items.length > 0 ? items[items.length - 1].startedAt : "";
+        return {
+            nextPageToken: nextPageToken + "",
+            items
+        };
+    });
+}
+exports.createFetchCalls = createFetchCalls;

package/dist/calls/createFetchSingleCall.d.ts

@@ -0,0 +1,3 @@
+import { CallDetailRecord, InfluxDBClient } from "./types";
+declare function createFetchSingleCall(influxdb: InfluxDBClient): (accessKeyId: string, ref: string) => Promise<CallDetailRecord>;
+export { createFetchSingleCall };

package/dist/calls/createFetchSingleCall.js

@@ -0,0 +1,48 @@
+"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.createFetchSingleCall = 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 types_1 = require("./types");
+const envs_1 = require("../envs");
+function createFetchSingleCall(influxdb) {
+    return (accessKeyId, ref) => __awaiter(this, void 0, void 0, function* () {
+        // TODO: Look into best practices for range and limit
+        const query = (0, influxdb_client_1.flux) `from(bucket: "${envs_1.INFLUXDB_BUCKET}")
+      |> range(start: -360d)
+      |> pivot(rowKey: ["_time"], columnKey: ["_field"], valueColumn: "_value")
+      |> filter(fn: (r) => r._measurement == "${types_1.CALL_DETAIL_RECORD_MEASUREMENT}")
+      |> filter(fn: (r) => r.ref == ${ref} and r.accessKeyId == "${accessKeyId}")
+      |> sort(columns: ["_time"], desc: true)
+      |> limit(n: 1)`;
+        const items = (yield influxdb.collectRows(query));
+        return items.length > 0 ? items[0] : null;
+    });
+}
+exports.createFetchSingleCall = createFetchSingleCall;

package/dist/calls/createTrackCallSubscriber.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+import EventEmitter from "events";
+declare function createTrackCallSubscriber(natsUrl: string): Promise<() => {
+    events: EventEmitter<[never]>;
+}>;
+export { createTrackCallSubscriber };