@dereekb/nestjs 12.7.0 → 13.0.0

package/mailgun/src/lib/mailgun.util.d.ts

@@ -1,12 +1,17 @@
 import { type Maybe, type NameEmailPair, type ArrayOrValue } from '@dereekb/util';
 import { type MailgunTemplateEmailRequestRecipientVariablesConfig, type MailgunRecipient, type MailgunTemplateEmailRequest } from './mailgun';
-import { type NotificationMessageEntityKey } from '@dereekb/firebase';
 /**
  * The default template subject to use when batch sending emails.
  *
  * This pulls the subject from each recipient's user variables.
  */
 export declare const MAILGUN_BATCH_SEND_RECIPIENT_SUBJECT_TEMPLATE = "%recipient.subject%";
+/**
+ * Arbitrary key used by the sending configuration service for choosing a pre-configured entity.
+ *
+ * Typically used for customizing the "from" or "replyTo" addresses while maintaining a separation of concerns.
+ */
+export type MailgunRecipientBatchSendTargetEntityKey = string;
 /**
  * A MailgunRecipient paired with additional cc/bcc values. This type is used by an ExpandMailgunRecipientBatchSendTargetRequestFactory to
  * build properly configured MailgunTemplateEmailRequest values for one or more MailgunRecipientBatchSendTarget.
@@ -23,7 +28,7 @@ export interface MailgunRecipientBatchSendTarget extends MailgunRecipient {
      *
      * Is ignored if from is set.
      */
-    readonly fromKey?: Maybe<NotificationMessageEntityKey>;
+    readonly fromKey?: Maybe<MailgunRecipientBatchSendTargetEntityKey>;
     /**
      * The reply-to value to use for the request.
      *
@@ -35,7 +40,7 @@ export interface MailgunRecipientBatchSendTarget extends MailgunRecipient {
      *
      * Is ignored if replyTo is set.
      */
-    readonly replyToKey?: Maybe<NotificationMessageEntityKey>;
+    readonly replyToKey?: Maybe<MailgunRecipientBatchSendTargetEntityKey>;
     /**
      * Carbon copy recipients.
      *
@@ -47,7 +52,7 @@ export interface MailgunRecipientBatchSendTarget extends MailgunRecipient {
      *
      * Are merged with cc when building the request.
      */
-    readonly ccKeys?: Maybe<ArrayOrValue<NotificationMessageEntityKey>>;
+    readonly ccKeys?: Maybe<ArrayOrValue<MailgunRecipientBatchSendTargetEntityKey>>;
     /**
      * Blind carbon copy recipients.
      *
@@ -59,7 +64,7 @@ export interface MailgunRecipientBatchSendTarget extends MailgunRecipient {
      *
      * Are merged with bcc when building the request.
      */
-    readonly bccKeys?: Maybe<ArrayOrValue<NotificationMessageEntityKey>>;
+    readonly bccKeys?: Maybe<ArrayOrValue<MailgunRecipientBatchSendTargetEntityKey>>;
 }
 /**
  * Composite key from the (lowercased) from/replyTo email addresses used to group MailgunRecipientBatchSendTarget values.
@@ -100,7 +105,7 @@ export interface ExpandMailgunRecipientBatchSendTargetRequestFactoryConfig {
     /**
      * Optional lookup for notification message entity keys.
      */
-    readonly notificationMessageEntityKeyRecipientLookup?: Maybe<NotificationMessageEntityKeyRecipientLookup>;
+    readonly mailgunRecipientBatchSendTargetEntityKeyRecipientLookup?: Maybe<MailgunRecipientBatchSendTargetEntityKeyRecipientLookup>;
     /**
      * Whether or not to override the carbon copy variables with the carbon copy key recipients.
      *
@@ -125,11 +130,11 @@ export declare function expandMailgunRecipientBatchSendTargetRequestFactory(conf
 /**
  * A lookup for notification message entity keys to recipients.
  */
-export interface NotificationMessageEntityKeyRecipientLookup {
+export interface MailgunRecipientBatchSendTargetEntityKeyRecipientLookup {
     /**
      * The map of recipients for the given keys.
      */
-    readonly recipientsMap: Map<NotificationMessageEntityKey, NameEmailPair>;
+    readonly recipientsMap: Map<MailgunRecipientBatchSendTargetEntityKey, NameEmailPair>;
     /**
      * Returns the recipient for the given key, or the default recipient if the key is not found. If the input is nullish, returns the default recipient if one is defined, otherwise undefined.
      *
@@ -137,27 +142,27 @@ export interface NotificationMessageEntityKeyRecipientLookup {
      * @param defaultRecipient The default recipient to return if the key is not found.
      * @returns The recipient for the given key, or the default recipient if the key is not found.
      */
-    getRecipientOrDefaultForKey(input: Maybe<NotificationMessageEntityKey>, defaultRecipient: NameEmailPair): NameEmailPair;
-    getRecipientOrDefaultForKey(input: Maybe<NotificationMessageEntityKey>, defaultRecipient?: Maybe<NameEmailPair>): Maybe<NameEmailPair>;
+    getRecipientOrDefaultForKey(input: Maybe<MailgunRecipientBatchSendTargetEntityKey>, defaultRecipient: NameEmailPair): NameEmailPair;
+    getRecipientOrDefaultForKey(input: Maybe<MailgunRecipientBatchSendTargetEntityKey>, defaultRecipient?: Maybe<NameEmailPair>): Maybe<NameEmailPair>;
     /**
      * Returns the recipients for the given keys. If the input is nullish, returns undefined.
      *
      * @param input The keys to look up.
      * @returns The recipients for the given keys.
      */
-    getRecipientsForKeys(input: Maybe<ArrayOrValue<NotificationMessageEntityKey>>): Maybe<NameEmailPair[]>;
-    getRecipientsForKeys(input: ArrayOrValue<NotificationMessageEntityKey>): NameEmailPair[];
+    getRecipientsForKeys(input: Maybe<ArrayOrValue<MailgunRecipientBatchSendTargetEntityKey>>): Maybe<NameEmailPair[]>;
+    getRecipientsForKeys(input: ArrayOrValue<MailgunRecipientBatchSendTargetEntityKey>): NameEmailPair[];
 }
 /**
- * Configuration for notificationMessageEntityKeyRecipientLookup().
+ * Configuration for mailgunRecipientBatchSendTargetEntityKeyRecipientLookup().
  */
-export interface NotificationMessageEntityKeyRecipientLookupConfig {
-    readonly recipientsMap: Map<NotificationMessageEntityKey, NameEmailPair>;
+export interface MailgunRecipientBatchSendTargetEntityKeyRecipientLookupConfig {
+    readonly recipientsMap: Map<MailgunRecipientBatchSendTargetEntityKey, NameEmailPair>;
 }
 /**
- * Creates a NotificationMessageEntityKeyRecipientLookup given the input configuration.
+ * Creates a MailgunRecipientBatchSendTargetEntityKeyRecipientLookup given the input configuration.
  *
  * @param config The configuration for the lookup.
  * @returns The lookup.
  */
-export declare function notificationMessageEntityKeyRecipientLookup(config: NotificationMessageEntityKeyRecipientLookupConfig): NotificationMessageEntityKeyRecipientLookup;
+export declare function mailgunRecipientBatchSendTargetEntityKeyRecipientLookup(config: MailgunRecipientBatchSendTargetEntityKeyRecipientLookupConfig): MailgunRecipientBatchSendTargetEntityKeyRecipientLookup;

package/openai/index.cjs.js

@@ -0,0 +1,310 @@
+'use strict';
+
+var util = require('@dereekb/util');
+var nestjs = require('@dereekb/nestjs');
+var common = require('@nestjs/common');
+var openai = require('openai');
+var config = require('@nestjs/config');
+
+/**
+ * Creates a OpenAIWebhookEvent and treats the data as the input type.
+ *
+ * @param event
+ * @returns
+ */
+function openAIWebhookEvent(event) {
+  return event;
+}
+const openaiEventHandlerFactory = util.handlerFactory(x => x.type);
+const openaiEventHandlerConfigurerFactory = util.handlerConfigurerFactory({
+  configurerForAccessor: accessor => {
+    // eslint-disable-next-line
+    const fnWithKey = util.handlerMappedSetFunctionFactory(accessor, openAIWebhookEvent);
+    const configurer = {
+      ...accessor,
+      handleBatchCancelled: fnWithKey('batch.cancelled'),
+      handleBatchCompleted: fnWithKey('batch.completed'),
+      handleBatchExpired: fnWithKey('batch.expired'),
+      handleBatchFailed: fnWithKey('batch.failed'),
+      handleEvalRunCanceled: fnWithKey('eval.run.canceled'),
+      handleEvalRunFailed: fnWithKey('eval.run.failed'),
+      handleEvalRunSucceeded: fnWithKey('eval.run.succeeded'),
+      handleFineTuningJobCancelled: fnWithKey('fine_tuning.job.cancelled'),
+      handleFineTuningJobFailed: fnWithKey('fine_tuning.job.failed'),
+      handleFineTuningJobSucceeded: fnWithKey('fine_tuning.job.succeeded'),
+      handleResponseCancelled: fnWithKey('response.cancelled'),
+      handleResponseCompleted: fnWithKey('response.completed'),
+      handleResponseFailed: fnWithKey('response.failed'),
+      handleResponseIncomplete: fnWithKey('response.incomplete')
+    };
+    return configurer;
+  }
+});
+
+const OPENAI_WEBHOOK_SECRET_TOKEN_ENV_VAR = 'OPENAI_WEBHOOK_SECRET_TOKEN';
+/**
+ * Configuration for OpenAIService
+ */
+class OpenAIWebhookServiceConfig {
+  openaiWebhook;
+  static assertValidConfig(config) {
+    if (!config.openaiWebhook.webhookSecret) {
+      throw new Error('No OpenAI 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;
+};
+
+/**
+ * Default environment variable for the OpenAI API key.
+ */
+const OPENAI_API_KEY_ENV_VAR = 'OPENAI_API_KEY';
+const OPENAI_BASE_URL_ENV_VAR = 'OPENAI_BASE_URL';
+const OPENAI_ORGANIZATION_ID_ENV_VAR = 'OPENAI_ORG_ID';
+const OPENAI_PROJECT_ID_ENV_VAR = 'OPENAI_PROJECT_ID';
+/**
+ * Configuration for OpenAIService
+ */
+class OpenAIServiceConfig {
+  openai;
+  static assertValidConfig(config) {
+    if (!config.openai.config.apiKey) {
+      throw new Error('No OpenAI API key specified.');
+    } else if (!config.openai.config.organization) {
+      throw new Error('No OpenAI organization specified.');
+    } else if (!config.openai.config.project) {
+      throw new Error('No OpenAI project specified.');
+    }
+  }
+}
+
+exports.OpenAIApi = class OpenAIApi {
+  config;
+  openAIClient;
+  constructor(config) {
+    this.config = config;
+    this.openAIClient = new openai.OpenAI(config.openai.config);
+  }
+};
+exports.OpenAIApi = __decorate([common.Injectable(), __param(0, common.Inject(OpenAIServiceConfig)), __metadata("design:paramtypes", [OpenAIServiceConfig])], exports.OpenAIApi);
+
+/**
+ * Verifies a OpenAI webhook event header.
+ *
+ * @param vapiSecretTokenGetter The OpenAI secret token. The Vapi client allows for using an AsyncGetterOrValue type, so the verifier supports that as well.
+ * @returns A function that verifies a OpenAI webhook event.
+ */
+function openAIWebhookEventVerifier(config) {
+  const {
+    secret,
+    client
+  } = config;
+  return async (request, rawBody) => {
+    const headers = request.headers;
+    const requestBodyString = String(request.body);
+    let event;
+    let valid = false;
+    try {
+      event = await client.webhooks.unwrap(requestBodyString, headers, secret);
+      valid = true;
+    } catch (e) {
+      if (e instanceof openai.InvalidWebhookSignatureError) {
+        valid = false;
+      } else {
+        throw e;
+      }
+    }
+    const result = {
+      valid,
+      event
+    };
+    return result;
+  };
+}
+
+/**
+ * Service that makes system changes based on OpenAI webhook events.
+ */
+exports.OpenAIWebhookService = class OpenAIWebhookService {
+  logger = new common.Logger('OpenAIWebhookService');
+  _verifier;
+  handler = openaiEventHandlerFactory();
+  configure = openaiEventHandlerConfigurerFactory(this.handler);
+  constructor(openAiApi, openAIWebhookServiceConfig) {
+    const {
+      webhookSecret
+    } = openAIWebhookServiceConfig.openaiWebhook;
+    this._verifier = openAIWebhookEventVerifier({
+      secret: webhookSecret,
+      client: openAiApi.openAIClient
+    });
+  }
+  async updateForWebhook(req, rawBody) {
+    const result = await this._verifier(req, rawBody);
+    if (!result.valid) {
+      this.logger.warn('Received invalid OpenAI event.', req);
+    } else {
+      await this.updateForOpenAIEvent(result.event);
+    }
+  }
+  async updateForOpenAIEvent(event) {
+    const result = await this.handler(event);
+    if (!result) {
+      this.logger.warn('Received unexpected/unhandled OpenAI event.', event);
+    }
+  }
+};
+exports.OpenAIWebhookService = __decorate([common.Injectable(), __param(0, common.Inject(exports.OpenAIApi)), __param(1, common.Inject(OpenAIWebhookServiceConfig)), __metadata("design:paramtypes", [exports.OpenAIApi, OpenAIWebhookServiceConfig])], exports.OpenAIWebhookService);
+
+exports.OpenAIWebhookController = class OpenAIWebhookController {
+  _openaiWebhookService;
+  constructor(openaiWebhookService) {
+    this._openaiWebhookService = openaiWebhookService;
+  }
+  async handleOpenAIWebhook(req, rawBody) {
+    await this._openaiWebhookService.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.OpenAIWebhookController.prototype, "handleOpenAIWebhook", null);
+exports.OpenAIWebhookController = __decorate([common.Controller('/webhook/openai'), __param(0, common.Inject(exports.OpenAIWebhookService)), __metadata("design:paramtypes", [exports.OpenAIWebhookService])], exports.OpenAIWebhookController);
+
+function openAIServiceConfigFactory(configService) {
+  const config = {
+    openai: {
+      config: {
+        apiKey: configService.get(OPENAI_API_KEY_ENV_VAR),
+        baseURL: configService.get(OPENAI_BASE_URL_ENV_VAR) ?? undefined,
+        organization: configService.get(OPENAI_ORGANIZATION_ID_ENV_VAR),
+        project: configService.get(OPENAI_PROJECT_ID_ENV_VAR)
+      }
+    }
+  };
+  OpenAIServiceConfig.assertValidConfig(config);
+  return config;
+}
+exports.OpenAIModule = class OpenAIModule {};
+exports.OpenAIModule = __decorate([common.Module({
+  imports: [config.ConfigModule],
+  providers: [{
+    provide: OpenAIServiceConfig,
+    inject: [config.ConfigService],
+    useFactory: openAIServiceConfigFactory
+  }, exports.OpenAIApi],
+  exports: [exports.OpenAIApi]
+})], exports.OpenAIModule);
+
+function openAIWebhookServiceConfigFactory(configService) {
+  const config = {
+    openaiWebhook: {
+      webhookSecret: configService.get(OPENAI_WEBHOOK_SECRET_TOKEN_ENV_VAR)
+    }
+  };
+  OpenAIWebhookServiceConfig.assertValidConfig(config);
+  return config;
+}
+exports.OpenAIWebhookModule = class OpenAIWebhookModule {};
+exports.OpenAIWebhookModule = __decorate([common.Module({
+  imports: [config.ConfigModule, exports.OpenAIModule],
+  controllers: [exports.OpenAIWebhookController],
+  providers: [{
+    provide: OpenAIWebhookServiceConfig,
+    inject: [config.ConfigService],
+    useFactory: openAIWebhookServiceConfigFactory
+  }, exports.OpenAIWebhookService],
+  exports: [exports.OpenAIWebhookService]
+})], exports.OpenAIWebhookModule);
+
+/**
+ * Returns true if the response has a json response.
+ *
+ * @param response
+ * @returns
+ */
+function isParsedOpenAIJsonResponseWithJson(response) {
+  return response.isJsonResponse && Boolean(response.jsonResponse) && Boolean(response.jsonResponseFieldMap);
+}
+/**
+ * Parses the OpenAI response into a ParsedOpenAIJsonResponse.
+ *
+ * @param response The OpenAI response to parse.
+ * @returns The parsed OpenAI response.
+ */
+function parseOpenAIJsonResponse(response) {
+  const output_text = typeof response === 'string' ? response : response.output_text;
+  let jsonResponse = undefined;
+  let jsonResponseFieldMap = undefined;
+  try {
+    jsonResponse = JSON.parse(output_text);
+    jsonResponseFieldMap = openAIJsonResponseFieldsMap(jsonResponse);
+  } catch (e) {
+    // ignore
+  }
+  return {
+    output_text,
+    isJsonResponse: Boolean(jsonResponse),
+    jsonResponse,
+    jsonResponseFieldMap
+  };
+}
+/**
+ * Creates a map of the OpenAI json response fields.
+ *
+ * @param response The OpenAI json response to create a map from.
+ * @returns The map of the OpenAI json response fields.
+ */
+function openAIJsonResponseFieldsMap(response) {
+  return new Map(response.fields.map(x => [x.field_name, x.field_value]));
+}
+
+exports.OPENAI_API_KEY_ENV_VAR = OPENAI_API_KEY_ENV_VAR;
+exports.OPENAI_BASE_URL_ENV_VAR = OPENAI_BASE_URL_ENV_VAR;
+exports.OPENAI_ORGANIZATION_ID_ENV_VAR = OPENAI_ORGANIZATION_ID_ENV_VAR;
+exports.OPENAI_PROJECT_ID_ENV_VAR = OPENAI_PROJECT_ID_ENV_VAR;
+exports.OPENAI_WEBHOOK_SECRET_TOKEN_ENV_VAR = OPENAI_WEBHOOK_SECRET_TOKEN_ENV_VAR;
+exports.OpenAIServiceConfig = OpenAIServiceConfig;
+exports.OpenAIWebhookServiceConfig = OpenAIWebhookServiceConfig;
+exports.isParsedOpenAIJsonResponseWithJson = isParsedOpenAIJsonResponseWithJson;
+exports.openAIJsonResponseFieldsMap = openAIJsonResponseFieldsMap;
+exports.openAIServiceConfigFactory = openAIServiceConfigFactory;
+exports.openAIWebhookEvent = openAIWebhookEvent;
+exports.openAIWebhookEventVerifier = openAIWebhookEventVerifier;
+exports.openAIWebhookServiceConfigFactory = openAIWebhookServiceConfigFactory;
+exports.openaiEventHandlerConfigurerFactory = openaiEventHandlerConfigurerFactory;
+exports.openaiEventHandlerFactory = openaiEventHandlerFactory;
+exports.parseOpenAIJsonResponse = parseOpenAIJsonResponse;

package/openai/index.d.ts

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