@dereekb/nestjs 12.6.21 → 13.0.0

package/vapiai/index.cjs.js

@@ -0,0 +1,306 @@
+'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.d.ts

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

package/vapiai/index.esm.js

@@ -0,0 +1,297 @@
+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,28 @@
 {
   "name": "@dereekb/nestjs/vapiai",
-  "version": "12.6.21",
-  "type": "commonjs",
-  "peerDependencies": {},
-  "dependencies": {},
+  "version": "13.0.0",
   "types": "./src/index.d.ts",
-  "main": "./src/index.js"
+  "module": "./index.esm.js",
+  "main": "./index.cjs.js",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "node": {
+        "require": "./index.cjs.js"
+      },
+      "browser": {
+        "require": "./index.cjs.js",
+        "import": "./index.esm.js"
+      },
+      "default": "./index.cjs.js"
+    }
+  },
+  "peerDependencies": {
+    "@dereekb/date": "13.0.0",
+    "@dereekb/nestjs": "13.0.0",
+    "@dereekb/model": "13.0.0",
+    "@dereekb/rxjs": "13.0.0",
+    "@dereekb/util": "13.0.0",
+    "core-js": "^3.0.0"
+  }
 }

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';

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

@@ -1,3 +1,4 @@
+import { type MaybeSo } from '@dereekb/util';
 import { type Vapi } from '@vapi-ai/server-sdk';
 /**
  * Secret token used by Vapi.ai for making requests.
@@ -30,7 +31,7 @@ export type VapiApiWebhookEventVerificationType = 'none' | 'secret' | 'hmac';
 /**
  * Cost item used by Vapi.ai.
  */
-export type VapiCostsItem = Vapi.ServerMessageEndOfCallReport.Costs.Item;
+export type VapiCostsItem = MaybeSo<Vapi.ServerMessageEndOfCallReport['costs']>[number];
 /**
  * Vapi.ai Call identifier
  */
@@ -40,6 +41,7 @@ export type VapiCallId = string;
  */
 export type VapiAssistantId = string;
 export type VapiTranscript = string;
+export type VapiChatMessage = MaybeSo<Vapi.Chat['messages']>[number];
 export interface VapiTranscriptRef {
     transcript?: VapiTranscript;
 }

package/vapiai/src/lib/webhook/webhook.vapiai.controller.d.ts

@@ -1,4 +1,4 @@
-import { RawBodyBuffer } from '@dereekb/nestjs';
+import { type RawBodyBuffer } from '@dereekb/nestjs';
 import { Request, Response } from 'express';
 import { VapiAiWebhookService } from './webhook.vapiai.service';
 export declare class VapiAiWebhookController {