@dereekb/nestjs 13.0.0 → 13.0.1

package/mailgun/package.json

@@ -1,28 +1,27 @@
 {
   "name": "@dereekb/nestjs/mailgun",
-  "version": "13.0.0",
-  "types": "./src/index.d.ts",
-  "module": "./index.esm.js",
-  "main": "./index.cjs.js",
+  "version": "13.0.1",
+  "peerDependencies": {
+    "@dereekb/date": "13.0.1",
+    "@dereekb/model": "13.0.1",
+    "@dereekb/nestjs": "13.0.1",
+    "@dereekb/rxjs": "13.0.1",
+    "@dereekb/util": "13.0.1",
+    "@nestjs/common": "^11.0.0",
+    "@nestjs/config": "^4.0.0",
+    "form-data": "^4.0.0",
+    "mailgun.js": "^12.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"
 }

package/openai/index.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require('./index.cjs.js').default;

package/openai/index.cjs.js

@@ -13,32 +13,32 @@ var config = require('@nestjs/config');
  * @returns
  */
 function openAIWebhookEvent(event) {
-  return event;
+    return event;
 }
-const openaiEventHandlerFactory = util.handlerFactory(x => x.type);
+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;
-  }
+    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';
@@ -46,12 +46,12 @@ 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.');
+    openaiWebhook;
+    static assertValidConfig(config) {
+        if (!config.openaiWebhook.webhookSecret) {
+            throw new Error('No OpenAI webhook secret specified.');
+        }
     }
-  }
 }
 
 /******************************************************************************
@@ -102,27 +102,33 @@ 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.');
+    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);
-  }
+    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);
+exports.OpenAIApi = __decorate([
+    common.Injectable(),
+    __param(0, common.Inject(OpenAIServiceConfig)),
+    __metadata("design:paramtypes", [OpenAIServiceConfig])
+], exports.OpenAIApi);
 
 /**
  * Verifies a OpenAI webhook event header.
@@ -131,124 +137,150 @@ exports.OpenAIApi = __decorate([common.Injectable(), __param(0, common.Inject(Op
  * @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
+    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;
     };
-    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);
+    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 updateForOpenAIEvent(event) {
-    const result = await this.handler(event);
-    if (!result) {
-      this.logger.warn('Received unexpected/unhandled OpenAI event.', event);
+    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.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);
-  }
+    _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);
+__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;
+    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);
+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;
+    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);
+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.
@@ -257,7 +289,7 @@ exports.OpenAIWebhookModule = __decorate([common.Module({
  * @returns
  */
 function isParsedOpenAIJsonResponseWithJson(response) {
-  return response.isJsonResponse && Boolean(response.jsonResponse) && Boolean(response.jsonResponseFieldMap);
+    return response.isJsonResponse && Boolean(response.jsonResponse) && Boolean(response.jsonResponseFieldMap);
 }
 /**
  * Parses the OpenAI response into a ParsedOpenAIJsonResponse.
@@ -266,21 +298,22 @@ function isParsedOpenAIJsonResponseWithJson(response) {
  * @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
-  };
+    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.
@@ -289,7 +322,7 @@ function parseOpenAIJsonResponse(response) {
  * @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]));
+    return new Map(response.fields.map((x) => [x.field_name, x.field_value]));
 }
 
 exports.OPENAI_API_KEY_ENV_VAR = OPENAI_API_KEY_ENV_VAR;

package/openai/index.cjs.mjs

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