@dereekb/nestjs 12.6.21 → 13.0.0

package/openai/index.esm.js

@@ -0,0 +1,293 @@
+import { handlerFactory, handlerConfigurerFactory, handlerMappedSetFunctionFactory } from '@dereekb/util';
+import { RawBody } from '@dereekb/nestjs';
+import { Injectable, Inject, Logger, Post, Req, Controller, Module } from '@nestjs/common';
+import { OpenAI, InvalidWebhookSignatureError } from 'openai';
+import { ConfigService, ConfigModule } from '@nestjs/config';
+
+/**
+ * Creates a OpenAIWebhookEvent and treats the data as the input type.
+ *
+ * @param event
+ * @returns
+ */
+function openAIWebhookEvent(event) {
+  return event;
+}
+const openaiEventHandlerFactory = handlerFactory(x => x.type);
+const openaiEventHandlerConfigurerFactory = handlerConfigurerFactory({
+  configurerForAccessor: accessor => {
+    // eslint-disable-next-line
+    const fnWithKey = 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.');
+    }
+  }
+}
+
+let OpenAIApi = class OpenAIApi {
+  config;
+  openAIClient;
+  constructor(config) {
+    this.config = config;
+    this.openAIClient = new OpenAI(config.openai.config);
+  }
+};
+OpenAIApi = __decorate([Injectable(), __param(0, Inject(OpenAIServiceConfig)), __metadata("design:paramtypes", [OpenAIServiceConfig])], 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 InvalidWebhookSignatureError) {
+        valid = false;
+      } else {
+        throw e;
+      }
+    }
+    const result = {
+      valid,
+      event
+    };
+    return result;
+  };
+}
+
+/**
+ * Service that makes system changes based on OpenAI webhook events.
+ */
+let OpenAIWebhookService = class OpenAIWebhookService {
+  logger = new 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);
+    }
+  }
+};
+OpenAIWebhookService = __decorate([Injectable(), __param(0, Inject(OpenAIApi)), __param(1, Inject(OpenAIWebhookServiceConfig)), __metadata("design:paramtypes", [OpenAIApi, OpenAIWebhookServiceConfig])], OpenAIWebhookService);
+
+let OpenAIWebhookController = class OpenAIWebhookController {
+  _openaiWebhookService;
+  constructor(openaiWebhookService) {
+    this._openaiWebhookService = openaiWebhookService;
+  }
+  async handleOpenAIWebhook(req, rawBody) {
+    await this._openaiWebhookService.updateForWebhook(req, rawBody);
+  }
+};
+__decorate([Post(), __param(0, Req()), __param(1, RawBody()), __metadata("design:type", Function), __metadata("design:paramtypes", [Object, Object]), __metadata("design:returntype", Promise)], OpenAIWebhookController.prototype, "handleOpenAIWebhook", null);
+OpenAIWebhookController = __decorate([Controller('/webhook/openai'), __param(0, Inject(OpenAIWebhookService)), __metadata("design:paramtypes", [OpenAIWebhookService])], 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;
+}
+let OpenAIModule = class OpenAIModule {};
+OpenAIModule = __decorate([Module({
+  imports: [ConfigModule],
+  providers: [{
+    provide: OpenAIServiceConfig,
+    inject: [ConfigService],
+    useFactory: openAIServiceConfigFactory
+  }, OpenAIApi],
+  exports: [OpenAIApi]
+})], OpenAIModule);
+
+function openAIWebhookServiceConfigFactory(configService) {
+  const config = {
+    openaiWebhook: {
+      webhookSecret: configService.get(OPENAI_WEBHOOK_SECRET_TOKEN_ENV_VAR)
+    }
+  };
+  OpenAIWebhookServiceConfig.assertValidConfig(config);
+  return config;
+}
+let OpenAIWebhookModule = class OpenAIWebhookModule {};
+OpenAIWebhookModule = __decorate([Module({
+  imports: [ConfigModule, OpenAIModule],
+  controllers: [OpenAIWebhookController],
+  providers: [{
+    provide: OpenAIWebhookServiceConfig,
+    inject: [ConfigService],
+    useFactory: openAIWebhookServiceConfigFactory
+  }, OpenAIWebhookService],
+  exports: [OpenAIWebhookService]
+})], 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]));
+}
+
+export { OPENAI_API_KEY_ENV_VAR, OPENAI_BASE_URL_ENV_VAR, OPENAI_ORGANIZATION_ID_ENV_VAR, OPENAI_PROJECT_ID_ENV_VAR, OPENAI_WEBHOOK_SECRET_TOKEN_ENV_VAR, OpenAIApi, OpenAIModule, OpenAIServiceConfig, OpenAIWebhookController, OpenAIWebhookModule, OpenAIWebhookService, OpenAIWebhookServiceConfig, isParsedOpenAIJsonResponseWithJson, openAIJsonResponseFieldsMap, openAIServiceConfigFactory, openAIWebhookEvent, openAIWebhookEventVerifier, openAIWebhookServiceConfigFactory, openaiEventHandlerConfigurerFactory, openaiEventHandlerFactory, parseOpenAIJsonResponse };

package/openai/package.json

@@ -1,9 +1,28 @@
 {
   "name": "@dereekb/nestjs/openai",
-  "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/util": "13.0.0",
+    "@dereekb/date": "13.0.0",
+    "@dereekb/nestjs": "13.0.0",
+    "@dereekb/model": "13.0.0",
+    "@dereekb/rxjs": "13.0.0",
+    "core-js": "^3.0.0"
+  }
 }

package/openai/src/lib/index.d.ts

@@ -1,7 +1,6 @@
 export * from './webhook';
 export * from './openai.module';
 export * from './openai.api';
-export * from './openai.module';
 export * from './openai.config';
 export * from './openai.type';
 export * from './openai.util';

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

@@ -1,4 +1,4 @@
-import { RawBodyBuffer } from '@dereekb/nestjs';
+import { type RawBodyBuffer } from '@dereekb/nestjs';
 import { Request } from 'express';
 import { OpenAIWebhookService } from './webhook.openai.service';
 export declare class OpenAIWebhookController {

package/openai/src/lib/webhook/webhook.openai.d.ts

@@ -23,7 +23,7 @@ export type UntypedOpenAIWebhookEvent = UnwrapWebhookEvent;
  */
 export declare function openAIWebhookEvent<T extends UnwrapWebhookEvent = UnwrapWebhookEvent>(event: UntypedOpenAIWebhookEvent): OpenAIWebhookEvent<T>;
 export type OpenAIEventHandler = Handler<UntypedOpenAIWebhookEvent, OpenAIWebhookEventType>;
-export declare const openaiEventHandlerFactory: import("@dereekb/util").HandlerFactory<UnwrapWebhookEvent, "batch.cancelled" | "batch.completed" | "batch.expired" | "batch.failed" | "eval.run.canceled" | "eval.run.failed" | "eval.run.succeeded" | "fine_tuning.job.cancelled" | "fine_tuning.job.failed" | "fine_tuning.job.succeeded" | "response.cancelled" | "response.completed" | "response.failed" | "response.incomplete", boolean>;
+export declare const openaiEventHandlerFactory: import("@dereekb/util").HandlerFactory<UnwrapWebhookEvent, "batch.cancelled" | "batch.completed" | "batch.expired" | "batch.failed" | "eval.run.canceled" | "eval.run.failed" | "eval.run.succeeded" | "fine_tuning.job.cancelled" | "fine_tuning.job.failed" | "fine_tuning.job.succeeded" | "realtime.call.incoming" | "response.cancelled" | "response.completed" | "response.failed" | "response.incomplete", boolean>;
 export type OpenAIHandlerMappedSetFunction<T extends UnwrapWebhookEvent = UnwrapWebhookEvent> = HandlerMappedSetFunction<OpenAIWebhookEvent<T>>;
 export interface OpenAIEventHandlerConfigurer extends HandlerBindAccessor<UntypedOpenAIWebhookEvent, OpenAIWebhookEventType> {
     readonly handleBatchCancelled: OpenAIHandlerMappedSetFunction<BatchCancelledWebhookEvent>;
@@ -41,4 +41,4 @@ export interface OpenAIEventHandlerConfigurer extends HandlerBindAccessor<Untype
     readonly handleResponseFailed: OpenAIHandlerMappedSetFunction<ResponseFailedWebhookEvent>;
     readonly handleResponseIncomplete: OpenAIHandlerMappedSetFunction<ResponseIncompleteWebhookEvent>;
 }
-export declare const openaiEventHandlerConfigurerFactory: import("@dereekb/util").HandlerConfigurerFactory<OpenAIEventHandlerConfigurer, UnwrapWebhookEvent, "batch.cancelled" | "batch.completed" | "batch.expired" | "batch.failed" | "eval.run.canceled" | "eval.run.failed" | "eval.run.succeeded" | "fine_tuning.job.cancelled" | "fine_tuning.job.failed" | "fine_tuning.job.succeeded" | "response.cancelled" | "response.completed" | "response.failed" | "response.incomplete", boolean>;
+export declare const openaiEventHandlerConfigurerFactory: import("@dereekb/util").HandlerConfigurerFactory<OpenAIEventHandlerConfigurer, UnwrapWebhookEvent, "batch.cancelled" | "batch.completed" | "batch.expired" | "batch.failed" | "eval.run.canceled" | "eval.run.failed" | "eval.run.succeeded" | "fine_tuning.job.cancelled" | "fine_tuning.job.failed" | "fine_tuning.job.succeeded" | "realtime.call.incoming" | "response.cancelled" | "response.completed" | "response.failed" | "response.incomplete", boolean>;

package/openai/src/lib/webhook/webhook.openai.service.d.ts

@@ -10,7 +10,7 @@ export declare class OpenAIWebhookService {
     private readonly logger;
     private readonly _verifier;
     readonly handler: Handler<OpenAIWebhookEvent, OpenAIWebhookEventType>;
-    readonly configure: import("@dereekb/util").HandlerConfigurer<import("./webhook.openai").OpenAIEventHandlerConfigurer, import("openai/resources/webhooks").UnwrapWebhookEvent, "batch.cancelled" | "batch.completed" | "batch.expired" | "batch.failed" | "eval.run.canceled" | "eval.run.failed" | "eval.run.succeeded" | "fine_tuning.job.cancelled" | "fine_tuning.job.failed" | "fine_tuning.job.succeeded" | "response.cancelled" | "response.completed" | "response.failed" | "response.incomplete", boolean>;
+    readonly configure: import("@dereekb/util").HandlerConfigurer<import("./webhook.openai").OpenAIEventHandlerConfigurer, import("openai/resources/webhooks.mjs").UnwrapWebhookEvent, "batch.cancelled" | "batch.completed" | "batch.expired" | "batch.failed" | "eval.run.canceled" | "eval.run.failed" | "eval.run.succeeded" | "fine_tuning.job.cancelled" | "fine_tuning.job.failed" | "fine_tuning.job.succeeded" | "realtime.call.incoming" | "response.cancelled" | "response.completed" | "response.failed" | "response.incomplete", boolean>;
     constructor(openAiApi: OpenAIApi, openAIWebhookServiceConfig: OpenAIWebhookServiceConfig);
     updateForWebhook(req: Request, rawBody: Buffer): Promise<void>;
     updateForOpenAIEvent(event: OpenAIWebhookEvent): Promise<void>;

package/package.json

@@ -1,54 +1,84 @@
 {
   "name": "@dereekb/nestjs",
-  "version": "12.6.21",
-  "type": "commonjs",
+  "version": "13.0.0",
+  "types": "./src/index.d.ts",
+  "module": "./index.esm.js",
+  "main": "./index.cjs.js",
   "exports": {
     ".": {
       "types": "./src/index.d.ts",
-      "main": "./src/index.js",
-      "require": "./src/index.js",
-      "default": "./src/index.js"
+      "node": {
+        "require": "./index.cjs.js"
+      },
+      "browser": {
+        "require": "./index.cjs.js",
+        "import": "./index.esm.js"
+      },
+      "default": "./index.cjs.js"
     },
     "./stripe": {
       "types": "./stripe/src/index.d.ts",
-      "main": "./stripe/src/index.js",
-      "require": "./stripe/src/index.js",
-      "default": "./stripe/src/index.js"
+      "node": {
+        "require": "./stripe/index.cjs.js"
+      },
+      "browser": {
+        "require": "./stripe/index.cjs.js",
+        "import": "./stripe/index.esm.js"
+      },
+      "default": "./stripe/index.cjs.js"
     },
     "./mailgun": {
       "types": "./mailgun/src/index.d.ts",
-      "main": "./mailgun/src/index.js",
-      "require": "./mailgun/src/index.js",
-      "default": "./mailgun/src/index.js"
+      "node": {
+        "require": "./mailgun/index.cjs.js"
+      },
+      "browser": {
+        "require": "./mailgun/index.cjs.js",
+        "import": "./mailgun/index.esm.js"
+      },
+      "default": "./mailgun/index.cjs.js"
     },
     "./vapiai": {
       "types": "./vapiai/src/index.d.ts",
-      "main": "./vapiai/src/index.js",
-      "require": "./vapiai/src/index.js",
-      "default": "./vapiai/src/index.js"
+      "node": {
+        "require": "./vapiai/index.cjs.js"
+      },
+      "browser": {
+        "require": "./vapiai/index.cjs.js",
+        "import": "./vapiai/index.esm.js"
+      },
+      "default": "./vapiai/index.cjs.js"
     },
     "./openai": {
       "types": "./openai/src/index.d.ts",
-      "main": "./openai/src/index.js",
-      "require": "./openai/src/index.js",
-      "default": "./openai/src/index.js"
+      "node": {
+        "require": "./openai/index.cjs.js"
+      },
+      "browser": {
+        "require": "./openai/index.cjs.js",
+        "import": "./openai/index.esm.js"
+      },
+      "default": "./openai/index.cjs.js"
     },
     "./typeform": {
       "types": "./typeform/src/index.d.ts",
-      "main": "./typeform/src/index.js",
-      "require": "./typeform/src/index.js",
-      "default": "./typeform/src/index.js"
+      "node": {
+        "require": "./typeform/index.cjs.js"
+      },
+      "browser": {
+        "require": "./typeform/index.cjs.js",
+        "import": "./typeform/index.esm.js"
+      },
+      "default": "./typeform/index.cjs.js"
     }
   },
-  "main": "./src/index.js",
-  "types": "./src/index.d.ts",
   "peerDependencies": {
-    "@nestjs/common": "^10.0.0",
-    "express": "4.21.2",
-    "raw-body": "2.5.2",
-    "body-parser": "1.20.3",
-    "@nestjs/config": "^3.0.0",
-    "@dereekb/util": "*"
+    "@nestjs/common": "^11.0.0",
+    "express": "^5.0.0",
+    "raw-body": "^3.0.0",
+    "body-parser": "^2.0.0",
+    "@nestjs/config": "^4.0.0",
+    "@dereekb/util": "13.0.0"
   },
   "dependencies": {}
 }