@dereekb/nestjs 13.0.0 → 13.0.2

package/vapiai/index.esm.js

@@ -12,32 +12,32 @@ import { VapiClient } from '@vapi-ai/server-sdk';
  * @returns
  */
 function vapiAiWebhookEvent(event) {
-  return event;
+    return event;
 }
-const vapiaiEventHandlerFactory = handlerFactory(x => x.type, {
-  defaultResult: {
-    handled: true,
-    response: undefined
-  },
-  negativeResult: {
-    handled: true,
-    response: undefined
-  }
+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;
-  }
+    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;
+    }
 });
 
 /******************************************************************************
@@ -84,55 +84,42 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
  * @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
+    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;
     };
-    return result;
-  };
 }
 
 const VAPI_AI_WEBHOOK_SECRET_TOKEN_ENV_VAR = 'VAPI_AI_WEBHOOK_SECRET_TOKEN';
@@ -143,155 +130,181 @@ const VAPI_AI_WEBHOOK_SIGNATURE_PREFIX_ENV_VAR = 'VAPI_AI_WEBHOOK_SIGNATURE_PREF
  * 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.');
+    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);
+    logger = new Logger('VapiAiWebhookService');
+    _verifier;
+    handler = vapiaiEventHandlerFactory();
+    configure = vapiaiEventHandlerConfigurerFactory(this.handler);
+    constructor(vapiAiWebhookServiceConfig) {
+        this._verifier = vapiAiWebhookEventVerifier(vapiAiWebhookServiceConfig.webhookConfig);
     }
-    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);
+    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;
     }
-    return result;
-  }
 };
-VapiAiWebhookService = __decorate([Injectable(), __param(0, Inject(VapiAiWebhookServiceConfig)), __metadata("design:paramtypes", [VapiAiWebhookServiceConfig])], VapiAiWebhookService);
+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({});
+    _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);
+__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;
+    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);
+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.');
+    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
-    });
-  }
+    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);
+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;
+    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);
+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,28 +1,27 @@
 {
   "name": "@dereekb/nestjs/vapiai",
-  "version": "13.0.0",
-  "types": "./src/index.d.ts",
-  "module": "./index.esm.js",
-  "main": "./index.cjs.js",
+  "version": "13.0.2",
+  "peerDependencies": {
+    "@dereekb/date": "13.0.2",
+    "@dereekb/model": "13.0.2",
+    "@dereekb/nestjs": "13.0.2",
+    "@dereekb/rxjs": "13.0.2",
+    "@dereekb/util": "13.0.2",
+    "@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",
     ".": {
-      "types": "./src/index.d.ts",
-      "node": {
-        "require": "./index.cjs.js"
-      },
-      "browser": {
-        "require": "./index.cjs.js",
-        "import": "./index.esm.js"
-      },
+      "module": "./index.esm.js",
+      "types": "./index.d.ts",
+      "import": "./index.cjs.mjs",
       "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"
-  }
+  "module": "./index.esm.js",
+  "main": "./index.cjs.js",
+  "types": "./index.d.ts"
 }