@triproject/nestjs-core 1.0.5

package/dist/drivers/notifications/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./notification.config"), exports);
+__exportStar(require("./notification.module"), exports);
+__exportStar(require("./notification.queue"), exports);
+__exportStar(require("./push-notification"), exports);
+__exportStar(require("./slack"), exports);

package/dist/drivers/notifications/notification.config.d.ts

@@ -0,0 +1,8 @@
+export interface SendNotificationDto {
+    userId: string | string[];
+    type: string;
+    message: string;
+    title: string;
+    data?: object;
+}
+export declare const notificationQueue = "NOTIFICATION:QUEUE";

package/dist/drivers/notifications/notification.config.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notificationQueue = void 0;
+exports.notificationQueue = 'NOTIFICATION:QUEUE';

package/dist/drivers/notifications/notification.module.d.ts

@@ -0,0 +1,2 @@
+export declare class NotificationDriverModule {
+}

package/dist/drivers/notifications/notification.module.js

@@ -0,0 +1,25 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationDriverModule = void 0;
+const bull_1 = require("@nestjs/bull");
+const common_1 = require("@nestjs/common");
+const notification_config_1 = require("./notification.config");
+const notification_queue_1 = require("./notification.queue");
+const push_notification_1 = require("./push-notification");
+let NotificationDriverModule = class NotificationDriverModule {
+};
+exports.NotificationDriverModule = NotificationDriverModule;
+exports.NotificationDriverModule = NotificationDriverModule = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({
+        providers: [push_notification_1.PushNotification, notification_queue_1.NotificationQueue],
+        imports: [bull_1.BullModule.registerQueue({ name: notification_config_1.notificationQueue })],
+        exports: [push_notification_1.PushNotification],
+    })
+], NotificationDriverModule);

package/dist/drivers/notifications/notification.queue.d.ts

@@ -0,0 +1,9 @@
+import { Job } from 'bull';
+import { AppQueue } from '../queues/app.queue';
+import { SendNotificationDto } from './notification.config';
+import { PushNotification } from './push-notification';
+export declare class NotificationQueue extends AppQueue {
+    private pushNotification;
+    constructor(pushNotification: PushNotification);
+    sendNotification({ data }: Job<SendNotificationDto>): Promise<void>;
+}

package/dist/drivers/notifications/notification.queue.js

@@ -0,0 +1,37 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationQueue = void 0;
+const bull_1 = require("@nestjs/bull");
+const app_queue_1 = require("../queues/app.queue");
+const notification_config_1 = require("./notification.config");
+const push_notification_1 = require("./push-notification");
+let NotificationQueue = class NotificationQueue extends app_queue_1.AppQueue {
+    pushNotification;
+    constructor(pushNotification) {
+        super();
+        this.pushNotification = pushNotification;
+    }
+    async sendNotification({ data }) {
+        await this.pushNotification.send(data, false);
+    }
+};
+exports.NotificationQueue = NotificationQueue;
+__decorate([
+    (0, bull_1.Process)({ name: notification_config_1.notificationQueue, concurrency: 4 }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], NotificationQueue.prototype, "sendNotification", null);
+exports.NotificationQueue = NotificationQueue = __decorate([
+    (0, bull_1.Processor)(notification_config_1.notificationQueue),
+    __metadata("design:paramtypes", [push_notification_1.PushNotification])
+], NotificationQueue);

package/dist/drivers/notifications/push-notification.d.ts

@@ -0,0 +1,10 @@
+import { Queue } from 'bullmq';
+import { SendNotificationDto } from './notification.config';
+export declare class PushNotification {
+    private notificationQueue;
+    private APP_ID;
+    private client;
+    constructor(notificationQueue: Queue);
+    send(params: SendNotificationDto, shouldQueue?: boolean): Promise<import("axios").AxiosResponse<any, any, {}> | import("bullmq").Job<any, any, string>>;
+    broadcast(params: Omit<SendNotificationDto, 'userId' | 'type'>, shouldQueue?: boolean): Promise<import("axios").AxiosResponse<any, any, {}> | import("bullmq").Job<any, any, string>>;
+}

package/dist/drivers/notifications/push-notification.js

@@ -0,0 +1,75 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PushNotification = void 0;
+const bull_1 = require("@nestjs/bull");
+const common_1 = require("@nestjs/common");
+const helpers_1 = require("@triproject/helpers");
+const axios_1 = __importDefault(require("axios"));
+const bullmq_1 = require("bullmq");
+const config_1 = require("../../config");
+const notification_config_1 = require("./notification.config");
+let PushNotification = class PushNotification {
+    notificationQueue;
+    APP_ID;
+    client;
+    constructor(notificationQueue) {
+        this.notificationQueue = notificationQueue;
+        this.APP_ID = config_1.ONESIGNAL_APP_ID;
+        this.client = axios_1.default.create({
+            baseURL: 'https://api.onesignal.com',
+            timeout: 100,
+            headers: {
+                'Content-Type': 'application/json; charset=utf-8',
+                Authorization: `Key ${config_1.ONESIGNAL_REST_API_KEY}`,
+            },
+        });
+    }
+    async send(params, shouldQueue = true) {
+        if (shouldQueue) {
+            return this.notificationQueue.add(notification_config_1.notificationQueue, params, {
+                jobId: (0, helpers_1.generateId)(),
+            });
+        }
+        const { userId, type, title, message, data } = params;
+        return await this.client.post('notifications', {
+            app_id: this.APP_ID,
+            target_channel: 'push',
+            name: type,
+            headings: { en: title },
+            contents: { en: message },
+            data,
+            included_segments: [userId].filter((d) => d),
+        });
+    }
+    broadcast(params, shouldQueue = true) {
+        const { title, message, data } = params;
+        return this.send({
+            userId: 'All',
+            type: 'broadcast',
+            title,
+            message,
+            data,
+        }, shouldQueue);
+    }
+};
+exports.PushNotification = PushNotification;
+exports.PushNotification = PushNotification = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, bull_1.InjectQueue)(notification_config_1.notificationQueue)),
+    __metadata("design:paramtypes", [bullmq_1.Queue])
+], PushNotification);

package/dist/drivers/notifications/slack.d.ts

@@ -0,0 +1,15 @@
+import { AppLogger } from '../logger/app.logger';
+interface SlackConfig {
+    webhookUrl: string;
+    logger?: AppLogger | Console;
+}
+export declare class Slack {
+    private logger;
+    private client;
+    private status;
+    constructor(config: SlackConfig);
+    private _toggleBlocked;
+    private _format;
+    send(...messages: any): Promise<void | import("axios").AxiosResponse<any, any, {}>>;
+}
+export {};

package/dist/drivers/notifications/slack.js

@@ -0,0 +1,95 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Slack = void 0;
+const axios_1 = __importDefault(require("axios"));
+class Slack {
+    logger = console;
+    client;
+    status = {
+        blocked: false,
+        lastUpdateAt: new Date(),
+    };
+    constructor(config) {
+        if (config.logger)
+            this.logger = config.logger;
+        if (config.webhookUrl.startsWith('https')) {
+            this.client = axios_1.default.create({
+                baseURL: config.webhookUrl,
+                timeout: 500,
+                headers: { 'Content-Type': 'application/json' },
+            });
+        }
+    }
+    _toggleBlocked() {
+        this.status = {
+            blocked: !this.status.blocked,
+            lastUpdateAt: new Date(),
+        };
+    }
+    _format(...messages) {
+        const blocks = [];
+        if (messages.length === 0)
+            return blocks;
+        if (messages.length > 0 && typeof messages[0] === 'string') {
+            blocks.push({
+                type: 'header',
+                text: { type: 'plain_text', text: messages[0] },
+            });
+            return blocks;
+        }
+        for (const msg of messages) {
+            if (!msg)
+                continue;
+            if (msg instanceof Error) {
+                blocks.push({
+                    type: 'section',
+                    text: {
+                        type: 'mrkdwn',
+                        text: '<font color="red">```**' +
+                            msg.name +
+                            '**: ' +
+                            msg.message +
+                            '\n  ' +
+                            msg?.stack?.split('\n').join('\n  ') +
+                            '</font>```',
+                    },
+                });
+            }
+            else if (typeof msg === 'object') {
+                blocks.push({
+                    type: 'section',
+                    text: { type: 'mrkdwn', text: '```json' + JSON.stringify(msg, null, 2) + '```' },
+                });
+            }
+            else {
+                blocks.push({
+                    type: 'section',
+                    text: { type: 'plain_text', text: msg?.toString() },
+                });
+            }
+        }
+        return blocks;
+    }
+    async send(...messages) {
+        if (!this.client)
+            return;
+        if (this.status.blocked && new Date().getTime() - this.status.lastUpdateAt.getTime() < 60_000 * 60 * 3)
+            return;
+        return await this.client
+            .post('', { blocks: this._format(...messages) })
+            .then((data) => {
+            if (this.status.blocked)
+                this._toggleBlocked();
+            return data;
+        })
+            .catch((error) => {
+            this?.logger.error('Failed to send slack notification', error);
+            if (!this.status.blocked)
+                this._toggleBlocked();
+        });
+    }
+}
+exports.Slack = Slack;

package/dist/drivers/queues/app.queue.d.ts

@@ -0,0 +1,11 @@
+import { Job } from 'bull';
+import { AppLogger } from '../logger/app.logger';
+export declare class AppQueue {
+    protected logger: AppLogger;
+    constructor();
+    onProgress(job: Job): void;
+    onCompleted(job: Job): void;
+    onStalled(job: Job): void;
+    onError(job: Job): void;
+    onFailed(job: Job, error: unknown): void;
+}

package/dist/drivers/queues/app.queue.js

@@ -0,0 +1,66 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppQueue = void 0;
+const bull_1 = require("@nestjs/bull");
+const app_logger_1 = require("../logger/app.logger");
+class AppQueue {
+    logger = new app_logger_1.AppLogger(this.constructor.name);
+    constructor() {
+        this.logger.log(this.constructor.name + ' is ready');
+    }
+    onProgress(job) {
+        this.logger.log(`Job ${job.id} in ${job.name} is active`, job.data);
+    }
+    onCompleted(job) {
+        this.logger.log(`Job ${job.id} in ${job.name} is completed`, job.data);
+    }
+    onStalled(job) {
+        this.logger.error(`Job ${job.id} in ${job.name} is stalled`, job.data);
+    }
+    onError(job) {
+        this.logger.error(`Job ${job.id} in ${job.name} is error`, job.data);
+    }
+    onFailed(job, error) {
+        this.logger.error(`Job ${job.id} in ${job.name} is failed`, job.data, error);
+    }
+}
+exports.AppQueue = AppQueue;
+__decorate([
+    (0, bull_1.OnQueueProgress)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], AppQueue.prototype, "onProgress", null);
+__decorate([
+    (0, bull_1.OnQueueCompleted)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], AppQueue.prototype, "onCompleted", null);
+__decorate([
+    (0, bull_1.OnQueueStalled)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], AppQueue.prototype, "onStalled", null);
+__decorate([
+    (0, bull_1.OnQueueError)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], AppQueue.prototype, "onError", null);
+__decorate([
+    (0, bull_1.OnQueueFailed)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", void 0)
+], AppQueue.prototype, "onFailed", null);

package/dist/drivers/queues/index.d.ts

@@ -0,0 +1,2 @@
+export * from './app.queue';
+export * from './queue.module';

package/dist/drivers/queues/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./app.queue"), exports);
+__exportStar(require("./queue.module"), exports);

package/dist/drivers/queues/queue.module.d.ts

@@ -0,0 +1,2 @@
+export declare class QueueModule {
+}

package/dist/drivers/queues/queue.module.js

@@ -0,0 +1,41 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueueModule = void 0;
+const bullmq_1 = require("@nestjs/bullmq");
+const common_1 = require("@nestjs/common");
+const config_1 = require("../../config");
+let QueueModule = class QueueModule {
+};
+exports.QueueModule = QueueModule;
+exports.QueueModule = QueueModule = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({
+        imports: [
+            bullmq_1.BullModule.forRootAsync({
+                useFactory: async () => ({
+                    prefix: config_1.APP_KEY + ':JOBS:',
+                    defaultJobOptions: {
+                        delay: 0,
+                        removeOnComplete: true,
+                        removeOnFail: false,
+                        backoff: { type: 'exponential', delay: 10 },
+                        attempts: 2,
+                    },
+                    connection: {
+                        host: config_1.REDIS_HOST,
+                        port: config_1.REDIS_PORT,
+                        db: config_1.REDIS_DB,
+                        password: config_1.REDIS_PASSWORD,
+                        tls: config_1.REDIS_TLS ? { ca: '' } : undefined,
+                    },
+                }),
+            }),
+        ],
+    })
+], QueueModule);

package/dist/helpers/exception.helper.d.ts

@@ -0,0 +1,35 @@
+import { BadGatewayException, BadRequestException, ConflictException, ForbiddenException, GatewayTimeoutException, InternalServerErrorException, NotFoundException, ServiceUnavailableException, UnauthorizedException, UnprocessableEntityException } from '@nestjs/common';
+type BadRequestParams<T = any> = Partial<Record<keyof T, string>>;
+export declare class AppBadRequestException<T> extends BadRequestException {
+    constructor(err: BadRequestParams<T>);
+    constructor(err: string);
+    has(str: string): boolean;
+}
+export declare class AppUnprocessableEntityException extends UnprocessableEntityException {
+    constructor(message?: string);
+}
+export declare class AppNotFoundException extends NotFoundException {
+    constructor(message?: string);
+}
+export declare class AppForbiddenException extends ForbiddenException {
+    constructor(message?: string);
+}
+export declare class AppUnauthorizedException extends UnauthorizedException {
+    constructor(message?: string);
+}
+export declare class AppConflictException extends ConflictException {
+    constructor(message?: string);
+}
+export declare class AppBadGatewayException extends BadGatewayException {
+    constructor(message?: string);
+}
+export declare class AppGatewayTimeoutException extends GatewayTimeoutException {
+    constructor(message?: string);
+}
+export declare class AppInternalServerErrorException extends InternalServerErrorException {
+    constructor(message?: string);
+}
+export declare class AppServiceUnavailableException extends ServiceUnavailableException {
+    constructor(message?: string);
+}
+export {};

package/dist/helpers/exception.helper.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppServiceUnavailableException = exports.AppInternalServerErrorException = exports.AppGatewayTimeoutException = exports.AppBadGatewayException = exports.AppConflictException = exports.AppUnauthorizedException = exports.AppForbiddenException = exports.AppNotFoundException = exports.AppUnprocessableEntityException = exports.AppBadRequestException = void 0;
+const common_1 = require("@nestjs/common");
+class AppBadRequestException extends common_1.BadRequestException {
+    constructor(err) {
+        const errors = typeof err === 'string'
+            ? { error: err }
+            : Object.entries(err).reduce((acc, [key, value]) => ({ ...acc, [key]: value }), {});
+        super({ statusCode: 400, message: 'Bad request', errors });
+        this.message = (typeof err === 'string' ? [err] : Object.values(err).flat()).join(', ');
+    }
+    has(str) {
+        return this.message.includes(str);
+    }
+}
+exports.AppBadRequestException = AppBadRequestException;
+class AppUnprocessableEntityException extends common_1.UnprocessableEntityException {
+    constructor(message) {
+        super({ statusCode: 422, message: message || 'Unprocessable entity' });
+    }
+}
+exports.AppUnprocessableEntityException = AppUnprocessableEntityException;
+class AppNotFoundException extends common_1.NotFoundException {
+    constructor(message) {
+        super({ statusCode: 404, message: message || 'Not found' });
+    }
+}
+exports.AppNotFoundException = AppNotFoundException;
+class AppForbiddenException extends common_1.ForbiddenException {
+    constructor(message) {
+        super({ statusCode: 403, message: message || 'Forbidden' });
+    }
+}
+exports.AppForbiddenException = AppForbiddenException;
+class AppUnauthorizedException extends common_1.UnauthorizedException {
+    constructor(message) {
+        super({ statusCode: 401, message: message || 'Unauthorized' });
+    }
+}
+exports.AppUnauthorizedException = AppUnauthorizedException;
+class AppConflictException extends common_1.ConflictException {
+    constructor(message) {
+        super({ statusCode: 409, message: message || 'Conflict' });
+    }
+}
+exports.AppConflictException = AppConflictException;
+class AppBadGatewayException extends common_1.BadGatewayException {
+    constructor(message) {
+        super({ statusCode: 502, message: message || 'Bad gateway' });
+    }
+}
+exports.AppBadGatewayException = AppBadGatewayException;
+class AppGatewayTimeoutException extends common_1.GatewayTimeoutException {
+    constructor(message) {
+        super({ statusCode: 504, message: message || 'Gateway timeout' });
+    }
+}
+exports.AppGatewayTimeoutException = AppGatewayTimeoutException;
+class AppInternalServerErrorException extends common_1.InternalServerErrorException {
+    constructor(message) {
+        super({ statusCode: 500, message: message || 'Internal server error' });
+    }
+}
+exports.AppInternalServerErrorException = AppInternalServerErrorException;
+class AppServiceUnavailableException extends common_1.ServiceUnavailableException {
+    constructor(message) {
+        super({ statusCode: 503, message: message || 'Service unavailable' });
+    }
+}
+exports.AppServiceUnavailableException = AppServiceUnavailableException;

package/dist/helpers/http.helper.d.ts

@@ -0,0 +1,23 @@
+import { ArgumentsHost, CallHandler, ExceptionFilter, ExecutionContext, HttpException, HttpStatus, NestInterceptor } from '@nestjs/common';
+import { Response } from 'express';
+import { Observable } from 'rxjs';
+export declare function CatchError(err: string): (target: any, key: string, descriptor: PropertyDescriptor) => void;
+export declare class HttpExceptionFilter implements ExceptionFilter {
+    catch(exception: HttpException, host: ArgumentsHost): void;
+}
+type ResponseData<T> = {
+    statusCode: number;
+    message: string;
+    data: T;
+};
+export declare class TransformResponseInterceptor<T> implements NestInterceptor<T, ResponseData<T>> {
+    intercept(context: ExecutionContext, next: CallHandler): Observable<Response<T>>;
+}
+export declare class ResponseInterceptor<T> implements NestInterceptor<T, ResponseData<T>> {
+    private readonly message;
+    private readonly status;
+    constructor(message?: string, status?: HttpStatus);
+    intercept(context: ExecutionContext, next: CallHandler): Observable<Response<T>>;
+}
+export declare const HandleResponse: (message: string, status?: HttpStatus) => MethodDecorator & ClassDecorator;
+export {};