gcf-common-lib 0.35.0 → 0.36.0

package/src/index.ts

@@ -1,178 +1,177 @@
-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 { AmqpHelper } from './amqp-helper';
-import { TEvent, TGSEvent, TMetadataOrAttributes, TPayload, TPSEvent, TResponse } from './types';
-import { ms, safeJsonParse } from './utils';
-import Dict = NodeJS.Dict;
-
-export * as Storage from '@google-cloud/storage';
-export * as PubSub from '@google-cloud/pubsub';
-export * as RxJs from 'rxjs';
-export * as MongoDb from 'mongodb';
-export * from './types';
-export * from './utils';
-export * from './mongo-helper';
-export * from './amqp-helper';
-
-export const pubSub = new PubSub();
-export const storage = new Storage();
-
-export const GcfCommon = {
-  amqpOptions: {
-    assertExchange: { durable: true, autoDelete: false },
-    assertOptions: { durable: true, autoDelete: true, expires: ms({ d: 1 }) },
-    publishOptions: { persistent: true },
-  } as {
-    url?: string;
-    assertExchange?: Options.AssertExchange;
-    assertOptions?: Options.AssertQueue;
-    publishOptions?: Options.Publish;
-  },
-
-  async process<T extends TResponse, E = TEvent>(
-    payload: TPayload<E>,
-    handler: (p: TPayload<E>) => Promise<any> | any,
-    // timeoutSec = 535,
-  ) {
-    const asyncHandler = async (p: TPayload<E>) => await handler(p);
-
-    // return firstValueFrom(
-    //   defer(() => from(asyncHandler({ ...payload }))).pipe(first(), timeout({ first: ms({ s: timeoutSec }) })),
-    // )
-
-    return asyncHandler({ ...payload })
-      .then(async res => {
-        // console.log('res:', res);
-        await GcfCommon.response({ ...payload }, res as T).catch(noop);
-        return res;
-      })
-      .catch(async (error: Error) => {
-        await GcfCommon.response({ ...payload }, GcfCommon.buildResponse(error), { error: '1' }).catch(noop);
-        throw error;
-      });
-  },
-
-  buildResponse(error: Error) {
-    return {
-      error: {
-        name: error.name,
-        message: `GCF [${process?.env?.K_SERVICE ?? 'UNKNOWN'}]: ${error.message}`,
-        stack: error.stack,
-      },
-    } as TResponse;
-  },
-
-  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 GcfCommon.safeGetAttributes(
-    //   event,
-    //   context,
-    //   ['consumer_id', 'topic', 'exchange', 'queue'],
-    // );
-    // console.timeEnd('safeGetAttributes');
-
-    const { topic, exchange, queue, consumer_id, request_id, app_id, env } = GcfCommon.getMetadataOrAttribute(payload);
-
-    //
-
-    console.time('publish');
-
-    if (topic && !isEmpty(topic)) {
-      console.log('send:', topic, app_id, env, json, attributes);
-      await pubSub.topic(topic).publishMessage({
-        json: json ?? {},
-        attributes: {
-          ...mapValues(attributes ?? {}, v => '' + v),
-          consumer_id: consumer_id ?? '',
-          request_id: request_id ?? '',
-          app_id: app_id ?? '',
-          env: env ?? '',
-        } as TMetadataOrAttributes,
-      });
-    }
-
-    if (exchange && !isEmpty(exchange)) {
-      console.log('send:', exchange, queue, app_id, env, json, attributes);
-      await AmqpHelper.withAmqpCh(async ch => {
-        await ch.assertExchange(exchange, 'direct', GcfCommon.amqpOptions.assertExchange);
-        await AmqpHelper.publishAmqp(ch, exchange, queue ?? '', json ?? {}, {
-          ...GcfCommon.amqpOptions.publishOptions,
-          correlationId: request_id,
-        });
-      }, GcfCommon.amqpOptions.url as string);
-    } else if (queue && !isEmpty(queue)) {
-      console.log('send:', queue, app_id, env, json, attributes);
-      await AmqpHelper.withAmqpCh(async ch => {
-        // await ch.assertQueue(queue, GcfCommon.amqpOptions.assertOptions);
-        await AmqpHelper.publishAmqp(ch, undefined, queue, json ?? {}, {
-          ...GcfCommon.amqpOptions.publishOptions,
-          correlationId: request_id,
-        });
-      }, GcfCommon.amqpOptions.url as string);
-    }
-
-    console.timeEnd('publish');
-  },
-
-  // async safeGetAttributes<E = TEvent>(event: E, context: TContext, props: string[]) {
-  //   let metaOrAttr = GcfCommon.getMetadataOrAttribute(event, context);
-  //   // const everyPropIsNil = props.map(prop => get(metaOrAttr, prop)).every(v => isNil(v));
-  //
-  //   const someProp = props.map(prop => get(metaOrAttr, prop)).some(v => !isNil(v));
-  //   // if no prop then check file metadata
-  //   if (!someProp && context?.resource?.type === 'storage#object') {
-  //     console.log('get metadata from file');
-  //     if (context?.eventType === 'google.storage.object.finalize') {
-  //       const gsEvent = event as TGSEvent;
-  //       const [meta] = await new Storage().bucket(gsEvent.bucket).file(gsEvent.name).getMetadata();
-  //       metaOrAttr = meta?.metadata ?? {};
-  //     }
-  //   }
-  //
-  //   return {
-  //     ...metaOrAttr,
-  //     app_id: metaOrAttr.app_id,
-  //     request_id: metaOrAttr.request_id,
-  //   } as TMetadataOrAttributes;
-  // },
-
-  async getOptions(payload: TPayload): Promise<Dict<any>> {
-    // const { options } = await GcfCommon.safeGetAttributes(event, context, ['options']);
-    const { options } = GcfCommon.getMetadataOrAttribute(payload);
-    return safeJsonParse(options as any, {} as any);
-  },
-
-  getMetadataOrAttribute<E = TEvent>(payload: TPayload<E>) {
-    let metadataOrAttribute: TMetadataOrAttributes | undefined;
-
-    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;
-        }
-      }
-    } else if (payload?.request) {
-      metadataOrAttribute = GcfCommon.getRequestMessage(payload.request)?.attributes;
-    }
-
-    // console.log('metadataOrAttribute:', metadataOrAttribute);
-
-    return metadataOrAttribute ?? {};
-  },
-
-  getRequestMessage(request: Request) {
-    return request.body.message as { attributes: TMetadataOrAttributes; data: string; json?: Dict<any> };
-  },
-};
+import { PubSub } from '@google-cloud/pubsub';
+import { Storage } from '@google-cloud/storage';
+import { Request } from 'express';
+import isEmpty from 'lodash/isEmpty';
+import mapValues from 'lodash/mapValues';
+import noop from 'lodash/noop';
+// import { AmqpHelper } from './amqp-helper.ts';
+import { TEvent, TGSEvent, TMetadataOrAttributes, TPayload, TPSEvent, TResponse } from './types';
+import { ms, safeJsonParse } from './utils';
+import Dict = NodeJS.Dict;
+
+export * as Storage from '@google-cloud/storage';
+export * as PubSub from '@google-cloud/pubsub';
+export * as RxJs from 'rxjs';
+export * as MongoDb from 'mongodb';
+export * from './types';
+export * from './utils';
+export * from './mongo-helper';
+// export * from './amqp-helper.ts';
+
+export const pubSub = new PubSub();
+export const storage = new Storage();
+
+export const GcfCommon = {
+  // amqpOptions: {
+  //   assertExchange: { durable: true, autoDelete: false },
+  //   assertOptions: { durable: true, autoDelete: true, expires: ms({ d: 1 }) },
+  //   publishOptions: { persistent: true },
+  // } as {
+  //   url?: string;
+  //   assertExchange?: Options.AssertExchange;
+  //   assertOptions?: Options.AssertQueue;
+  //   publishOptions?: Options.Publish;
+  // },
+
+  async process<T extends TResponse, E = TEvent>(
+    payload: TPayload<E>,
+    handler: (p: TPayload<E>) => Promise<any> | any,
+    // timeoutSec = 535,
+  ) {
+    const asyncHandler = async (p: TPayload<E>) => await handler(p);
+
+    // return firstValueFrom(
+    //   defer(() => from(asyncHandler({ ...payload }))).pipe(first(), timeout({ first: ms({ s: timeoutSec }) })),
+    // )
+
+    return asyncHandler({ ...payload })
+      .then(async res => {
+        // console.log('res:', res);
+        await GcfCommon.response({ ...payload }, res as T).catch(noop);
+        return res;
+      })
+      .catch(async (error: Error) => {
+        await GcfCommon.response({ ...payload }, GcfCommon.buildResponse(error), { error: '1' }).catch(noop);
+        throw error;
+      });
+  },
+
+  buildResponse(error: Error) {
+    return {
+      error: {
+        name: error.name,
+        message: `GCF [${process?.env?.K_SERVICE ?? 'UNKNOWN'}]: ${error.message}`,
+        stack: error.stack,
+      },
+    } as TResponse;
+  },
+
+  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 GcfCommon.safeGetAttributes(
+    //   event,
+    //   context,
+    //   ['consumer_id', 'topic', 'exchange', 'queue'],
+    // );
+    // console.timeEnd('safeGetAttributes');
+
+    const { topic, exchange, queue, consumer_id, request_id, app_id, env } = GcfCommon.getMetadataOrAttribute(payload);
+
+    //
+
+    console.time('publish');
+
+    if (topic && !isEmpty(topic)) {
+      console.log('send:', topic, app_id, env, json, attributes);
+      await pubSub.topic(topic).publishMessage({
+        json: json ?? {},
+        attributes: {
+          ...mapValues(attributes ?? {}, v => '' + v),
+          consumer_id: consumer_id ?? '',
+          request_id: request_id ?? '',
+          app_id: app_id ?? '',
+          env: env ?? '',
+        } as TMetadataOrAttributes,
+      });
+    }
+
+    // if (exchange && !isEmpty(exchange)) {
+    //   console.log('send:', exchange, queue, app_id, env, json, attributes);
+    //   await AmqpHelper.withAmqpCh(async ch => {
+    //     await ch.assertExchange(exchange, 'direct', GcfCommon.amqpOptions.assertExchange);
+    //     await AmqpHelper.publishAmqp(ch, exchange, queue ?? '', json ?? {}, {
+    //       ...GcfCommon.amqpOptions.publishOptions,
+    //       correlationId: request_id,
+    //     });
+    //   }, GcfCommon.amqpOptions.url as string);
+    // } else if (queue && !isEmpty(queue)) {
+    //   console.log('send:', queue, app_id, env, json, attributes);
+    //   await AmqpHelper.withAmqpCh(async ch => {
+    //     // await ch.assertQueue(queue, GcfCommon.amqpOptions.assertOptions);
+    //     await AmqpHelper.publishAmqp(ch, undefined, queue, json ?? {}, {
+    //       ...GcfCommon.amqpOptions.publishOptions,
+    //       correlationId: request_id,
+    //     });
+    //   }, GcfCommon.amqpOptions.url as string);
+    // }
+
+    console.timeEnd('publish');
+  },
+
+  // async safeGetAttributes<E = TEvent>(event: E, context: TContext, props: string[]) {
+  //   let metaOrAttr = GcfCommon.getMetadataOrAttribute(event, context);
+  //   // const everyPropIsNil = props.map(prop => get(metaOrAttr, prop)).every(v => isNil(v));
+  //
+  //   const someProp = props.map(prop => get(metaOrAttr, prop)).some(v => !isNil(v));
+  //   // if no prop then check file metadata
+  //   if (!someProp && context?.resource?.type === 'storage#object') {
+  //     console.log('get metadata from file');
+  //     if (context?.eventType === 'google.storage.object.finalize') {
+  //       const gsEvent = event as TGSEvent;
+  //       const [meta] = await new Storage().bucket(gsEvent.bucket).file(gsEvent.name).getMetadata();
+  //       metaOrAttr = meta?.metadata ?? {};
+  //     }
+  //   }
+  //
+  //   return {
+  //     ...metaOrAttr,
+  //     app_id: metaOrAttr.app_id,
+  //     request_id: metaOrAttr.request_id,
+  //   } as TMetadataOrAttributes;
+  // },
+
+  async getOptions(payload: TPayload): Promise<Dict<any>> {
+    // const { options } = await GcfCommon.safeGetAttributes(event, context, ['options']);
+    const { options } = GcfCommon.getMetadataOrAttribute(payload);
+    return safeJsonParse(options as any, {} as any);
+  },
+
+  getMetadataOrAttribute<E = TEvent>(payload: TPayload<E>) {
+    let metadataOrAttribute: TMetadataOrAttributes | undefined;
+
+    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;
+        }
+      }
+    } else if (payload?.request) {
+      metadataOrAttribute = GcfCommon.getRequestMessage(payload.request)?.attributes;
+    }
+
+    // console.log('metadataOrAttribute:', metadataOrAttribute);
+
+    return metadataOrAttribute ?? {};
+  },
+
+  getRequestMessage(request: Request) {
+    return request.body.message as { attributes: TMetadataOrAttributes; data: string; json?: Dict<any> };
+  },
+};

package/src/mongo-helper.js

@@ -1,42 +1,42 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MongoHelper = void 0;
-const mongodb_1 = require("mongodb");
-const bluebird_1 = __importDefault(require("bluebird"));
-let mongoClient;
-exports.MongoHelper = {
-    async collectionExists(client, name) {
-        const db = client.db();
-        const collections = await db.listCollections({ name }, { nameOnly: true }).toArray();
-        return collections.length > 0;
-    },
-    async collectionSafeGet(client, name, options, afterCreate) {
-        const db = client.db();
-        let coll;
-        if (await this.collectionExists(client, name)) {
-            coll = db.collection(name);
-        }
-        else {
-            coll = await db.createCollection(name, options);
-            afterCreate && (await afterCreate(coll));
-        }
-        return coll;
-    },
-    async withMongoClient(fn, url, mongoClientOptions) {
-        function withDisposer() {
-            return bluebird_1.default.method(async () => {
-                if (!mongoClient) {
-                    mongoClient = new mongodb_1.MongoClient(url, mongoClientOptions);
-                    await mongoClient.connect();
-                }
-                return mongoClient;
-            })().disposer((client, promise) => {
-                // client.close();
-            });
-        }
-        return bluebird_1.default.using(withDisposer(), client => fn(client));
-    },
-};
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoHelper = void 0;
+const mongodb_1 = require("mongodb");
+const bluebird_1 = __importDefault(require("bluebird"));
+let mongoClient;
+exports.MongoHelper = {
+    async collectionExists(client, name) {
+        const db = client.db();
+        const collections = await db.listCollections({ name }, { nameOnly: true }).toArray();
+        return collections.length > 0;
+    },
+    async collectionSafeGet(client, name, options, afterCreate) {
+        const db = client.db();
+        let coll;
+        if (await this.collectionExists(client, name)) {
+            coll = db.collection(name);
+        }
+        else {
+            coll = await db.createCollection(name, options);
+            afterCreate && (await afterCreate(coll));
+        }
+        return coll;
+    },
+    async withMongoClient(fn, url, mongoClientOptions) {
+        function withDisposer() {
+            return bluebird_1.default.method(async () => {
+                if (!mongoClient) {
+                    mongoClient = new mongodb_1.MongoClient(url, mongoClientOptions);
+                    await mongoClient.connect();
+                }
+                return mongoClient;
+            })().disposer((client, promise) => {
+                // client.close();
+            });
+        }
+        return bluebird_1.default.using(withDisposer(), client => fn(client));
+    },
+};

package/src/mongo-helper.ts

@@ -1,51 +1,51 @@
-import { Collection, CreateCollectionOptions, MongoClient, MongoClientOptions } from 'mongodb';
-import { Document } from 'bson';
-import Bluebird from 'bluebird';
-let mongoClient: MongoClient;
-
-export const MongoHelper = {
-  async collectionExists(client: MongoClient, name: string) {
-    const db = client.db();
-    const collections = await db.listCollections({ name }, { nameOnly: true }).toArray();
-    return collections.length > 0;
-  },
-
-  async collectionSafeGet<TSchema extends Document = Document>(
-    client: MongoClient,
-    name: string,
-    options?: CreateCollectionOptions,
-    afterCreate?: (col: Collection<TSchema>) => Promise<void>,
-  ) {
-    const db = client.db();
-    let coll: Collection<TSchema>;
-
-    if (await this.collectionExists(client, name)) {
-      coll = db.collection<TSchema>(name);
-    } else {
-      coll = await db.createCollection<TSchema>(name, options);
-      afterCreate && (await afterCreate(coll));
-    }
-
-    return coll;
-  },
-
-  async withMongoClient<T = any>(
-    fn: (mongoClient: MongoClient) => Promise<T>,
-    url: string,
-    mongoClientOptions?: MongoClientOptions,
-  ) {
-    function withDisposer() {
-      return Bluebird.method(async () => {
-        if (!mongoClient) {
-          mongoClient = new MongoClient(url, mongoClientOptions);
-          await mongoClient.connect();
-        }
-        return mongoClient;
-      })().disposer((client, promise) => {
-        // client.close();
-      });
-    }
-
-    return Bluebird.using(withDisposer(), client => fn(client));
-  },
-};
+import { Collection, CreateCollectionOptions, MongoClient, MongoClientOptions } from 'mongodb';
+import { Document } from 'bson';
+import Bluebird from 'bluebird';
+let mongoClient: MongoClient;
+
+export const MongoHelper = {
+  async collectionExists(client: MongoClient, name: string) {
+    const db = client.db();
+    const collections = await db.listCollections({ name }, { nameOnly: true }).toArray();
+    return collections.length > 0;
+  },
+
+  async collectionSafeGet<TSchema extends Document = Document>(
+    client: MongoClient,
+    name: string,
+    options?: CreateCollectionOptions,
+    afterCreate?: (col: Collection<TSchema>) => Promise<void>,
+  ) {
+    const db = client.db();
+    let coll: Collection<TSchema>;
+
+    if (await this.collectionExists(client, name)) {
+      coll = db.collection<TSchema>(name);
+    } else {
+      coll = await db.createCollection<TSchema>(name, options);
+      afterCreate && (await afterCreate(coll));
+    }
+
+    return coll;
+  },
+
+  async withMongoClient<T = any>(
+    fn: (mongoClient: MongoClient) => Promise<T>,
+    url: string,
+    mongoClientOptions?: MongoClientOptions,
+  ) {
+    function withDisposer() {
+      return Bluebird.method(async () => {
+        if (!mongoClient) {
+          mongoClient = new MongoClient(url, mongoClientOptions);
+          await mongoClient.connect();
+        }
+        return mongoClient;
+      })().disposer((client, promise) => {
+        // client.close();
+      });
+    }
+
+    return Bluebird.using(withDisposer(), client => fn(client));
+  },
+};