@geniehr/utilities 1.0.5

package/dist/apiUtils/api.d.ts

@@ -0,0 +1,5 @@
+import { Request, Response } from 'express';
+import { AppException } from '../shared/exceptions/index.js';
+import { HttpStatusCode } from '../shared/enums/HttpStatusCodes.js';
+import { InvalidRequestException } from '../shared/exceptions/index';
+export declare function sendResponse(req: Request, res: Response, code: HttpStatusCode, response: any | null, ex?: AppException | InvalidRequestException | undefined): void;

package/dist/apiUtils/api.js

@@ -0,0 +1,113 @@
+import { LoggerService } from '../logger/LoggerService.js';
+import { getContext } from '../shared/context/index.js';
+const context = getContext();
+const logger = new LoggerService();
+export function sendResponse(req, res, code, response, ex) {
+    const correlationId = getContext().correlationId;
+    if (code >= 200 && code < 300) {
+        res.status(code).send({ data: response });
+    }
+    else if (code == 400) {
+        logger.error({ correlationId: correlationId || '', ex });
+        res.status(code).send({ data: null, error: { message: ex?.message, code: ex?.errorCode } });
+    }
+    // else if (code == 401) {
+    // }
+    else if (code == 500) {
+        logger.error({ correlationId: correlationId, ex });
+        res.status(code).send({
+            data: null,
+            error: {
+                code: ex?.errorCode,
+                message: ex?.message,
+                details: ex?.details
+            }
+        });
+    }
+    // else if (code > 500) {
+    // }
+    else {
+        logger.error({ correlationId: correlationId, ex });
+        res.status(code).send({
+            data: null,
+            error: {
+                code: ex?.errorCode,
+                message: ex?.message,
+                details: ex?.details
+            }
+        });
+    }
+}
+function extractErrorMessage(error) {
+    if (!error)
+        return 'Unknown error';
+    // If it's a standard Error object, use its message
+    if (typeof error.message === 'string') {
+        // Clean up multiline Prisma-style messages by picking the last meaningful line
+        const lines = error.message.split('\n').map((line) => line.trim()).filter(Boolean);
+        if (lines.length > 1) {
+            // Try to return the last non-empty line if it looks meaningful
+            const lastLine = lines[lines.length - 1];
+            if (lastLine.length > 10)
+                return lastLine;
+        }
+        return lines[0]; // fallback to first line
+    }
+    // Handle string errors
+    if (typeof error === 'string') {
+        return error;
+    }
+    // Fallback for non-standard error shapes
+    return JSON.stringify(error);
+}
+/*
+{
+    "error": "Validation failed",
+    "details": [
+        {
+            "code": "invalid_type",
+            "expected": "string",
+            "received": "undefined",
+            "path": [
+                "lastName"
+            ],
+            "message": "Required"
+        },
+        {
+            "code": "invalid_type",
+            "expected": "string",
+            "received": "undefined",
+            "path": [
+                "emailAddress"
+            ],
+            "message": "Required"
+        },
+        {
+            "code": "invalid_date",
+            "path": [
+                "dateOfBirth"
+            ],
+            "message": "Invalid date"
+        },
+        {
+            "code": "invalid_type",
+            "expected": "string",
+            "received": "undefined",
+            "path": [
+                "genderName"
+            ],
+            "message": "Required"
+        },
+        {
+            "code": "invalid_type",
+            "expected": "string",
+            "received": "undefined",
+            "path": [
+                "mobileNo"
+            ],
+            "message": "Required"
+        }
+    ]
+}
+
+*/

package/dist/apiUtils/httpUtils.d.ts

@@ -0,0 +1,12 @@
+import { AxiosRequestConfig } from 'axios';
+export declare class HttpClient {
+    private client;
+    constructor(baseURL?: string);
+    get<T = any>(url: string, correlationId: string, config?: AxiosRequestConfig): Promise<T>;
+    post<T = any>(url: string, data: any, correlationId: string, config?: AxiosRequestConfig): Promise<T>;
+    put<T = any>(url: string, data: any, correlationId: string, config?: AxiosRequestConfig): Promise<T>;
+    delete<T = any>(url: string, data: any, correlationId: string, config?: AxiosRequestConfig): Promise<T>;
+    patch<T = any>(url: string, data: any, correlationId: string, config?: AxiosRequestConfig): Promise<T>;
+    private formatError;
+}
+export default HttpClient;

package/dist/apiUtils/httpUtils.js

@@ -0,0 +1,106 @@
+import axios from 'axios';
+export class HttpClient {
+    client;
+    constructor(baseURL) {
+        this.client = axios.create({
+            baseURL,
+            timeout: 30000,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+    async get(url, correlationId, config) {
+        try {
+            const mergedConfig = {
+                ...config,
+                headers: {
+                    ...(config?.headers || {}),
+                    ...{ 'X-Correlation-Id': correlationId },
+                },
+            };
+            const response = await this.client.get(url, mergedConfig);
+            return response.data.data;
+        }
+        catch (error) {
+            throw this.formatError(error);
+        }
+    }
+    async post(url, data, correlationId, config) {
+        try {
+            const mergedConfig = {
+                ...config,
+                headers: {
+                    ...(config?.headers || {}),
+                    'X-Correlation-Id': correlationId,
+                },
+            };
+            const response = await this.client.post(url, data, mergedConfig);
+            return response.data.data;
+        }
+        catch (error) {
+            throw this.formatError(error);
+        }
+    }
+    async put(url, data, correlationId, config) {
+        try {
+            const mergedConfig = {
+                ...config,
+                headers: {
+                    ...(config?.headers || {}),
+                    'X-Correlation-Id': correlationId,
+                },
+            };
+            const response = await this.client.put(url, data, mergedConfig);
+            return response.data.data;
+        }
+        catch (error) {
+            throw this.formatError(error);
+        }
+    }
+    async delete(url, data, correlationId, config) {
+        try {
+            const mergedConfig = {
+                ...config,
+                headers: {
+                    ...(config?.headers || {}),
+                    'X-Correlation-Id': correlationId,
+                },
+                data, // Attach data to config for DELETE
+            };
+            const response = await this.client.delete(url, mergedConfig);
+            return response.data.data;
+        }
+        catch (error) {
+            throw this.formatError(error);
+        }
+    }
+    async patch(url, data, correlationId, config) {
+        try {
+            const mergedConfig = {
+                ...config,
+                headers: {
+                    ...(config?.headers || {}),
+                    'X-Correlation-Id': correlationId,
+                },
+            };
+            const response = await this.client.patch(url, data, mergedConfig);
+            return response.data.data;
+        }
+        catch (error) {
+            throw this.formatError(error);
+        }
+    }
+    formatError(error) {
+        if (error.response) {
+            return new Error(`Request failed with status ${error.response.status}: ${JSON.stringify(error.response.data)}`);
+        }
+        else if (error.request) {
+            return new Error('No response received from server');
+        }
+        else {
+            return new Error(`HTTP client error: ${error.message}`);
+        }
+    }
+}
+export default HttpClient;

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export { validateRequest } from './schema/validation.js';
+export { MQClient } from './mq/client.js';
+export { getContext, setExtras, setContext } from './shared/context/index.js';
+export { LoggerService as Logger } from './logger/LoggerService.js';
+export { HttpStatusCode } from './shared/enums/HttpStatusCodes.js';
+export { InvalidRequestException, InvalidEnvironmentException, AppException } from './shared/exceptions/index.js';
+export { getAWSParameters, matchFace, registerFace, generatePresignedUrl, getCustomAttribute, updateCustomAttribute, executeS3Action } from './secrets/aws.js';
+export { CognitoUserService } from './secrets/CognitoUserService.js';
+export { HttpClient } from './apiUtils/httpUtils.js';
+export { sendResponse } from './apiUtils/api.js';
+export { services } from './shared/services.js';
+export { ImageCompressor } from './shared/helper/ImageCompressor.js';

package/dist/index.js

@@ -0,0 +1,12 @@
+export { validateRequest } from './schema/validation.js';
+export { MQClient } from './mq/client.js';
+export { getContext, setExtras, setContext } from './shared/context/index.js';
+export { LoggerService as Logger } from './logger/LoggerService.js';
+export { HttpStatusCode } from './shared/enums/HttpStatusCodes.js';
+export { InvalidRequestException, InvalidEnvironmentException, AppException } from './shared/exceptions/index.js';
+export { getAWSParameters, matchFace, registerFace, generatePresignedUrl, getCustomAttribute, updateCustomAttribute, executeS3Action } from './secrets/aws.js';
+export { CognitoUserService } from './secrets/CognitoUserService.js';
+export { HttpClient } from './apiUtils/httpUtils.js';
+export { sendResponse } from './apiUtils/api.js';
+export { services } from './shared/services.js';
+export { ImageCompressor } from './shared/helper/ImageCompressor.js';

package/dist/logger/LoggerService.d.ts

@@ -0,0 +1,20 @@
+import { BaseLogPayload, ErrorLogPayload } from '../types/logTypes';
+export declare class LoggerService {
+    private logger;
+    private cloudWatch;
+    private service;
+    constructor(service?: string);
+    private isAppException;
+    private extractErrorPayload;
+    private formatMessage;
+    debug(payload: BaseLogPayload): void;
+    info(payload: BaseLogPayload): void;
+    warn(payload: BaseLogPayload): void;
+    error(args: {
+        correlationId: string;
+        ex: unknown;
+        [key: string]: any;
+    }): void;
+    error(payload: ErrorLogPayload): void;
+    flush(): Promise<void>;
+}

package/dist/logger/LoggerService.js

@@ -0,0 +1,121 @@
+import winston from 'winston';
+import WinstonCloudWatch from 'winston-cloudwatch';
+process.env.AWS_SDK_LOAD_CONFIG = '1';
+process.env.AWS_PROFILE = 'ghr-aws-dev-profile';
+const { NODE_ENV, AWS_REGION = 'ap-south-1' } = process.env;
+export class LoggerService {
+    logger;
+    cloudWatch;
+    service = '';
+    constructor(service) {
+        if (service)
+            this.service = service;
+        const logGroupName = `ghr-${NODE_ENV}-logs`;
+        this.cloudWatch = new WinstonCloudWatch({
+            logGroupName,
+            logStreamName: () => {
+                const date = new Date().toISOString().split('T')[0];
+                return `ghr-${NODE_ENV}-${date}`;
+            },
+            awsRegion: AWS_REGION,
+            jsonMessage: true,
+            level: 'debug',
+            messageFormatter: (item) => item.message,
+        });
+        const transports = [
+            new winston.transports.Console({
+                format: winston.format.combine(winston.format.timestamp(), winston.format.printf(({ timestamp, level, message }) => {
+                    return `[${timestamp}] [${level.toUpperCase()}] ${message} `;
+                })),
+            })
+        ];
+        if (NODE_ENV !== 'Dev') {
+            process.env.AWS_SDK_LOAD_CONFIG = '1';
+            process.env.AWS_PROFILE = 'ghr-aws-dev-profile';
+            transports.push(this.cloudWatch);
+        }
+        this.logger = winston.createLogger({
+            level: 'debug',
+            transports,
+        });
+    }
+    isAppException(obj) {
+        // Duck-typing: If it has an errorCode, it's one of our exceptions.
+        return obj && typeof obj.errorCode === 'string';
+    }
+    extractErrorPayload(input) {
+        const { ex, correlationId, service, ...rest } = input;
+        if (!correlationId)
+            throw new Error('correlationId is mandatory');
+        let message = 'Unknown error';
+        let stack = '';
+        let errorCode = 'UNKNOWN';
+        if (ex instanceof Error) {
+            message = ex.message;
+            stack = ex.stack || '';
+        }
+        // This check will now work reliably
+        if (this.isAppException(ex)) {
+            message = ex.message; // Ensure message is from AppException
+            errorCode = ex.errorCode; // Correctly assign the error code
+            if (ex.details)
+                rest.details = ex.details;
+        }
+        return {
+            message,
+            correlationId,
+            errorCode,
+            errorStack: stack,
+            service: service || this.service, // Use provided service or fallback to the class's service
+            ...rest,
+        };
+    }
+    formatMessage(level, payload) {
+        const base = {
+            ...payload,
+            service: this.service,
+            timestamp: new Date().toISOString(),
+            level,
+        };
+        return base;
+    }
+    debug(payload) {
+        this.logger.debug(this.formatMessage('debug', payload));
+    }
+    info(payload) {
+        this.logger.info(this.formatMessage('info', payload));
+    }
+    warn(payload) {
+        this.logger.warn(this.formatMessage('warn', payload));
+    }
+    error(input) {
+        let finalPayload;
+        // This check correctly narrows down the type of 'input'.
+        if ('ex' in input) {
+            // If 'ex' exists, 'input' matches the 'ErrorInput' type.
+            // It's now safe to call the extractor.
+            finalPayload = this.extractErrorPayload(input);
+        }
+        else {
+            // If 'ex' does not exist, 'input' is an 'ErrorLogPayload'.
+            // We can use it directly after ensuring mandatory fields are present.
+            if (!input.message || !input.errorCode || !input.correlationId) {
+                throw new Error('message, errorCode, and correlationId are mandatory in ErrorLogPayload');
+            }
+            finalPayload = {
+                service: this.service,
+                ...input,
+            };
+        }
+        this.logger.error(this.formatMessage('error', finalPayload));
+    }
+    flush() {
+        return new Promise((resolve, reject) => {
+            this.cloudWatch.kthxbye((err) => {
+                if (err)
+                    return reject(err);
+                resolve();
+            });
+        });
+    }
+}

package/dist/mq/client.d.ts

@@ -0,0 +1,57 @@
+import type { ConsumeMessage } from 'amqplib';
+interface RabbitMQCredentials {
+    host: string;
+    port: string | number;
+    user: string;
+    password: string;
+}
+interface DLQOptions {
+    dlqName: string;
+    messageTTL: number;
+}
+export declare class MQClient {
+    private connection;
+    private channel;
+    private readonly exchangeName;
+    private readonly exchangeType;
+    constructor();
+    /**
+     * Initializes the RabbitMQ connection and channel.
+     * Establishes a connection, creates a channel, asserts the exchange,
+     * and sets up a listener for connection closure.
+     * @param creds - RabbitMQ connection credentials.
+     */
+    init(creds: RabbitMQCredentials | Record<string, string>): Promise<Record<string, any>>;
+    /**
+     * Retrieves the current channel instance.
+     * Throws an error if the channel has not been initialized.
+     * @returns The AMQP channel.
+     */
+    private getChannel;
+    /**
+     * Publishes a message to the defined exchange with a specified routing key.
+     * The message is persistent, meaning it will survive server restarts if queues are durable.
+     * @param routingKey - The routing key for the message.
+     * @param message - The message payload (object or string).
+     */
+    publish(routingKey: string, message: object | string): Promise<void>;
+    /**
+     * Binds a queue to the exchange with specified routing keys.
+     * Optionally sets up a Dead Letter Queue (DLQ) for the main queue.
+     * @param queue - The name of the queue to bind.
+     * @param routingKeys - An array of routing keys to bind the queue with.
+     * @param dlq - Optional DLQ options, including DLQ name and message TTL.
+     */
+    bindQueue(queue: string, routingKeys: string[], dlq?: DLQOptions): Promise<void>;
+    /**
+     * Starts consuming messages from a specified queue.
+     * Messages are acknowledged (acked) on successful processing,
+     * or negatively acknowledged (nacked) on failure, causing them to be
+     * requeued or sent to DLQ if configured.
+     * @param queue - The name of the queue to consume from.
+     * @param onMessage - An async callback function to process each message.
+     * Receives the parsed message data and the raw ConsumeMessage object.
+     */
+    consume(queue: string, onMessage: (msg: any, raw: ConsumeMessage) => Promise<void>): Promise<void>;
+}
+export {};

package/dist/mq/client.js

@@ -0,0 +1,143 @@
+import * as amqp from 'amqplib';
+export class MQClient {
+    connection = null;
+    channel = null;
+    exchangeName = 'ghr.events';
+    exchangeType = 'topic';
+    constructor() { }
+    /**
+     * Initializes the RabbitMQ connection and channel.
+     * Establishes a connection, creates a channel, asserts the exchange,
+     * and sets up a listener for connection closure.
+     * @param creds - RabbitMQ connection credentials.
+     */
+    async init(creds) {
+        const { host, port, user, password } = creds;
+        // Construct the connection string for AMQPS (secure AMQP).
+        const connStr = `amqps://${user}:${password}@${host}:${port}`;
+        try {
+            // Connect to RabbitMQ.
+            const rawConn = await amqp.connect(connStr);
+            // @ts-expect-error Fixing broken types
+            this.connection = rawConn;
+            // Create a channel from the connection.
+            // @ts-expect-error Fixing broken types
+            this.channel = await this.connection.createChannel();
+            // Assert the existence of the exchange.
+            // @ts-expect-error Fixing broken types
+            await this.channel.assertExchange(this.exchangeName, this.exchangeType, {
+                durable: true, // Exchange will survive server restarts.
+            });
+            // Set up an event listener for connection closure.
+            // @ts-expect-error Fixing broken types
+            this.connection.on('close', () => {
+                this.connection = null;
+                this.channel = null;
+                console.warn('RabbitMQ connection closed'); // allow-console
+            });
+            return { connected: true, message: 'MQ client is initialized successfully.' };
+        }
+        catch (error) {
+            return { connected: false, message: `'Failed to initialize RabbitMQ client:', ${error}` };
+        }
+    }
+    /**
+     * Retrieves the current channel instance.
+     * Throws an error if the channel has not been initialized.
+     * @returns The AMQP channel.
+     */
+    getChannel() {
+        if (!this.channel) {
+            throw new Error('RabbitMQ not initialized. Call init() first.');
+        }
+        return this.channel;
+    }
+    /**
+     * Publishes a message to the defined exchange with a specified routing key.
+     * The message is persistent, meaning it will survive server restarts if queues are durable.
+     * @param routingKey - The routing key for the message.
+     * @param message - The message payload (object or string).
+     */
+    async publish(routingKey, message) {
+        const channel = this.getChannel();
+        // Convert the message to a string if it's an object, then to a Buffer.
+        const payload = typeof message === 'string' ? message : JSON.stringify(message);
+        // Publish the message.
+        const sent = channel.publish(this.exchangeName, routingKey, Buffer.from(payload), {
+            persistent: true, // Make the message persistent.
+        });
+        if (!sent) {
+            // If the message could not be sent (e.g., channel buffer full), throw an error.
+            throw new Error(`Failed to publish to exchange ${this.exchangeName} with key ${routingKey}. Channel buffer likely full.`);
+        }
+    }
+    /**
+     * Binds a queue to the exchange with specified routing keys.
+     * Optionally sets up a Dead Letter Queue (DLQ) for the main queue.
+     * @param queue - The name of the queue to bind.
+     * @param routingKeys - An array of routing keys to bind the queue with.
+     * @param dlq - Optional DLQ options, including DLQ name and message TTL.
+     */
+    async bindQueue(queue, routingKeys, dlq) {
+        const channel = this.getChannel();
+        if (dlq) {
+            // Assert the DLQ first.
+            await channel.assertQueue(dlq.dlqName, { durable: true });
+            // Assert the main queue with DLQ arguments.
+            await channel.assertQueue(queue, {
+                durable: true, // Queue will survive server restarts.
+                arguments: {
+                    'x-dead-letter-exchange': '', // Route to the default exchange.
+                    'x-dead-letter-routing-key': dlq.dlqName, // Route to the DLQ by its name.
+                    'x-message-ttl': dlq.messageTTL, // Messages in this queue expire after this time.
+                },
+            });
+        }
+        else {
+            // Assert the main queue without DLQ arguments.
+            await channel.assertQueue(queue, { durable: true });
+        }
+        // Bind the queue to the exchange for each routing key.
+        for (const key of routingKeys) {
+            await channel.bindQueue(queue, this.exchangeName, key);
+        }
+    }
+    /**
+     * Starts consuming messages from a specified queue.
+     * Messages are acknowledged (acked) on successful processing,
+     * or negatively acknowledged (nacked) on failure, causing them to be
+     * requeued or sent to DLQ if configured.
+     * @param queue - The name of the queue to consume from.
+     * @param onMessage - An async callback function to process each message.
+     * Receives the parsed message data and the raw ConsumeMessage object.
+     */
+    async consume(queue, onMessage) {
+        const channel = this.getChannel();
+        // Ensure the queue exists before consuming.
+        await channel.assertQueue(queue, { durable: true });
+        // Start consuming messages.
+        await channel.consume(queue, async (msg) => {
+            if (!msg) {
+                // This can happen if the consumer is cancelled by RabbitMQ.
+                console.warn(`Consumer received null message.`); // allow-console
+                return;
+            }
+            try {
+                // Parse the message content.
+                const data = JSON.parse(msg.content.toString());
+                // Process the message using the provided callback.
+                await onMessage(data, msg);
+                // Acknowledge the message if processed successfully.
+                channel.ack(msg);
+            }
+            catch (err) {
+                console.error(`Error processing message from queue "${queue}":`, err); // allow-console
+                // Negative acknowledge the message.
+                // 'false' for multiple (don't nack multiple messages), 'false' for requeue (send to DLQ or drop).
+                channel.nack(msg, false, false);
+            }
+        }, { noAck: false } // We are manually acknowledging messages.
+        );
+        // log.debug(`Started consuming from queue: ${queue}`);
+    }
+}

package/dist/schema/files/index.d.ts

@@ -0,0 +1 @@
+export * from './person/index.js';

package/dist/schema/files/index.js

@@ -0,0 +1 @@
+export * from './person/index.js';

package/dist/schema/files/person/address.d.ts

@@ -0,0 +1,41 @@
+import { z } from "zod";
+export declare const addressSchema: z.ZodObject<{
+    employeeId: z.ZodNumber;
+    addressName: z.ZodString;
+    addressLine1: z.ZodString;
+    addressLine2: z.ZodOptional<z.ZodString>;
+    addressLine3: z.ZodOptional<z.ZodString>;
+    countryId: z.ZodOptional<z.ZodNumber>;
+    countryName: z.ZodOptional<z.ZodString>;
+    stateId: z.ZodOptional<z.ZodNumber>;
+    stateName: z.ZodOptional<z.ZodString>;
+    cityId: z.ZodOptional<z.ZodNumber>;
+    cityName: z.ZodOptional<z.ZodString>;
+    pinCode: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    employeeId: number;
+    addressName: string;
+    addressLine1: string;
+    addressLine2?: string | undefined;
+    addressLine3?: string | undefined;
+    countryId?: number | undefined;
+    countryName?: string | undefined;
+    stateId?: number | undefined;
+    stateName?: string | undefined;
+    cityId?: number | undefined;
+    cityName?: string | undefined;
+    pinCode?: string | undefined;
+}, {
+    employeeId: number;
+    addressName: string;
+    addressLine1: string;
+    addressLine2?: string | undefined;
+    addressLine3?: string | undefined;
+    countryId?: number | undefined;
+    countryName?: string | undefined;
+    stateId?: number | undefined;
+    stateName?: string | undefined;
+    cityId?: number | undefined;
+    cityName?: string | undefined;
+    pinCode?: string | undefined;
+}>;

package/dist/schema/files/person/address.js

@@ -0,0 +1,15 @@
+import { z } from "zod";
+export const addressSchema = z.object({
+    employeeId: z.number().int(),
+    addressName: z.string().trim().min(1).max(100),
+    addressLine1: z.string().trim().min(1).max(255),
+    addressLine2: z.string().trim().max(255).optional(),
+    addressLine3: z.string().trim().max(255).optional(),
+    countryId: z.number().int().optional(),
+    countryName: z.string().trim().max(100).optional(),
+    stateId: z.number().int().optional(),
+    stateName: z.string().trim().max(100).optional(),
+    cityId: z.number().int().optional(),
+    cityName: z.string().trim().max(100).optional(),
+    pinCode: z.string().trim().max(20).optional()
+});