@lucaapp/service-utils 1.7.0 → 1.9.0

package/dist/index.d.ts

@@ -2,3 +2,5 @@ export * from './lib/kafka';
 export * from './lib/serviceIdentity';
 export * from './lib/metrics';
 export * from './lib/wsEvent';
+export * from './lib/lifecycle';
+export * from './lib/logger';

package/dist/index.js

@@ -18,3 +18,5 @@ __exportStar(require("./lib/kafka"), exports);
 __exportStar(require("./lib/serviceIdentity"), exports);
 __exportStar(require("./lib/metrics"), exports);
 __exportStar(require("./lib/wsEvent"), exports);
+__exportStar(require("./lib/lifecycle"), exports);
+__exportStar(require("./lib/logger"), exports);

package/dist/lib/kafka/events/wsEvent.d.ts

@@ -1,5 +1,6 @@
 declare type WsEvent = {
     subId: string;
+    type: string;
     data: any;
 };
 export type { WsEvent };

package/dist/lib/lifecycle/index.d.ts

@@ -0,0 +1,17 @@
+import { Logger, LoggerOptions } from 'pino';
+declare class Lifecycle {
+    state: {
+        isShuttingDown: boolean;
+    };
+    private readonly shutdownDelay;
+    private readonly logger;
+    constructor(shutdownDelay: number, logger: Logger<LoggerOptions>);
+    shutdownHandlers: Array<() => void>;
+    gracefulShutdown: (isImmediate?: boolean) => Promise<void>;
+    private sigtermHandler;
+    unhandledRejectionHandler: (error: unknown) => void;
+    uncaughtExceptionHandler: (error: unknown) => void;
+    registerShutdownHandler: (shutdownHandler: () => void) => void;
+    registerHooks: () => void;
+}
+export { Lifecycle };

package/dist/lib/lifecycle/index.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Lifecycle = void 0;
+const moment_1 = __importDefault(require("moment"));
+const sleep_1 = require("./sleep");
+class Lifecycle {
+    constructor(shutdownDelay, logger) {
+        this.state = {
+            isShuttingDown: false,
+        };
+        this.shutdownHandlers = [];
+        this.gracefulShutdown = async (isImmediate = false) => {
+            if (this.state.isShuttingDown)
+                return;
+            this.state.isShuttingDown = true;
+            if (!isImmediate) {
+                this.logger.info(`shutting down in ${this.shutdownDelay.as('seconds')}s.`);
+                await (0, sleep_1.sleep)(this.shutdownDelay.as('milliseconds'));
+            }
+            this.logger.info('starting shutdown');
+            for (const shutdownHandler of this.shutdownHandlers) {
+                shutdownHandler();
+            }
+            this.logger.info('shutdown complete');
+        };
+        this.sigtermHandler = async () => {
+            this.logger.info('SIGTERM received.');
+            await this.gracefulShutdown();
+            process.exit(0);
+        };
+        this.unhandledRejectionHandler = (error) => {
+            this.logger.error(error, 'unhandledRejection');
+            process.exit(1);
+        };
+        this.uncaughtExceptionHandler = (error) => {
+            this.logger.error(error, 'uncaughtException');
+            process.exit(1);
+        };
+        this.registerShutdownHandler = (shutdownHandler) => {
+            this.shutdownHandlers.push(shutdownHandler);
+        };
+        this.registerHooks = () => {
+            process.on('SIGTERM', this.sigtermHandler);
+            process.on('uncaughtException', this.uncaughtExceptionHandler);
+            process.on('unhandledRejection', this.unhandledRejectionHandler);
+        };
+        this.shutdownDelay = moment_1.default.duration(shutdownDelay, 'seconds');
+        this.logger = logger;
+    }
+}
+exports.Lifecycle = Lifecycle;

package/dist/lib/lifecycle/sleep.d.ts

@@ -0,0 +1,3 @@
+declare const sleep: (msToSleep: number) => Promise<void>;
+declare const randomSleep: () => Promise<void>;
+export { sleep, randomSleep };

package/dist/lib/lifecycle/sleep.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomSleep = exports.sleep = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const util_1 = require("util");
+const setTimeoutPromise = (0, util_1.promisify)(setTimeout);
+const sleep = (msToSleep) => setTimeoutPromise(msToSleep);
+exports.sleep = sleep;
+const randomSleep = () => setTimeoutPromise(crypto_1.default.randomInt(100, 500));
+exports.randomSleep = randomSleep;

package/dist/lib/logger/index.d.ts

@@ -0,0 +1,6 @@
+import { Logger, LoggerOptions } from 'pino';
+import { HttpLoggerCreationOptions } from './utils';
+export declare class LoggerFactory {
+    static getLogger(logLevel: string): Logger<LoggerOptions>;
+    static getHttpLogger(options: HttpLoggerCreationOptions): import("pino-http").HttpLogger;
+}

package/dist/lib/logger/index.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerFactory = void 0;
+const pino_1 = __importDefault(require("pino"));
+const pino_http_1 = __importDefault(require("pino-http"));
+const pick_1 = __importDefault(require("lodash/pick"));
+const uuid_1 = require("uuid");
+class LoggerFactory {
+    static getLogger(logLevel) {
+        return (0, pino_1.default)({ level: logLevel });
+    }
+    static getHttpLogger(options) {
+        const { requestSerializer, responseSerializer, errorSerializer, defaultHttpLogLevel, customMessage, } = new HttpLoggerHelpers(options);
+        const logger = this.getLogger(options.logLevel);
+        return (0, pino_http_1.default)({
+            logger: logger,
+            serializers: {
+                req: requestSerializer,
+                res: responseSerializer,
+                err: errorSerializer,
+            },
+            customLogLevel: (response, error) => {
+                if (response.statusCode >= 400 && response.statusCode < 500)
+                    return 'warn';
+                if (response.statusCode >= 500 || error)
+                    return 'error';
+                return defaultHttpLogLevel;
+            },
+            customSuccessMessage: customMessage,
+            customErrorMessage: (_, response) => customMessage(response),
+            genReqId: () => (0, uuid_1.v4)(),
+        });
+    }
+}
+exports.LoggerFactory = LoggerFactory;
+class HttpLoggerHelpers {
+    constructor({ debug, e2e, defaultHttpLogLevel }) {
+        this.requestSerializer = (request) => {
+            if (this.debug || this.e2e)
+                return request;
+            request.headers = (0, pick_1.default)(request.headers, [
+                'connection',
+                'host',
+                'origin',
+                'x-real-ip',
+                'x-forwarded-for',
+                'x-forwarded-proto',
+                'x-forwarded-host',
+                'x-forwarded-port',
+                'x-scheme',
+                'user-agent',
+                'content-type',
+                'accept',
+                'referer',
+                'accept-encoding',
+                'ssl-client-subject-dn',
+            ]);
+            return request;
+        };
+        this.responseSerializer = (response) => {
+            if (this.debug)
+                return response;
+            response.headers = (0, pick_1.default)(response.headers, [
+                'content-type',
+                'content-length',
+            ]);
+            return response;
+        };
+        this.errorSerializer = (error) => {
+            if (error?.parameters)
+                error.parameters = undefined;
+            if (error?.parent?.parameters)
+                error.parent.parameters = undefined;
+            if (error?.original?.parameters)
+                error.original.parameters = undefined;
+            return error;
+        };
+        this.customMessage = (response) => {
+            const { req: { method, originalUrl }, statusCode, } = response;
+            return `${statusCode} ${method} ${originalUrl}`;
+        };
+        this.debug = !!debug;
+        this.e2e = !!e2e;
+        this.defaultHttpLogLevel = defaultHttpLogLevel || 'info';
+    }
+}

package/dist/lib/logger/utils.d.ts

@@ -0,0 +1,9 @@
+import { Service } from '../serviceIdentity';
+import { Level } from 'pino';
+export interface HttpLoggerCreationOptions {
+    logLevel: string;
+    defaultHttpLogLevel: Level;
+    service: Service;
+    debug: boolean;
+    e2e: boolean;
+}

package/dist/lib/logger/utils.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/serviceIdentity/service.d.ts

@@ -2,6 +2,8 @@ declare enum Service {
     BACKEND = "backend",
     BACKEND_PAY = "backend-pay",
     BACKEND_POS = "backend-pos",
+    BACKEND_ID = "backend-id",
+    BACKEND_ATTESTATION = "backend-attestation",
     BACKEND_PUBSUB = "backend-pubsub"
 }
 export { Service };

package/dist/lib/serviceIdentity/service.js

@@ -6,6 +6,8 @@ var Service;
     Service["BACKEND"] = "backend";
     Service["BACKEND_PAY"] = "backend-pay";
     Service["BACKEND_POS"] = "backend-pos";
+    Service["BACKEND_ID"] = "backend-id";
+    Service["BACKEND_ATTESTATION"] = "backend-attestation";
     Service["BACKEND_PUBSUB"] = "backend-pubsub";
 })(Service || (Service = {}));
 exports.Service = Service;

package/dist/lib/wsEvent/index.d.ts

@@ -1,4 +1,4 @@
 import { KafkaClient } from '../kafka';
 declare const generateSubscriptionId: () => string;
-declare const emitWebsocketEvent: (kafkaClient: KafkaClient, subId: string, data: any) => Promise<void>;
+declare const emitWebsocketEvent: (kafkaClient: KafkaClient, subId: string, type: string, data: any) => Promise<void>;
 export { generateSubscriptionId, emitWebsocketEvent };

package/dist/lib/wsEvent/index.js

@@ -7,7 +7,7 @@ const generateSubscriptionId = () => {
     return (0, crypto_1.randomBytes)(32).toString('base64');
 };
 exports.generateSubscriptionId = generateSubscriptionId;
-const emitWebsocketEvent = async (kafkaClient, subId, data) => {
+const emitWebsocketEvent = async (kafkaClient, subId, type, data) => {
     const issuer = kafkaClient.serviceIdentity.identityName;
     // using WS_EVENT_backend since all WS_EVENTs use same schema
     const topic = `wsevent_${issuer}`;
@@ -16,6 +16,7 @@ const emitWebsocketEvent = async (kafkaClient, subId, data) => {
         type: 'create',
         entity: {
             subId,
+            type,
             data,
         },
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lucaapp/service-utils",
-  "version": "1.7.0",
+  "version": "1.9.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
@@ -20,6 +20,7 @@
   "devDependencies": {
     "@types/express": "4.17.13",
     "@types/jest": "^28.1.5",
+    "@types/lodash": "^4.14.187",
     "@types/uuid": "^8.3.4",
     "@typescript-eslint/eslint-plugin": "^5.30.6",
     "@typescript-eslint/parser": "^5.30.6",
@@ -40,7 +41,10 @@
     "axios": "^0.27.2",
     "jose": "4.9.2",
     "kafkajs": "2.1.0",
+    "lodash": "^4.17.21",
     "moment": "^2.29.4",
+    "pino": "7.10.0",
+    "pino-http": "6.6.0",
     "prom-client": "14.1.0",
     "uuid": "^9.0.0"
   }