@aptana/multichannel-common 2.9.12

package/core/infrastructure/http/middleware/routeNotFoundMiddleware.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.routeNotFoundMiddleware = void 0;
+const NotFoundError_1 = __importDefault(require("../../../../core/errors/NotFoundError"));
+function routeNotFoundMiddleware(req, res, next) {
+    throw new NotFoundError_1.default();
+}
+exports.routeNotFoundMiddleware = routeNotFoundMiddleware;

package/core/infrastructure/http/middleware/validationMiddleware.d.ts

@@ -0,0 +1,4 @@
+import { RequestHandler } from 'express';
+export declare function validateBodyMiddleware<T>(type: any, skipMissingProperties?: boolean): RequestHandler;
+export declare function validateQueryMiddleware<T>(type: any, skipMissingProperties?: boolean): RequestHandler;
+export declare const validationMiddleware: typeof validateBodyMiddleware;

package/core/infrastructure/http/middleware/validationMiddleware.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validationMiddleware = exports.validateQueryMiddleware = exports.validateBodyMiddleware = void 0;
+const RequestValidationError_1 = require("../../../../core/errors/RequestValidationError");
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+function validateBodyMiddleware(type, skipMissingProperties = false) {
+    return (req, res, next) => {
+        (0, class_validator_1.validate)((0, class_transformer_1.plainToClass)(type, req.body), { skipMissingProperties })
+            .then((errors) => {
+            if (errors.length > 0) {
+                next(new RequestValidationError_1.RequestValidationError(errors));
+            }
+            else {
+                next();
+            }
+        });
+    };
+}
+exports.validateBodyMiddleware = validateBodyMiddleware;
+function validateQueryMiddleware(type, skipMissingProperties = false) {
+    return (req, res, next) => {
+        (0, class_validator_1.validate)((0, class_transformer_1.plainToClass)(type, req.query, { enableImplicitConversion: false }), { skipMissingProperties })
+            .then((errors) => {
+            if (errors.length > 0) {
+                next(new RequestValidationError_1.RequestValidationError(errors));
+            }
+            else {
+                next();
+            }
+        });
+    };
+}
+exports.validateQueryMiddleware = validateQueryMiddleware;
+exports.validationMiddleware = validateBodyMiddleware;

package/core/infrastructure/loaders/Loader.d.ts

@@ -0,0 +1,8 @@
+import { Loader as LoaderContract } from "../../../core/domain/loaders/Loader";
+import { Container } from '../../../core/infrastructure/Container';
+export declare abstract class Loader implements LoaderContract {
+    protected container: typeof Container;
+    constructor();
+    load(): void;
+    abstract register(): void;
+}

package/core/infrastructure/loaders/Loader.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Loader = void 0;
+const Container_1 = require("../../../core/infrastructure/Container");
+class Loader {
+    container;
+    constructor() {
+        this.container = Container_1.Container;
+    }
+    load() {
+        this.register();
+    }
+}
+exports.Loader = Loader;

package/core/infrastructure/loaders/Manager.d.ts

@@ -0,0 +1,7 @@
+import { Manager as LoaderManagerContract } from '../../../core/domain/loaders/Manager';
+export declare class LoaderManager implements LoaderManagerContract {
+    protected loaders: any[];
+    constructor(loaders: any[]);
+    load(): void;
+    protected resolve(klass: any): any;
+}

package/core/infrastructure/loaders/Manager.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoaderManager = void 0;
+class LoaderManager {
+    loaders = [
+    //
+    ];
+    constructor(loaders) {
+        this.loaders.push(...loaders);
+    }
+    load() {
+        this.loaders.forEach((loader) => {
+            const instance = this.resolve(loader);
+            instance.load();
+        });
+    }
+    resolve(klass) {
+        if (klass instanceof Function) {
+            klass = new klass();
+        }
+        return klass;
+    }
+}
+exports.LoaderManager = LoaderManager;

package/core/modules/health/errors/ConnectionNotFoundError.d.ts

@@ -0,0 +1,4 @@
+import { HealthCheckError } from './HealthCheckError';
+export declare class ConnectionNotFoundError extends HealthCheckError {
+    constructor();
+}

package/core/modules/health/errors/ConnectionNotFoundError.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionNotFoundError = void 0;
+const HealthCheckError_1 = require("./HealthCheckError");
+class ConnectionNotFoundError extends HealthCheckError_1.HealthCheckError {
+    constructor() {
+        super('Connection provider not found in application context');
+    }
+}
+exports.ConnectionNotFoundError = ConnectionNotFoundError;

package/core/modules/health/errors/HealthCheckError.d.ts

@@ -0,0 +1,3 @@
+export declare class HealthCheckError extends Error {
+    constructor(message: string);
+}

package/core/modules/health/errors/HealthCheckError.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HealthCheckError = void 0;
+class HealthCheckError extends Error {
+    constructor(message) {
+        super(message);
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+exports.HealthCheckError = HealthCheckError;

package/core/modules/health/errors/TimeoutError.d.ts

@@ -0,0 +1,4 @@
+import { HealthCheckError } from './HealthCheckError';
+export declare class TimeoutError extends HealthCheckError {
+    constructor(timeout: number);
+}

package/core/modules/health/errors/TimeoutError.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeoutError = void 0;
+const HealthCheckError_1 = require("./HealthCheckError");
+class TimeoutError extends HealthCheckError_1.HealthCheckError {
+    constructor(timeout) {
+        super(`Timeout ${timeout}ms exceeded`);
+    }
+}
+exports.TimeoutError = TimeoutError;

package/core/modules/health/useCases/health/HealthController.d.ts

@@ -0,0 +1,20 @@
+import { Controller } from '../../../../../core/infrastructure/Controller';
+import { Request, Response } from 'express';
+import { HealthCheck } from '../healthCheck/HealthCheck';
+import { MongooseHealthIndicator } from '../healthIndicator/database/mongooseHealthIndicator';
+import { SequelizeHealthIndicator } from '../healthIndicator/database/sequelizeHealthIndicator';
+import { RabbitmqHealthIndicator } from '../healthIndicator/message-broker/rabbitmqHealthIndicator';
+import { HealthIndicatorFunction } from '../healthIndicator/HealthIndicator';
+export default class HealthController extends Controller {
+    private readonly health;
+    protected readonly mongoose: MongooseHealthIndicator;
+    protected readonly rabbitmq: RabbitmqHealthIndicator;
+    protected readonly sequelize: SequelizeHealthIndicator;
+    constructor(health: HealthCheck, mongoose: MongooseHealthIndicator, rabbitmq: RabbitmqHealthIndicator, sequelize: SequelizeHealthIndicator);
+    registerRoutes(): void;
+    show(req: Request, res: Response): Promise<Response<any, Record<string, any>>>;
+    protected getHealthServices(): HealthIndicatorFunction[];
+    protected rmqPingCheck(): HealthIndicatorFunction[];
+    protected mongoPingCheck(): HealthIndicatorFunction[];
+    protected sequelizePingCheck(): HealthIndicatorFunction[];
+}

package/core/modules/health/useCases/health/HealthController.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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Container_1 = require("../../../../../core/infrastructure/Container");
+const Controller_1 = require("../../../../../core/infrastructure/Controller");
+const HealthCheck_1 = require("../healthCheck/HealthCheck");
+const mongooseHealthIndicator_1 = require("../healthIndicator/database/mongooseHealthIndicator");
+const sequelizeHealthIndicator_1 = require("../healthIndicator/database/sequelizeHealthIndicator");
+const rabbitmqHealthIndicator_1 = require("../healthIndicator/message-broker/rabbitmqHealthIndicator");
+const response_1 = require("../../../../../core/utils/response");
+let HealthController = class HealthController extends Controller_1.Controller {
+    health;
+    mongoose;
+    rabbitmq;
+    sequelize;
+    constructor(health, mongoose, rabbitmq, sequelize) {
+        super();
+        this.health = health;
+        this.mongoose = mongoose;
+        this.rabbitmq = rabbitmq;
+        this.sequelize = sequelize;
+    }
+    registerRoutes() {
+        this.router.get('/health', this.show.bind(this));
+    }
+    async show(req, res) {
+        try {
+            const services = this.getHealthServices();
+            const data = await this.health.check(services);
+            return this.ok(res, data);
+        }
+        catch (error) {
+            return (0, response_1.sendSuccessResponse)(res, error, 500);
+        }
+    }
+    getHealthServices() {
+        const services = [];
+        const health = Container_1.Container.get('health');
+        if (health?.rmq) {
+            services.push(...this.rmqPingCheck());
+        }
+        if (health?.mongo) {
+            services.push(...this.mongoPingCheck());
+        }
+        if (health?.mysql) {
+            services.push(...this.sequelizePingCheck());
+        }
+        return services;
+    }
+    rmqPingCheck() {
+        return [async () => this.rabbitmq.pingCheck('rmq')];
+    }
+    mongoPingCheck() {
+        return [async () => this.mongoose.pingCheck('mongo')];
+    }
+    sequelizePingCheck() {
+        return [async () => this.sequelize.pingCheck('mysql')];
+    }
+};
+HealthController = __decorate([
+    (0, Container_1.Service)(),
+    __metadata("design:paramtypes", [HealthCheck_1.HealthCheck,
+        mongooseHealthIndicator_1.MongooseHealthIndicator,
+        rabbitmqHealthIndicator_1.RabbitmqHealthIndicator,
+        sequelizeHealthIndicator_1.SequelizeHealthIndicator])
+], HealthController);
+exports.default = HealthController;

package/core/modules/health/useCases/healthCheck/HealthCheck.d.ts

@@ -0,0 +1,8 @@
+import { HealthIndicatorFunction } from '../healthIndicator/HealthIndicator';
+import { HealthCheckExecutor } from './HealthCheckExecutor';
+import { HealthCheckResult } from './HealthCheckResult';
+export declare class HealthCheck {
+    private readonly healthCheckExecutor;
+    constructor(healthCheckExecutor: HealthCheckExecutor);
+    check(healthIndicators: HealthIndicatorFunction[]): Promise<HealthCheckResult>;
+}

package/core/modules/health/useCases/healthCheck/HealthCheck.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.HealthCheck = void 0;
+const Container_1 = require("../../../../../core/infrastructure/Container");
+const HealthCheckError_1 = require("../../errors/HealthCheckError");
+const HealthCheckExecutor_1 = require("./HealthCheckExecutor");
+let HealthCheck = class HealthCheck {
+    healthCheckExecutor;
+    constructor(healthCheckExecutor) {
+        this.healthCheckExecutor = healthCheckExecutor;
+        // 
+    }
+    async check(healthIndicators) {
+        const result = await this.healthCheckExecutor.execute(healthIndicators);
+        if (result.status === 'ok') {
+            return result;
+        }
+        if (result.status === 'error') {
+            throw result;
+        }
+        throw new HealthCheckError_1.HealthCheckError('Service Unavailable');
+    }
+};
+HealthCheck = __decorate([
+    (0, Container_1.Service)(),
+    __metadata("design:paramtypes", [HealthCheckExecutor_1.HealthCheckExecutor])
+], HealthCheck);
+exports.HealthCheck = HealthCheck;

package/core/modules/health/useCases/healthCheck/HealthCheckExecutor.d.ts

@@ -0,0 +1,8 @@
+import { HealthIndicatorFunction } from '../healthIndicator/HealthIndicator';
+import { HealthCheckResult } from './HealthCheckResult';
+export declare class HealthCheckExecutor {
+    execute(healthIndicators: HealthIndicatorFunction[]): Promise<HealthCheckResult>;
+    private executeHealthIndicators;
+    private getResults;
+    private getSummary;
+}

package/core/modules/health/useCases/healthCheck/HealthCheckExecutor.js

@@ -0,0 +1,48 @@
+"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.HealthCheckExecutor = void 0;
+const Container_1 = require("../../../../../core/infrastructure/Container");
+let HealthCheckExecutor = class HealthCheckExecutor {
+    async execute(healthIndicators) {
+        const { results, errors } = await this.executeHealthIndicators(healthIndicators);
+        return await this.getResults(results, errors);
+    }
+    async executeHealthIndicators(healthIndicators) {
+        const results = [];
+        const errors = [];
+        const result = await Promise.allSettled(healthIndicators.map(async (h) => h()));
+        result.forEach((res) => {
+            if (res.status === 'fulfilled') {
+                results.push(res.value);
+            }
+            else {
+                const error = res.reason;
+                errors.push(error);
+            }
+        });
+        return { results, errors };
+    }
+    async getResults(results, errors) {
+        const infoErrorCombained = results.concat(errors);
+        const details = this.getSummary(infoErrorCombained);
+        let status = 'ok';
+        status = errors.length > 0 ? 'error' : status;
+        return {
+            status,
+            details
+        };
+    }
+    getSummary(results) {
+        return results.reduce((prev, curr) => Object.assign(prev, curr), {});
+    }
+};
+HealthCheckExecutor = __decorate([
+    (0, Container_1.Service)()
+], HealthCheckExecutor);
+exports.HealthCheckExecutor = HealthCheckExecutor;

package/core/modules/health/useCases/healthCheck/HealthCheckResult.d.ts

@@ -0,0 +1,6 @@
+import { HealthIndicatorResult } from '../healthIndicator/HealthIndicatorResult';
+export type HealthCheckStatus = 'error' | 'ok' | 'shutdown';
+export interface HealthCheckResult {
+    status: HealthCheckStatus;
+    details: HealthIndicatorResult;
+}

package/core/modules/health/useCases/healthCheck/HealthCheckResult.js

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

package/core/modules/health/useCases/healthIndicator/HealthIndicator.d.ts

@@ -0,0 +1,7 @@
+import { HealthIndicatorResult } from './HealthIndicatorResult';
+export type HealthIndicatorFunction = () => Promise<HealthIndicatorResult> | HealthIndicatorResult;
+export declare abstract class HealthIndicator {
+    protected getStatus(key: string, isHealthy: boolean, data?: {
+        [key: string]: any;
+    }): HealthIndicatorResult;
+}

package/core/modules/health/useCases/healthIndicator/HealthIndicator.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HealthIndicator = void 0;
+class HealthIndicator {
+    getStatus(key, isHealthy, data) {
+        return {
+            [key]: {
+                status: isHealthy ? 'up' : 'down',
+                ...data
+            }
+        };
+    }
+}
+exports.HealthIndicator = HealthIndicator;

package/core/modules/health/useCases/healthIndicator/HealthIndicatorResult.d.ts

@@ -0,0 +1,7 @@
+export type HealthIndicatorStatus = 'up' | 'down';
+export type HealthIndicatorResult = {
+    [key: string]: {
+        status: HealthIndicatorStatus;
+        [key: string]: any;
+    };
+};

package/core/modules/health/useCases/healthIndicator/HealthIndicatorResult.js

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

package/core/modules/health/useCases/healthIndicator/database/mongooseHealthIndicator.d.ts

@@ -0,0 +1,21 @@
+import { HealthIndicatorResult } from '../HealthIndicatorResult';
+import { HealthIndicator } from '../HealthIndicator';
+export interface MongoosePingCheckOptions {
+    connection?: any;
+    /**
+     * The amount of time the check should require in ms
+     */
+    timeout?: number;
+}
+export declare class MongooseHealthIndicator extends HealthIndicator {
+    /**
+     * Checks if the MongoDB responds in (default) 1000ms and
+     * returns a result object corresponding to the result
+     *
+     * @example
+     * mongooseHealthIndicator.pingCheck('mongodb', { timeout: 1000 });
+     */
+    pingCheck(key: string, options?: MongoosePingCheckOptions): Promise<HealthIndicatorResult>;
+    private pingDB;
+    private getContextConnection;
+}

package/core/modules/health/useCases/healthIndicator/database/mongooseHealthIndicator.js

@@ -0,0 +1,69 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongooseHealthIndicator = void 0;
+const HealthIndicator_1 = require("../HealthIndicator");
+const mongoose_1 = __importDefault(require("mongoose"));
+const ConnectionNotFoundError_1 = require("../../../errors/ConnectionNotFoundError");
+const HealthCheckError_1 = require("../../../errors/HealthCheckError");
+const promise_1 = require("../../../utils/promise");
+const TimeoutError_1 = require("../../../errors/TimeoutError");
+const Container_1 = require("../../../../../../core/infrastructure/Container");
+let MongooseHealthIndicator = class MongooseHealthIndicator extends HealthIndicator_1.HealthIndicator {
+    /**
+     * Checks if the MongoDB responds in (default) 1000ms and
+     * returns a result object corresponding to the result
+     *
+     * @example
+     * mongooseHealthIndicator.pingCheck('mongodb', { timeout: 1000 });
+     */
+    async pingCheck(key, options) {
+        let isHealthy = false;
+        const connection = options?.connection || this.getContextConnection();
+        const timeout = options?.timeout || 1000;
+        if (!connection) {
+            throw new ConnectionNotFoundError_1.ConnectionNotFoundError();
+        }
+        try {
+            await this.pingDB(connection, timeout);
+            isHealthy = true;
+        }
+        catch (err) {
+            if (err instanceof TimeoutError_1.TimeoutError) {
+                throw new TimeoutError_1.TimeoutError(timeout);
+            }
+        }
+        if (isHealthy) {
+            return this.getStatus(key, isHealthy);
+        }
+        else {
+            throw this.getStatus(key, isHealthy, {
+                error: new HealthCheckError_1.HealthCheckError(`${key} is not available`).message
+            });
+        }
+    }
+    async pingDB(connection, timeout) {
+        const promise = connection.readyState === 1 ? Promise.resolve() : Promise.reject();
+        return await (0, promise_1.promiseTimeout)(timeout, promise);
+    }
+    getContextConnection() {
+        try {
+            return mongoose_1.default.connection;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+};
+MongooseHealthIndicator = __decorate([
+    (0, Container_1.Service)()
+], MongooseHealthIndicator);
+exports.MongooseHealthIndicator = MongooseHealthIndicator;

package/core/modules/health/useCases/healthIndicator/database/sequelizeHealthIndicator.d.ts

@@ -0,0 +1,27 @@
+import { HealthIndicatorResult } from '../HealthIndicatorResult';
+import { HealthIndicator } from '../HealthIndicator';
+import { Sequelize } from 'sequelize';
+export interface SequelizePingCheckOptions {
+    connection?: Sequelize;
+    /**
+     * The amount of time the check should require in ms
+     */
+    timeout?: number;
+}
+export declare class SequelizeHealthIndicator extends HealthIndicator {
+    /**
+     * Checks if the MySQL/PostgreSQL database responds in (default) 1000ms
+     * Uses existing connection pool, does NOT create new connections
+     *
+     * @example
+     * sequelizeHealthIndicator.pingCheck('mysql', { timeout: 1000 });
+     */
+    pingCheck(key: string, options?: SequelizePingCheckOptions): Promise<HealthIndicatorResult>;
+    /**
+     * Ping database using existing connection pool
+     * Uses Sequelize.authenticate() which executes a simple query (SELECT 1)
+     * Does NOT create new database connections
+     */
+    private pingDB;
+    private getContextConnection;
+}

package/core/modules/health/useCases/healthIndicator/database/sequelizeHealthIndicator.js

@@ -0,0 +1,73 @@
+"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.SequelizeHealthIndicator = void 0;
+const HealthIndicator_1 = require("../HealthIndicator");
+const ConnectionNotFoundError_1 = require("../../../errors/ConnectionNotFoundError");
+const HealthCheckError_1 = require("../../../errors/HealthCheckError");
+const promise_1 = require("../../../utils/promise");
+const TimeoutError_1 = require("../../../errors/TimeoutError");
+const Container_1 = require("../../../../../../core/infrastructure/Container");
+let SequelizeHealthIndicator = class SequelizeHealthIndicator extends HealthIndicator_1.HealthIndicator {
+    /**
+     * Checks if the MySQL/PostgreSQL database responds in (default) 1000ms
+     * Uses existing connection pool, does NOT create new connections
+     *
+     * @example
+     * sequelizeHealthIndicator.pingCheck('mysql', { timeout: 1000 });
+     */
+    async pingCheck(key, options) {
+        let isHealthy = false;
+        const connection = options?.connection || this.getContextConnection();
+        const timeout = options?.timeout || 1000;
+        if (!connection) {
+            throw new ConnectionNotFoundError_1.ConnectionNotFoundError();
+        }
+        try {
+            await this.pingDB(connection, timeout);
+            isHealthy = true;
+        }
+        catch (err) {
+            if (err instanceof TimeoutError_1.TimeoutError) {
+                throw new TimeoutError_1.TimeoutError(timeout);
+            }
+            // Log error for debugging
+            console.error(`Health check failed for ${key}:`, err);
+        }
+        if (isHealthy) {
+            return this.getStatus(key, isHealthy);
+        }
+        else {
+            throw this.getStatus(key, isHealthy, {
+                error: new HealthCheckError_1.HealthCheckError(`${key} is not available`).message
+            });
+        }
+    }
+    /**
+     * Ping database using existing connection pool
+     * Uses Sequelize.authenticate() which executes a simple query (SELECT 1)
+     * Does NOT create new database connections
+     */
+    async pingDB(connection, timeout) {
+        const promise = connection.authenticate();
+        return await (0, promise_1.promiseTimeout)(timeout, promise);
+    }
+    getContextConnection() {
+        try {
+            const sequelize = Container_1.Container.get('sequelize');
+            return sequelize;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+};
+SequelizeHealthIndicator = __decorate([
+    (0, Container_1.Service)()
+], SequelizeHealthIndicator);
+exports.SequelizeHealthIndicator = SequelizeHealthIndicator;

package/core/modules/health/useCases/healthIndicator/message-broker/rabbitmqHealthIndicator.d.ts

@@ -0,0 +1,21 @@
+import { HealthIndicatorResult } from '../HealthIndicatorResult';
+import { HealthIndicator } from '../HealthIndicator';
+export interface RabbitmqPingCheckOptions {
+    connection?: any;
+    /**
+     * The amount of time the check should require in ms
+     */
+    timeout?: number;
+}
+export declare class RabbitmqHealthIndicator extends HealthIndicator {
+    /**
+     * Checks if the RabbitMQ responds in (default) 1000ms and
+     * returns a result object corresponding to the result
+     *
+     * @example
+     * rabbitmqHealthIndicator.pingCheck('rabbitmq', { timeout: 1000 });
+     */
+    pingCheck(key: string, options?: RabbitmqPingCheckOptions): Promise<HealthIndicatorResult>;
+    private pingMQ;
+    private getContextConnection;
+}