@dereekb/nestjs 13.0.0 → 13.0.1

package/vapiai/index.cjs.js

@@ -14,32 +14,32 @@ var serverSdk = require('@vapi-ai/server-sdk');
  * @returns
  */
 function vapiAiWebhookEvent(event) {
-  return event;
+    return event;
 }
-const vapiaiEventHandlerFactory = util.handlerFactory(x => x.type, {
-  defaultResult: {
-    handled: true,
-    response: undefined
-  },
-  negativeResult: {
-    handled: true,
-    response: undefined
-  }
+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;
-  }
+    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;
+    }
 });
 
 /******************************************************************************
@@ -86,55 +86,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 = 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
+    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;
     };
-    return result;
-  };
 }
 
 const VAPI_AI_WEBHOOK_SECRET_TOKEN_ENV_VAR = 'VAPI_AI_WEBHOOK_SECRET_TOKEN';
@@ -145,156 +132,182 @@ 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.
  */
 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);
+    logger = new common.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;
-  }
 };
-exports.VapiAiWebhookService = __decorate([common.Injectable(), __param(0, common.Inject(VapiAiWebhookServiceConfig)), __metadata("design:paramtypes", [VapiAiWebhookServiceConfig])], exports.VapiAiWebhookService);
+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({});
+    _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);
+__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;
+    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);
+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.');
+    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
-    });
-  }
+    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);
+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;
+    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.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;

package/vapiai/index.cjs.mjs

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