gcf-common-lib 0.31.62 → 0.32.62

package/eslint.config.mjs

@@ -0,0 +1,33 @@
+import globals from 'globals';
+import pluginJs from '@eslint/js';
+import tseslint from 'typescript-eslint';
+import eslintPluginUnicorn from 'eslint-plugin-unicorn';
+import pluginPromise from 'eslint-plugin-promise';
+// import pluginLodash from 'eslint-plugin-lodash';
+
+/** @type {import('eslint').Linter.Config[]} */
+export default [
+  { files: ['**/*.{js,mjs,cjs,ts}'] },
+  { files: ['**/*.js'], languageOptions: { sourceType: 'commonjs' } },
+  { languageOptions: { globals: globals.node } },
+  pluginJs.configs.recommended,
+  ...tseslint.configs.recommended,
+  eslintPluginUnicorn.configs.recommended,
+  pluginPromise.configs['flat/recommended'],
+  // pluginLodash.configs.recommended,
+  {
+    rules: {
+      'block-scoped-var': 'error',
+      'no-loop-func': 'error',
+      //
+      '@typescript-eslint/no-explicit-any': 'off',
+      '@typescript-eslint/no-unused-vars': 'off',
+      '@typescript-eslint/no-empty-function': 'off',
+      '@typescript-eslint/no-empty-interface': 'off',
+      //
+      'unicorn/prevent-abbreviations': 'off',
+      // 'lodash/prefer-lodash-method': 'off',
+      // 'rxjs/no-implicit-any-catch': 'off',
+    },
+  },
+];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "gcf-common-lib",
   "description": "",
-  "version": "0.31.62",
+  "version": "0.32.62",
   "publishConfig": {
     "access": "public",
     "branches": [
@@ -20,12 +20,14 @@
     "url": "https://github.com/TopTechnologies/gcf-common.git"
   },
   "dependencies": {
+    "@google-cloud/pubsub": "^4.4.0",
+    "@google-cloud/storage": "^7.11.0",
+    "@tsconfig/node18": "^18.2.4",
     "@types/amqplib": "^0.10.5",
     "@types/bluebird": "^3.5.42",
+    "@types/express": "^4.17.21",
     "@types/lodash": "^4.17.1",
     "@types/node": "^18.19.32",
-    "@google-cloud/pubsub": "^4.4.0",
-    "@google-cloud/storage": "^7.11.0",
     "amqplib": "^0.10.4",
     "bluebird": "^3.7.2",
     "lodash": "^4.17.21",
@@ -34,16 +36,14 @@
     "rxjs": "^7.8.1"
   },
   "devDependencies": {
-    "@typescript-eslint/eslint-plugin": "^7.8.0",
-    "@typescript-eslint/parser": "^7.8.0",
-    "@tsconfig/node18": "^18.2.4",
-    "eslint": "^8.57.0",
-    "eslint-import-resolver-typescript": "^3.6.1",
-    "eslint-plugin-import": "^2.29.1",
-    "eslint-plugin-lodash": "^7.4.0",
-    "eslint-plugin-promise": "^6.1.1",
-    "eslint-plugin-rxjs": "^5.0.3",
-    "eslint-plugin-unicorn": "^52.0.0"
+    "@eslint/js": "^9.21.0",
+    "eslint": "^9.21.0",
+    "eslint-plugin-lodash": "^8.0.0",
+    "eslint-plugin-promise": "^7.2.1",
+    "eslint-plugin-unicorn": "^57.0.0",
+    "globals": "^15.15.0",
+    "prettier": "^3.5.2",
+    "typescript-eslint": "^8.25.0"
   },
   "author": "alert83@gmail.com",
   "license": ""

package/src/index.ts

@@ -1,12 +1,13 @@
 import { PubSub } from '@google-cloud/pubsub';
 import { Storage } from '@google-cloud/storage';
 import { Options } from 'amqplib';
+import { Request } from 'express';
 import isEmpty from 'lodash/isEmpty';
 import mapValues from 'lodash/mapValues';
 import noop from 'lodash/noop';
 import { defer, first, firstValueFrom, from, identity, timeout } from 'rxjs';
 import { AmqpHelper } from './amqp-helper';
-import { TContext, TEvent, TGSEvent, TMetadataOrAttributes, TPSEvent, TResponse } from './types';
+import { TEvent, TGSEvent, TMetadataOrAttributes, TPayload, TPSEvent, TResponse } from './types';
 import { ms, safeJsonParse } from './utils';
 import Dict = NodeJS.Dict;
 
@@ -35,52 +36,26 @@ export class GcfCommon {
     publishOptions: { persistent: true },
   };
 
-  /**
-   *
-   * @param {!TEvent} event Event payload.
-   * @param {!TContext} context Metadata for the event.
-   * @param handler
-   * @param timeoutSec Seconds
-   */
   static async process<T extends TResponse, E = TEvent>(
-    event: E,
-    context: TContext,
-    handler: (event: E, context: TContext) => Promise<T | E> | T | E = identity,
+    payload: TPayload<E>,
+    handler: (payload: TPayload<E>) => Promise<any> | any = identity,
     timeoutSec = 535,
   ) {
-    const asyncHandler = async (_event: any, _context: any) => await handler(_event, _context);
+    const asyncHandler = async (p: TPayload<E>) => await handler(p);
     return firstValueFrom(
-      defer(() => from(asyncHandler(event, context))).pipe(first(), timeout({ first: ms({ s: timeoutSec }) })),
+      defer(() => from(asyncHandler(payload))).pipe(first(), timeout({ first: ms({ s: timeoutSec }) })),
     )
       .then(async res => {
         // console.log('res:', res);
-        await this.response(event, context, res as T).catch(noop);
+        await this.response(payload, res as T).catch(noop);
         return res;
       })
       .catch(async (error: Error) => {
-        await this.response(event, context, GcfCommon.buildResponse(error), { error: '1' }).catch(noop);
+        await this.response(payload, GcfCommon.buildResponse(error), { error: '1' }).catch(noop);
         throw error;
       });
   }
 
-  // static async processOLd<T extends TResponse, E = TEvent>(
-  //   event: E,
-  //   context: TContext,
-  //   handler: (event: E, context: TContext) => Promise<T | E> | T | E = identity,
-  //   timeoutSec = 535,
-  // ) {
-  //   return Promise.race([timeoutAfter(timeoutSec), handler(event, context)])
-  //     .then(async res => {
-  //       // console.log('res:', res);
-  //       await this.response(event, context, res as T);
-  //       return res;
-  //     })
-  //     .catch(async (error: Error) => {
-  //       await this.response(event, context, GcfCommon.buildResponse(error), { error: '1' }).catch(noop);
-  //       throw error;
-  //     });
-  // }
-
   static buildResponse(error: Error) {
     return {
       error: {
@@ -91,7 +66,7 @@ export class GcfCommon {
     } as TResponse;
   }
 
-  static async response<E = TEvent>(event: E, context: TContext, json?: TResponse, attributes?: Dict<any>) {
+  static async response<E = TEvent>(payload: TPayload<E>, json?: TResponse, attributes?: Dict<any>) {
     // console.time('safeGetAttributes');
     // const { topic, exchange, queue, consumer_id, request_id, app_id, env } = await this.safeGetAttributes(
     //   event,
@@ -100,10 +75,7 @@ export class GcfCommon {
     // );
     // console.timeEnd('safeGetAttributes');
 
-    const { topic, exchange, queue, consumer_id, request_id, app_id, env } = this.getMetadataOrAttribute(
-      event,
-      context,
-    );
+    const { topic, exchange, queue, consumer_id, request_id, app_id, env } = this.getMetadataOrAttribute(payload);
 
     //
 
@@ -168,31 +140,41 @@ export class GcfCommon {
   //   } as TMetadataOrAttributes;
   // }
 
-  static async getOptions(event: TEvent, context: TContext): Promise<Dict<any>> {
+  static async getOptions(payload: TPayload): Promise<Dict<any>> {
     // const { options } = await this.safeGetAttributes(event, context, ['options']);
-    const { options } = this.getMetadataOrAttribute(event, context);
+    const { options } = this.getMetadataOrAttribute(payload);
     return safeJsonParse(options as any, {} as any);
   }
 
-  static getMetadataOrAttribute<E = TEvent>(event: E, context: TContext) {
+  static getMetadataOrAttribute<E = TEvent>(payload: TPayload<E>) {
     let metadataOrAttribute: TMetadataOrAttributes | undefined;
 
-    switch (context?.eventType) {
-      case 'google.storage.object.finalize': {
-        const gsEvent = event as TGSEvent;
-        metadataOrAttribute = gsEvent?.metadata;
-        break;
-      }
-      case 'google.pubsub.topic.publish': {
-        const psEvent = event as TPSEvent;
-        metadataOrAttribute = psEvent?.attributes;
-        break;
+    if (payload?.context) {
+      switch (payload?.context?.eventType) {
+        case 'google.storage.object.finalize': {
+          const gsEvent = payload?.event as TGSEvent;
+          metadataOrAttribute = gsEvent?.metadata;
+          break;
+        }
+        case 'google.pubsub.topic.publish': {
+          const psEvent = payload?.event as TPSEvent;
+          metadataOrAttribute = psEvent?.attributes;
+          break;
+        }
       }
     }
 
+    if (payload?.request) {
+      metadataOrAttribute = this.getRequestMessage(payload.request)?.attributes;
+    }
+
     return metadataOrAttribute ?? {};
   }
 
+  static getRequestMessage(request: Request) {
+    return request.body.message as { attributes: TMetadataOrAttributes; data: string; json?: Dict<any> };
+  }
+
   // static async getSecret(name: string, version?: string) {
   //   const projectId = await secretClient.getProjectId();
   //   const secretName = `projects/${projectId}/secrets/${name}`;

package/src/types.ts

@@ -1,4 +1,12 @@
 import Dict = NodeJS.Dict;
+import { Request, Response } from 'express';
+
+export type TPayload<E = TEvent> = {
+  event?: E;
+  context?: TContext;
+  request?: Request;
+  response?: Response;
+};
 
 export type TGSEvent<M = TMetadataOrAttributes> = {
   bucket: string;