@dereekb/nestjs 12.6.21 → 13.0.0

package/typeform/index.cjs.js

@@ -0,0 +1,378 @@
+'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 apiClient = require('@typeform/api-client');
+
+/**
+ * Creates a TypeformWebhookEvent and treats the data as the input type.
+ *
+ * @param event
+ * @returns
+ */
+function typeFormWebhookEvent(event) {
+  return event;
+}
+const typeformEventHandlerFactory = util.handlerFactory(x => x.event_type);
+const typeformEventHandlerConfigurerFactory = util.handlerConfigurerFactory({
+  configurerForAccessor: accessor => {
+    // eslint-disable-next-line
+    const fnWithKey = util.handlerMappedSetFunctionFactory(accessor, typeFormWebhookEvent);
+    const configurer = {
+      ...accessor,
+      handleFormResponse: fnWithKey('form_response')
+    };
+    return configurer;
+  }
+});
+
+const TYPEFORM_WEBHOOK_SECRET_TOKEN_ENV_VAR = 'TYPEFORM_WEBHOOK_SECRET_TOKEN';
+/**
+ * Configuration for TypeformService
+ */
+class TypeformWebhookServiceConfig {
+  typeformWebhook;
+  static assertValidConfig(config) {
+    if (!config.typeformWebhook.secretToken) {
+      throw new Error('No Typeform webhook secret specified.');
+    }
+  }
+}
+
+/******************************************************************************
+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 Typeform webhook event header.
+ *
+ * @param vapiSecretTokenGetter The Typeform secret token. The Vapi client allows for using an AsyncGetterOrValue type, so the verifier supports that as well.
+ * @returns A function that verifies a Typeform webhook event.
+ */
+function typeFormWebhookEventVerifier(config) {
+  const {
+    secret
+  } = config;
+  return async (request, rawBody) => {
+    const requestBodyString = String(request.body);
+    const headers = request.headers;
+    const vapiSignature = headers['typeform-signature'];
+    const hashForVerify = crypto.createHmac('sha256', secret).update(requestBodyString).digest('base64');
+    const signature = `sha256=${hashForVerify}`;
+    const valid = vapiSignature === signature;
+    const event = JSON.parse(requestBodyString);
+    const result = {
+      valid,
+      event
+    };
+    return result;
+  };
+}
+
+/**
+ * Service that makes system changes based on Typeform webhook events.
+ */
+exports.TypeformWebhookService = class TypeformWebhookService {
+  logger = new common.Logger('TypeformWebhookService');
+  _verifier;
+  handler = typeformEventHandlerFactory();
+  configure = typeformEventHandlerConfigurerFactory(this.handler);
+  constructor(typeFormWebhookServiceConfig) {
+    const {
+      secretToken: webhookSecret
+    } = typeFormWebhookServiceConfig.typeformWebhook;
+    this._verifier = typeFormWebhookEventVerifier({
+      secret: webhookSecret
+    });
+  }
+  async updateForWebhook(req, rawBody) {
+    const result = await this._verifier(req, rawBody);
+    if (!result.valid) {
+      this.logger.warn('Received invalid Typeform event.', req);
+    } else {
+      await this.updateForTypeformEvent(result.event);
+    }
+  }
+  async updateForTypeformEvent(event) {
+    const result = await this.handler(event);
+    if (!result) {
+      this.logger.warn('Received unexpected/unhandled Typeform event.', event);
+    }
+  }
+};
+exports.TypeformWebhookService = __decorate([common.Injectable(), __param(0, common.Inject(TypeformWebhookServiceConfig)), __metadata("design:paramtypes", [TypeformWebhookServiceConfig])], exports.TypeformWebhookService);
+
+exports.TypeformWebhookController = class TypeformWebhookController {
+  _typeformWebhookService;
+  constructor(typeformWebhookService) {
+    this._typeformWebhookService = typeformWebhookService;
+  }
+  async handleTypeformWebhook(req, rawBody) {
+    await this._typeformWebhookService.updateForWebhook(req, rawBody);
+  }
+};
+__decorate([common.Post(), __param(0, common.Req()), __param(1, nestjs.RawBody()), __metadata("design:type", Function), __metadata("design:paramtypes", [Object, Object]), __metadata("design:returntype", Promise)], exports.TypeformWebhookController.prototype, "handleTypeformWebhook", null);
+exports.TypeformWebhookController = __decorate([common.Controller('/webhook/typeform'), __param(0, common.Inject(exports.TypeformWebhookService)), __metadata("design:paramtypes", [exports.TypeformWebhookService])], exports.TypeformWebhookController);
+
+function typeFormWebhookServiceConfigFactory(configService) {
+  const config = {
+    typeformWebhook: {
+      secretToken: configService.get(TYPEFORM_WEBHOOK_SECRET_TOKEN_ENV_VAR)
+    }
+  };
+  TypeformWebhookServiceConfig.assertValidConfig(config);
+  return config;
+}
+exports.TypeformWebhookModule = class TypeformWebhookModule {};
+exports.TypeformWebhookModule = __decorate([common.Module({
+  imports: [config.ConfigModule],
+  controllers: [exports.TypeformWebhookController],
+  providers: [{
+    provide: TypeformWebhookServiceConfig,
+    inject: [config.ConfigService],
+    useFactory: typeFormWebhookServiceConfigFactory
+  }, exports.TypeformWebhookService],
+  exports: [exports.TypeformWebhookService]
+})], exports.TypeformWebhookModule);
+
+function findTypeformTemplateRefsInString(input) {
+  /**
+   * Used to search the input string to find field refs like the following:
+   *
+   * {{field:8f7adc1e-c3b8-44bd-b00c-1b6c8de65797}}
+   * {{field:01H7G3DCZ1FZV4KYZGM755MXZZ}}
+   */
+  const regex = /\{\{\s*(field)\s*:\s*([A-Za-z0-9-]+)\s*\}\}/g;
+  const matches = input.matchAll(regex);
+  const result = [];
+  for (const regexMatch of matches) {
+    const match = regexMatch[0]; // {{field:8f7adc1e-c3b8-44bd-b00c-1b6c8de65797}}
+    const type = regexMatch[1]; // field
+    const ref = regexMatch[2]; // 8f7adc1e-c3b8-44bd-b00c-1b6c8de65797
+    result.push({
+      type,
+      match,
+      ref
+    });
+  }
+  return result;
+}
+
+/**
+ * Creates an ExpandedTypeformWebhookFormResponse from a TypeformWebhookFormResponse.
+ */
+function expandTypeformWebhookFormResponse(formResponse) {
+  const {
+    answers,
+    definition
+  } = formResponse;
+  const {
+    fields = []
+  } = definition;
+  const questionFieldMap = new Map(util.filterMaybeArrayValues(fields.map(x => x.id ? [x.id, x] : null)));
+  const answerValuePairs = answers.map(answer => makeTypeformFormResponseAnswerValuePair(answer));
+  const answerValueFieldRefMap = new Map(util.filterMaybeArrayValues(answerValuePairs.map(x => x.answer.field.ref ? [x.answer.field.ref, x] : null)));
+  function expandQuestionTitle(title) {
+    let result = title;
+    let hadReferenceInTitle = false;
+    if (result) {
+      const refsInTitle = findTypeformTemplateRefsInString(result);
+      if (refsInTitle.length > 0) {
+        hadReferenceInTitle = true;
+        refsInTitle.forEach(refInTitle => {
+          const {
+            match,
+            ref
+          } = refInTitle;
+          const fullMatch = match;
+          const answer = answerValueFieldRefMap.get(ref);
+          const answerValue = answer?.valueString;
+          const replacedTitle = result.replaceAll(fullMatch, answerValue || '');
+          result = replacedTitle;
+        });
+      }
+    }
+    return {
+      questionTitle: result,
+      hadReferenceInTitle
+    };
+  }
+  const pairs = answerValuePairs.map(answerValue => {
+    const definitionField = questionFieldMap.get(answerValue.answer.field.id);
+    const {
+      questionTitle,
+      hadReferenceInTitle
+    } = expandQuestionTitle(definitionField?.title);
+    const result = {
+      ...answerValue,
+      definitionField,
+      questionTitle,
+      hadReferenceInTitle
+    };
+    return result;
+  });
+  return {
+    formResponse,
+    pairs
+  };
+}
+/**
+ * Creates a TypeformFormQuestionAnswerPair from a TypeformFormResponseAnswer.
+ */
+function makeTypeformFormResponseAnswerValuePair(answer) {
+  let value;
+  let valueString;
+  switch (answer.type) {
+    case 'number':
+      value = answer.number;
+      valueString = answer.number.toString();
+      break;
+    case 'boolean':
+      value = answer.boolean;
+      valueString = answer.boolean.toString();
+      break;
+    case 'email':
+      value = answer.email;
+      valueString = answer.email;
+      break;
+    case 'phone_number':
+      value = answer.phone_number;
+      valueString = answer.phone_number;
+      break;
+    case 'date':
+      value = answer.date;
+      valueString = answer.date;
+      break;
+    case 'payment':
+      value = answer.payment;
+      valueString = answer.payment.amount.toString();
+      break;
+    case 'text':
+      value = answer.text;
+      valueString = answer.text;
+      break;
+    case 'choices':
+      value = answer.choices;
+      valueString = answer.choices.other || util.joinStringsWithCommas(answer.choices.labels);
+      break;
+    case 'choice':
+      value = answer.choice;
+      valueString = answer.choice.other || answer.choice.label || '';
+      break;
+    case 'url':
+      value = answer.url;
+      valueString = answer.url;
+      break;
+    case 'file_url':
+      value = answer.file_url;
+      valueString = answer.file_url;
+      break;
+  }
+  const result = {
+    answer,
+    value,
+    valueString
+  };
+  return result;
+}
+
+/**
+ * Default environment variable for the Typeform API key.
+ */
+const TYPEFORM_SECRET_TOKEN_ENV_VAR = 'TYPEFORM_SECRET_TOKEN';
+const TYPEFORM_BASE_URL_ENV_VAR = 'TYPEFORM_BASE_URL';
+/**
+ * Configuration for TypeformService
+ */
+class TypeformServiceConfig {
+  typeform;
+  static assertValidConfig(config) {
+    if (!config.typeform.config.token) {
+      throw new Error('No Typeform token specified.');
+    }
+  }
+}
+
+exports.TypeformApi = class TypeformApi {
+  config;
+  client;
+  constructor(config) {
+    this.config = config;
+    this.client = apiClient.createClient(config.typeform.config);
+  }
+};
+exports.TypeformApi = __decorate([common.Injectable(), __param(0, common.Inject(TypeformServiceConfig)), __metadata("design:paramtypes", [TypeformServiceConfig])], exports.TypeformApi);
+
+function typeFormServiceConfigFactory(configService) {
+  const config = {
+    typeform: {
+      config: {
+        token: configService.get(TYPEFORM_SECRET_TOKEN_ENV_VAR),
+        baseURL: configService.get(TYPEFORM_BASE_URL_ENV_VAR) ?? undefined
+      }
+    }
+  };
+  TypeformServiceConfig.assertValidConfig(config);
+  return config;
+}
+exports.TypeformModule = class TypeformModule {};
+exports.TypeformModule = __decorate([common.Module({
+  imports: [config.ConfigModule],
+  providers: [{
+    provide: TypeformServiceConfig,
+    inject: [config.ConfigService],
+    useFactory: typeFormServiceConfigFactory
+  }, exports.TypeformApi],
+  exports: [exports.TypeformApi]
+})], exports.TypeformModule);
+
+exports.TYPEFORM_BASE_URL_ENV_VAR = TYPEFORM_BASE_URL_ENV_VAR;
+exports.TYPEFORM_SECRET_TOKEN_ENV_VAR = TYPEFORM_SECRET_TOKEN_ENV_VAR;
+exports.TYPEFORM_WEBHOOK_SECRET_TOKEN_ENV_VAR = TYPEFORM_WEBHOOK_SECRET_TOKEN_ENV_VAR;
+exports.TypeformServiceConfig = TypeformServiceConfig;
+exports.TypeformWebhookServiceConfig = TypeformWebhookServiceConfig;
+exports.expandTypeformWebhookFormResponse = expandTypeformWebhookFormResponse;
+exports.findTypeformTemplateRefsInString = findTypeformTemplateRefsInString;
+exports.makeTypeformFormResponseAnswerValuePair = makeTypeformFormResponseAnswerValuePair;
+exports.typeFormServiceConfigFactory = typeFormServiceConfigFactory;
+exports.typeFormWebhookEvent = typeFormWebhookEvent;
+exports.typeFormWebhookEventVerifier = typeFormWebhookEventVerifier;
+exports.typeFormWebhookServiceConfigFactory = typeFormWebhookServiceConfigFactory;
+exports.typeformEventHandlerConfigurerFactory = typeformEventHandlerConfigurerFactory;
+exports.typeformEventHandlerFactory = typeformEventHandlerFactory;

package/typeform/index.d.ts

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