@dereekb/nestjs 12.7.0 → 13.0.1

package/vapiai/index.cjs.js

@@ -0,0 +1,319 @@
+'use strict';
+
+var util = require('@dereekb/util');
+var nestjs = require('@dereekb/nestjs');
+var common = require('@nestjs/common');
+var crypto = require('crypto');
+var config = require('@nestjs/config');
+var serverSdk = require('@vapi-ai/server-sdk');
+
+/**
+ * Creates a VapiAiWebhookEvent and treats the data as the input type.
+ *
+ * @param event
+ * @returns
+ */
+function vapiAiWebhookEvent(event) {
+    return event;
+}
+const vapiaiEventHandlerFactory = util.handlerFactory((x) => x.type, {
+    defaultResult: {
+        handled: true,
+        response: undefined
+    },
+    negativeResult: {
+        handled: true,
+        response: undefined
+    }
+});
+const vapiaiEventHandlerConfigurerFactory = util.handlerConfigurerFactory({
+    configurerForAccessor: (accessor) => {
+        // eslint-disable-next-line
+        const fnWithKey = util.handlerMappedSetFunctionFactory(accessor, vapiAiWebhookEvent);
+        const configurer = {
+            ...accessor,
+            handleAssistantRequest: fnWithKey('assistant-request'),
+            handleStatusUpdate: fnWithKey('status-update'),
+            handleFunctionCall: fnWithKey('function-call'),
+            handleEndOfCallReport: fnWithKey('end-of-call-report'),
+            handleHang: fnWithKey('hang')
+        };
+        return configurer;
+    }
+});
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+function __param(paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+}
+
+function __metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+/**
+ * Verifies a VapiAi webhook event header.
+ *
+ * @param vapiSecretTokenGetter The VapiAi secret token. The Vapi client allows for using an AsyncGetterOrValue type, so the verifier supports that as well.
+ * @returns A function that verifies a VapiAi webhook event.
+ */
+function vapiAiWebhookEventVerifier(config) {
+    const { verificationType: inputVerificationType, secret: inputSecret, hmacSecret: inputHmacSecret, signaturePrefix: inputSignaturePrefix } = config;
+    const verificationType = inputVerificationType ?? (inputHmacSecret != null ? 'hmac' : 'secret'); // default to secret always, never default to none
+    const secretToken = (verificationType === 'hmac' ? (inputHmacSecret ?? inputSecret) : inputSecret) ?? '';
+    const signaturePrefix = inputSignaturePrefix ?? '';
+    function verifyNone(input) {
+        return true;
+    }
+    function verifySecret(input) {
+        const { request } = input;
+        const headers = request.headers;
+        const vapiSecret = headers['x-vapi-secret'];
+        const valid = vapiSecret === secretToken;
+        return valid;
+    }
+    function verifyHmac(input) {
+        const { request, requestBodyString } = input;
+        const headers = request.headers;
+        const timestamp = headers['x-timestamp'];
+        const vapiSignature = headers['x-signature'];
+        const message = `${timestamp}.${requestBodyString}`;
+        const hashForVerify = crypto.createHmac('sha256', secretToken).update(message).digest('hex');
+        const signature = `${signaturePrefix}${hashForVerify}`;
+        const valid = vapiSignature === signature;
+        return valid;
+    }
+    const verify = verificationType === 'hmac' ? verifyHmac : verificationType === 'secret' ? verifySecret : verifyNone;
+    return async (request, rawBody) => {
+        const requestBodyString = String(request.body);
+        const valid = verify({ request, requestBodyString });
+        const requestBody = JSON.parse(requestBodyString);
+        const result = {
+            valid,
+            event: requestBody.message
+        };
+        return result;
+    };
+}
+
+const VAPI_AI_WEBHOOK_SECRET_TOKEN_ENV_VAR = 'VAPI_AI_WEBHOOK_SECRET_TOKEN';
+const VAPI_AI_WEBHOOK_HMAC_SECRET_TOKEN_ENV_VAR = 'VAPI_AI_WEBHOOK_HMAC_SECRET_TOKEN';
+const VAPI_AI_WEBHOOK_SECRET_VERIFICATION_TYPE_ENV_VAR = 'VAPI_AI_WEBHOOK_SECRET_VERIFICATION_TYPE';
+const VAPI_AI_WEBHOOK_SIGNATURE_PREFIX_ENV_VAR = 'VAPI_AI_WEBHOOK_SIGNATURE_PREFIX';
+/**
+ * Configuration for VapiAiService
+ */
+class VapiAiWebhookServiceConfig {
+    webhookConfig;
+    static assertValidConfig(config) {
+        if (!config.webhookConfig.secret && !config.webhookConfig.hmacSecret) {
+            throw new Error('No Vapi.ai webhook secret token specified.');
+        }
+    }
+}
+
+/**
+ * Service that makes system changes based on VapiAi webhook events.
+ */
+exports.VapiAiWebhookService = class VapiAiWebhookService {
+    logger = new common.Logger('VapiAiWebhookService');
+    _verifier;
+    handler = vapiaiEventHandlerFactory();
+    configure = vapiaiEventHandlerConfigurerFactory(this.handler);
+    constructor(vapiAiWebhookServiceConfig) {
+        this._verifier = vapiAiWebhookEventVerifier(vapiAiWebhookServiceConfig.webhookConfig);
+    }
+    async updateForWebhook(req, rawBody) {
+        const { valid, event } = await this._verifier(req, rawBody);
+        let result = {
+            handled: false
+        };
+        if (!valid) {
+            this.logger.warn('Received invalid Vapi.ai event: ', event);
+        }
+        else {
+            result = await this.updateForVapiAiEvent(event);
+        }
+        const response = {
+            valid,
+            event,
+            ...result
+        };
+        return response;
+    }
+    async updateForVapiAiEvent(event) {
+        const result = await this.handler(event);
+        if (!result.handled) {
+            this.logger.warn('Received unexpected/unhandled Vapi.ai event: ', event);
+        }
+        return result;
+    }
+};
+exports.VapiAiWebhookService = __decorate([
+    common.Injectable(),
+    __param(0, common.Inject(VapiAiWebhookServiceConfig)),
+    __metadata("design:paramtypes", [VapiAiWebhookServiceConfig])
+], exports.VapiAiWebhookService);
+
+exports.VapiAiWebhookController = class VapiAiWebhookController {
+    _vapiaiWebhookService;
+    constructor(vapiaiWebhookService) {
+        this._vapiaiWebhookService = vapiaiWebhookService;
+    }
+    async handleVapiAiWebhook(res, req, rawBody) {
+        const { valid, response: responseData } = await this._vapiaiWebhookService.updateForWebhook(req, rawBody);
+        const response = res.status(200); // always return a 200 status code
+        if (valid && responseData) {
+            response.json(responseData);
+        }
+        else {
+            response.json({});
+        }
+    }
+};
+__decorate([
+    common.Post(),
+    __param(0, common.Res()),
+    __param(1, common.Req()),
+    __param(2, nestjs.RawBody()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], exports.VapiAiWebhookController.prototype, "handleVapiAiWebhook", null);
+exports.VapiAiWebhookController = __decorate([
+    common.Controller('/webhook/vapiai'),
+    __param(0, common.Inject(exports.VapiAiWebhookService)),
+    __metadata("design:paramtypes", [exports.VapiAiWebhookService])
+], exports.VapiAiWebhookController);
+
+function vapiaiWebhookServiceConfigFactory(configService) {
+    const config = {
+        webhookConfig: {
+            secret: configService.get(VAPI_AI_WEBHOOK_SECRET_TOKEN_ENV_VAR),
+            hmacSecret: configService.get(VAPI_AI_WEBHOOK_HMAC_SECRET_TOKEN_ENV_VAR),
+            verificationType: configService.get(VAPI_AI_WEBHOOK_SECRET_VERIFICATION_TYPE_ENV_VAR),
+            signaturePrefix: configService.get(VAPI_AI_WEBHOOK_SIGNATURE_PREFIX_ENV_VAR)
+        }
+    };
+    VapiAiWebhookServiceConfig.assertValidConfig(config);
+    return config;
+}
+exports.VapiAiWebhookModule = class VapiAiWebhookModule {
+};
+exports.VapiAiWebhookModule = __decorate([
+    common.Module({
+        imports: [config.ConfigModule],
+        controllers: [exports.VapiAiWebhookController],
+        providers: [
+            {
+                provide: VapiAiWebhookServiceConfig,
+                inject: [config.ConfigService],
+                useFactory: vapiaiWebhookServiceConfigFactory
+            },
+            exports.VapiAiWebhookService
+        ],
+        exports: [exports.VapiAiWebhookService]
+    })
+], exports.VapiAiWebhookModule);
+
+const VAPI_AI_SECRET_TOKEN_ENV_VAR = 'VAPI_AI_SECRET_TOKEN';
+/**
+ * Configuration for VapiAiService
+ */
+class VapiAiServiceConfig {
+    vapiai;
+    static assertValidConfig(config) {
+        if (!config.vapiai.config.token) {
+            throw new Error('No Vapi.ai secret/token specified.');
+        }
+    }
+}
+
+exports.VapiAiApi = class VapiAiApi {
+    config;
+    vapiClient;
+    constructor(config) {
+        this.config = config;
+        this.vapiClient = new serverSdk.VapiClient(config.vapiai.config);
+    }
+    // MARK: Accessors
+    /**
+     * Gets a call by ID.
+     *
+     * @param callId
+     * @returns
+     */
+    getCall(callId) {
+        return this.vapiClient.calls.get({ id: callId });
+    }
+};
+exports.VapiAiApi = __decorate([
+    common.Injectable(),
+    __param(0, common.Inject(VapiAiServiceConfig)),
+    __metadata("design:paramtypes", [VapiAiServiceConfig])
+], exports.VapiAiApi);
+
+function vapiaiServiceConfigFactory(configService) {
+    const config = {
+        vapiai: {
+            config: {
+                token: configService.get(VAPI_AI_SECRET_TOKEN_ENV_VAR)
+            }
+        }
+    };
+    VapiAiServiceConfig.assertValidConfig(config);
+    return config;
+}
+exports.VapiAiModule = class VapiAiModule {
+};
+exports.VapiAiModule = __decorate([
+    common.Module({
+        imports: [config.ConfigModule],
+        providers: [
+            {
+                provide: VapiAiServiceConfig,
+                inject: [config.ConfigService],
+                useFactory: vapiaiServiceConfigFactory
+            },
+            exports.VapiAiApi
+        ],
+        exports: [exports.VapiAiApi]
+    })
+], exports.VapiAiModule);
+
+exports.VAPI_AI_SECRET_TOKEN_ENV_VAR = VAPI_AI_SECRET_TOKEN_ENV_VAR;
+exports.VapiAiServiceConfig = VapiAiServiceConfig;
+exports.vapiAiWebhookEvent = vapiAiWebhookEvent;
+exports.vapiAiWebhookEventVerifier = vapiAiWebhookEventVerifier;
+exports.vapiaiEventHandlerConfigurerFactory = vapiaiEventHandlerConfigurerFactory;
+exports.vapiaiEventHandlerFactory = vapiaiEventHandlerFactory;
+exports.vapiaiServiceConfigFactory = vapiaiServiceConfigFactory;
+exports.vapiaiWebhookServiceConfigFactory = vapiaiWebhookServiceConfigFactory;

package/vapiai/index.cjs.mjs

@@ -0,0 +1,2 @@
+export * from './index.cjs.js';
+export { _default as default } from './index.cjs.default.js';

package/vapiai/index.d.ts

@@ -0,0 +1 @@
+export * from "./src/index";

package/vapiai/index.esm.js

@@ -0,0 +1,310 @@
+import { handlerFactory, handlerConfigurerFactory, handlerMappedSetFunctionFactory } from '@dereekb/util';
+import { RawBody } from '@dereekb/nestjs';
+import { Injectable, Inject, Logger, Post, Res, Req, Controller, Module } from '@nestjs/common';
+import { createHmac } from 'crypto';
+import { ConfigService, ConfigModule } from '@nestjs/config';
+import { VapiClient } from '@vapi-ai/server-sdk';
+
+/**
+ * Creates a VapiAiWebhookEvent and treats the data as the input type.
+ *
+ * @param event
+ * @returns
+ */
+function vapiAiWebhookEvent(event) {
+    return event;
+}
+const vapiaiEventHandlerFactory = handlerFactory((x) => x.type, {
+    defaultResult: {
+        handled: true,
+        response: undefined
+    },
+    negativeResult: {
+        handled: true,
+        response: undefined
+    }
+});
+const vapiaiEventHandlerConfigurerFactory = handlerConfigurerFactory({
+    configurerForAccessor: (accessor) => {
+        // eslint-disable-next-line
+        const fnWithKey = handlerMappedSetFunctionFactory(accessor, vapiAiWebhookEvent);
+        const configurer = {
+            ...accessor,
+            handleAssistantRequest: fnWithKey('assistant-request'),
+            handleStatusUpdate: fnWithKey('status-update'),
+            handleFunctionCall: fnWithKey('function-call'),
+            handleEndOfCallReport: fnWithKey('end-of-call-report'),
+            handleHang: fnWithKey('hang')
+        };
+        return configurer;
+    }
+});
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+function __param(paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+}
+
+function __metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+/**
+ * Verifies a VapiAi webhook event header.
+ *
+ * @param vapiSecretTokenGetter The VapiAi secret token. The Vapi client allows for using an AsyncGetterOrValue type, so the verifier supports that as well.
+ * @returns A function that verifies a VapiAi webhook event.
+ */
+function vapiAiWebhookEventVerifier(config) {
+    const { verificationType: inputVerificationType, secret: inputSecret, hmacSecret: inputHmacSecret, signaturePrefix: inputSignaturePrefix } = config;
+    const verificationType = inputVerificationType ?? (inputHmacSecret != null ? 'hmac' : 'secret'); // default to secret always, never default to none
+    const secretToken = (verificationType === 'hmac' ? (inputHmacSecret ?? inputSecret) : inputSecret) ?? '';
+    const signaturePrefix = inputSignaturePrefix ?? '';
+    function verifyNone(input) {
+        return true;
+    }
+    function verifySecret(input) {
+        const { request } = input;
+        const headers = request.headers;
+        const vapiSecret = headers['x-vapi-secret'];
+        const valid = vapiSecret === secretToken;
+        return valid;
+    }
+    function verifyHmac(input) {
+        const { request, requestBodyString } = input;
+        const headers = request.headers;
+        const timestamp = headers['x-timestamp'];
+        const vapiSignature = headers['x-signature'];
+        const message = `${timestamp}.${requestBodyString}`;
+        const hashForVerify = createHmac('sha256', secretToken).update(message).digest('hex');
+        const signature = `${signaturePrefix}${hashForVerify}`;
+        const valid = vapiSignature === signature;
+        return valid;
+    }
+    const verify = verificationType === 'hmac' ? verifyHmac : verificationType === 'secret' ? verifySecret : verifyNone;
+    return async (request, rawBody) => {
+        const requestBodyString = String(request.body);
+        const valid = verify({ request, requestBodyString });
+        const requestBody = JSON.parse(requestBodyString);
+        const result = {
+            valid,
+            event: requestBody.message
+        };
+        return result;
+    };
+}
+
+const VAPI_AI_WEBHOOK_SECRET_TOKEN_ENV_VAR = 'VAPI_AI_WEBHOOK_SECRET_TOKEN';
+const VAPI_AI_WEBHOOK_HMAC_SECRET_TOKEN_ENV_VAR = 'VAPI_AI_WEBHOOK_HMAC_SECRET_TOKEN';
+const VAPI_AI_WEBHOOK_SECRET_VERIFICATION_TYPE_ENV_VAR = 'VAPI_AI_WEBHOOK_SECRET_VERIFICATION_TYPE';
+const VAPI_AI_WEBHOOK_SIGNATURE_PREFIX_ENV_VAR = 'VAPI_AI_WEBHOOK_SIGNATURE_PREFIX';
+/**
+ * Configuration for VapiAiService
+ */
+class VapiAiWebhookServiceConfig {
+    webhookConfig;
+    static assertValidConfig(config) {
+        if (!config.webhookConfig.secret && !config.webhookConfig.hmacSecret) {
+            throw new Error('No Vapi.ai webhook secret token specified.');
+        }
+    }
+}
+
+/**
+ * Service that makes system changes based on VapiAi webhook events.
+ */
+let VapiAiWebhookService = class VapiAiWebhookService {
+    logger = new Logger('VapiAiWebhookService');
+    _verifier;
+    handler = vapiaiEventHandlerFactory();
+    configure = vapiaiEventHandlerConfigurerFactory(this.handler);
+    constructor(vapiAiWebhookServiceConfig) {
+        this._verifier = vapiAiWebhookEventVerifier(vapiAiWebhookServiceConfig.webhookConfig);
+    }
+    async updateForWebhook(req, rawBody) {
+        const { valid, event } = await this._verifier(req, rawBody);
+        let result = {
+            handled: false
+        };
+        if (!valid) {
+            this.logger.warn('Received invalid Vapi.ai event: ', event);
+        }
+        else {
+            result = await this.updateForVapiAiEvent(event);
+        }
+        const response = {
+            valid,
+            event,
+            ...result
+        };
+        return response;
+    }
+    async updateForVapiAiEvent(event) {
+        const result = await this.handler(event);
+        if (!result.handled) {
+            this.logger.warn('Received unexpected/unhandled Vapi.ai event: ', event);
+        }
+        return result;
+    }
+};
+VapiAiWebhookService = __decorate([
+    Injectable(),
+    __param(0, Inject(VapiAiWebhookServiceConfig)),
+    __metadata("design:paramtypes", [VapiAiWebhookServiceConfig])
+], VapiAiWebhookService);
+
+let VapiAiWebhookController = class VapiAiWebhookController {
+    _vapiaiWebhookService;
+    constructor(vapiaiWebhookService) {
+        this._vapiaiWebhookService = vapiaiWebhookService;
+    }
+    async handleVapiAiWebhook(res, req, rawBody) {
+        const { valid, response: responseData } = await this._vapiaiWebhookService.updateForWebhook(req, rawBody);
+        const response = res.status(200); // always return a 200 status code
+        if (valid && responseData) {
+            response.json(responseData);
+        }
+        else {
+            response.json({});
+        }
+    }
+};
+__decorate([
+    Post(),
+    __param(0, Res()),
+    __param(1, Req()),
+    __param(2, RawBody()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], VapiAiWebhookController.prototype, "handleVapiAiWebhook", null);
+VapiAiWebhookController = __decorate([
+    Controller('/webhook/vapiai'),
+    __param(0, Inject(VapiAiWebhookService)),
+    __metadata("design:paramtypes", [VapiAiWebhookService])
+], VapiAiWebhookController);
+
+function vapiaiWebhookServiceConfigFactory(configService) {
+    const config = {
+        webhookConfig: {
+            secret: configService.get(VAPI_AI_WEBHOOK_SECRET_TOKEN_ENV_VAR),
+            hmacSecret: configService.get(VAPI_AI_WEBHOOK_HMAC_SECRET_TOKEN_ENV_VAR),
+            verificationType: configService.get(VAPI_AI_WEBHOOK_SECRET_VERIFICATION_TYPE_ENV_VAR),
+            signaturePrefix: configService.get(VAPI_AI_WEBHOOK_SIGNATURE_PREFIX_ENV_VAR)
+        }
+    };
+    VapiAiWebhookServiceConfig.assertValidConfig(config);
+    return config;
+}
+let VapiAiWebhookModule = class VapiAiWebhookModule {
+};
+VapiAiWebhookModule = __decorate([
+    Module({
+        imports: [ConfigModule],
+        controllers: [VapiAiWebhookController],
+        providers: [
+            {
+                provide: VapiAiWebhookServiceConfig,
+                inject: [ConfigService],
+                useFactory: vapiaiWebhookServiceConfigFactory
+            },
+            VapiAiWebhookService
+        ],
+        exports: [VapiAiWebhookService]
+    })
+], VapiAiWebhookModule);
+
+const VAPI_AI_SECRET_TOKEN_ENV_VAR = 'VAPI_AI_SECRET_TOKEN';
+/**
+ * Configuration for VapiAiService
+ */
+class VapiAiServiceConfig {
+    vapiai;
+    static assertValidConfig(config) {
+        if (!config.vapiai.config.token) {
+            throw new Error('No Vapi.ai secret/token specified.');
+        }
+    }
+}
+
+let VapiAiApi = class VapiAiApi {
+    config;
+    vapiClient;
+    constructor(config) {
+        this.config = config;
+        this.vapiClient = new VapiClient(config.vapiai.config);
+    }
+    // MARK: Accessors
+    /**
+     * Gets a call by ID.
+     *
+     * @param callId
+     * @returns
+     */
+    getCall(callId) {
+        return this.vapiClient.calls.get({ id: callId });
+    }
+};
+VapiAiApi = __decorate([
+    Injectable(),
+    __param(0, Inject(VapiAiServiceConfig)),
+    __metadata("design:paramtypes", [VapiAiServiceConfig])
+], VapiAiApi);
+
+function vapiaiServiceConfigFactory(configService) {
+    const config = {
+        vapiai: {
+            config: {
+                token: configService.get(VAPI_AI_SECRET_TOKEN_ENV_VAR)
+            }
+        }
+    };
+    VapiAiServiceConfig.assertValidConfig(config);
+    return config;
+}
+let VapiAiModule = class VapiAiModule {
+};
+VapiAiModule = __decorate([
+    Module({
+        imports: [ConfigModule],
+        providers: [
+            {
+                provide: VapiAiServiceConfig,
+                inject: [ConfigService],
+                useFactory: vapiaiServiceConfigFactory
+            },
+            VapiAiApi
+        ],
+        exports: [VapiAiApi]
+    })
+], VapiAiModule);
+
+export { VAPI_AI_SECRET_TOKEN_ENV_VAR, VapiAiApi, VapiAiModule, VapiAiServiceConfig, VapiAiWebhookController, VapiAiWebhookModule, VapiAiWebhookService, vapiAiWebhookEvent, vapiAiWebhookEventVerifier, vapiaiEventHandlerConfigurerFactory, vapiaiEventHandlerFactory, vapiaiServiceConfigFactory, vapiaiWebhookServiceConfigFactory };

package/vapiai/package.json

@@ -1,9 +1,27 @@
 {
   "name": "@dereekb/nestjs/vapiai",
-  "version": "12.7.0",
-  "type": "commonjs",
-  "peerDependencies": {},
-  "dependencies": {},
-  "types": "./src/index.d.ts",
-  "main": "./src/index.js"
+  "version": "13.0.1",
+  "peerDependencies": {
+    "@dereekb/date": "13.0.1",
+    "@dereekb/model": "13.0.1",
+    "@dereekb/nestjs": "13.0.1",
+    "@dereekb/rxjs": "13.0.1",
+    "@dereekb/util": "13.0.1",
+    "@nestjs/common": "^11.0.0",
+    "@nestjs/config": "^4.0.0",
+    "@vapi-ai/server-sdk": "^0.11.0",
+    "express": "^5.0.0"
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "module": "./index.esm.js",
+      "types": "./index.d.ts",
+      "import": "./index.cjs.mjs",
+      "default": "./index.cjs.js"
+    }
+  },
+  "module": "./index.esm.js",
+  "main": "./index.cjs.js",
+  "types": "./index.d.ts"
 }

package/vapiai/src/lib/index.d.ts

@@ -1,6 +1,5 @@
 export * from './webhook';
 export * from './vapiai.module';
 export * from './vapiai.api';
-export * from './vapiai.module';
 export * from './vapiai.config';
 export * from './vapiai.type';