@tmlmobilidade/databases 20260323.400.54

package/dist/clients/go-clickhouse.d.ts

@@ -0,0 +1,30 @@
+import { ClickHouseClient } from '@clickhouse/client';
+export declare class GOClickHouseClient {
+    private static _instance;
+    private client;
+    private tunnel;
+    /**
+     * Disallow direct instantiation of the service.
+     * Use getClient() instead to ensure singleton behavior.
+     */
+    private constructor();
+    /**
+     * Returns the singleton instance of the subclass.
+     */
+    static getClient(): Promise<ClickHouseClient>;
+    /**
+     * Connects to ClickHouse, setting up the client instance.
+     * If SSH tunneling is required, it establishes the tunnel first.
+     * This method is called internally by the service and should not be used directly.
+     */
+    private connect;
+    /**
+     * Constructs the connection string based on environment variables
+     * and SSH tunneling configuration, and handles both direct connections and SSH-tunneled
+     * connections, validating the necessary environment variables for each case.
+     * This method is called internally by the service and should not be used directly.
+     * @throws Will throw an error if required environment variables are missing or if the SSH tunnel setup fails.
+     * @returns A promise that resolves to the ClickHouse connection string.
+     */
+    private getConnectionString;
+}

package/dist/clients/go-clickhouse.js

@@ -0,0 +1,110 @@
+/* * */
+import { createClient } from '@clickhouse/client';
+import { Logger } from '@tmlmobilidade/logger';
+import { SshTunnelService } from '@tmlmobilidade/ssh';
+/* * */
+export class GOClickHouseClient {
+    //
+    static _instance = null;
+    client;
+    tunnel = null;
+    /**
+     * Disallow direct instantiation of the service.
+     * Use getClient() instead to ensure singleton behavior.
+     */
+    constructor() { }
+    /**
+     * Returns the singleton instance of the subclass.
+     */
+    static async getClient() {
+        // If no instance exists, create one and store the promise.
+        // This ensures that if multiple calls to getClient() happen concurrently,
+        // they will all await the same initialization process.
+        if (!this._instance) {
+            this._instance = (async () => {
+                const instance = new GOClickHouseClient();
+                // This behaves like the constructor,
+                // but allows for async initialization.
+                await instance.connect();
+                return instance;
+            })();
+        }
+        // Await the instance if it's still initializing,
+        // or return it immediately if ready.
+        const instance = await this._instance;
+        return instance.client;
+    }
+    /**
+     * Connects to ClickHouse, setting up the client instance.
+     * If SSH tunneling is required, it establishes the tunnel first.
+     * This method is called internally by the service and should not be used directly.
+     */
+    async connect() {
+        Logger.info('Connecting to GOClickHouseClient...');
+        const connectionString = await this.getConnectionString();
+        this.client = createClient({ url: connectionString });
+    }
+    /**
+     * Constructs the connection string based on environment variables
+     * and SSH tunneling configuration, and handles both direct connections and SSH-tunneled
+     * connections, validating the necessary environment variables for each case.
+     * This method is called internally by the service and should not be used directly.
+     * @throws Will throw an error if required environment variables are missing or if the SSH tunnel setup fails.
+     * @returns A promise that resolves to the ClickHouse connection string.
+     */
+    async getConnectionString() {
+        //
+        //
+        // Validate required environment variables
+        if (process.env.GODB_CLICKHOUSE_TUNNEL_ENABLED !== 'true' && process.env.GODB_CLICKHOUSE_TUNNEL_ENABLED !== 'false') {
+            throw new Error('Missing GODB_CLICKHOUSE_TUNNEL_ENABLED. Please indicate whether SSH tunneling is required by setting GODB_CLICKHOUSE_TUNNEL_ENABLED to "true" or "false".');
+        }
+        if (!process.env.GODB_CLICKHOUSE_HOST || !process.env.GODB_CLICKHOUSE_PORT) {
+            throw new Error('Missing GODB_CLICKHOUSE_HOST or GODB_CLICKHOUSE_PORT');
+        }
+        if (process.env.GODB_CLICKHOUSE_TUNNEL_ENABLED === 'false') {
+            return `http://${process.env.GODB_CLICKHOUSE_USER}:${process.env.GODB_CLICKHOUSE_PASSWORD}@${process.env.GODB_CLICKHOUSE_HOST}:${process.env.GODB_CLICKHOUSE_PORT}`;
+        }
+        // SSH required
+        if (!process.env.GODB_CLICKHOUSE_TUNNEL_LOCAL_PORT) {
+            throw new Error('Missing GODB_CLICKHOUSE_TUNNEL_LOCAL_PORT');
+        }
+        if (!process.env.GODB_CLICKHOUSE_TUNNEL_SSH_HOST || !process.env.GODB_CLICKHOUSE_TUNNEL_SSH_USERNAME) {
+            throw new Error('Missing SSH config');
+        }
+        const sshConfig = {
+            forwardOptions: {
+                dstAddr: process.env.GODB_CLICKHOUSE_HOST,
+                dstPort: Number(process.env.GODB_CLICKHOUSE_PORT),
+                srcAddr: 'localhost',
+                srcPort: Number(process.env.GODB_CLICKHOUSE_TUNNEL_LOCAL_PORT),
+            },
+            serverOptions: {
+                port: Number(process.env.GODB_CLICKHOUSE_TUNNEL_LOCAL_PORT),
+            },
+            sshOptions: {
+                agent: process.env.SSH_AUTH_SOCK,
+                host: process.env.GODB_CLICKHOUSE_TUNNEL_SSH_HOST,
+                keepaliveCountMax: 3,
+                keepaliveInterval: 10_000,
+                port: 22,
+                username: process.env.GODB_CLICKHOUSE_TUNNEL_SSH_USERNAME,
+            },
+            tunnelOptions: {
+                autoClose: false,
+                reconnectOnError: true,
+            },
+        };
+        const sshOptions = {
+            maxRetries: 3,
+        };
+        this.tunnel = new SshTunnelService(sshConfig, sshOptions);
+        Logger.info('[GOClickHouseClient] Setting up SSH Tunnel...');
+        const connection = await this.tunnel.connect();
+        const addr = connection.address();
+        if (!addr || typeof addr !== 'object') {
+            throw new Error('[GOClickHouseClient] Failed to retrieve SSH tunnel address.');
+        }
+        return `http://${process.env.GODB_CLICKHOUSE_USER}:${process.env.GODB_CLICKHOUSE_PASSWORD}@localhost:${addr.port}`;
+    }
+}

package/dist/clients/go-mongo.d.ts

@@ -0,0 +1,30 @@
+import { MongoClient } from 'mongodb';
+export declare class GOMongoClient {
+    private static _instance;
+    private client;
+    private tunnel;
+    /**
+     * Disallow direct instantiation of the service.
+     * Use getClient() instead to ensure singleton behavior.
+     */
+    private constructor();
+    /**
+     * Returns the singleton instance of the subclass.
+     */
+    static getClient(): Promise<MongoClient>;
+    /**
+     * Connects to Mongo, setting up the client instance.
+     * If SSH tunneling is required, it establishes the tunnel first.
+     * This method is called internally by the service and should not be used directly.
+     */
+    private connect;
+    /**
+     * Constructs the connection string based on environment variables
+     * and SSH tunneling configuration, and handles both direct connections and SSH-tunneled
+     * connections, validating the necessary environment variables for each case.
+     * This method is called internally by the service and should not be used directly.
+     * @throws Will throw an error if required environment variables are missing or if the SSH tunnel setup fails.
+     * @returns A promise that resolves to the Mongo connection string.
+     */
+    private getConnectionString;
+}

package/dist/clients/go-mongo.js

@@ -0,0 +1,117 @@
+/* * */
+import { Logger } from '@tmlmobilidade/logger';
+import { SshTunnelService } from '@tmlmobilidade/ssh';
+import { MongoClient } from 'mongodb';
+/* * */
+export class GOMongoClient {
+    //
+    static _instance = null;
+    client;
+    tunnel = null;
+    /**
+     * Disallow direct instantiation of the service.
+     * Use getClient() instead to ensure singleton behavior.
+     */
+    constructor() { }
+    /**
+     * Returns the singleton instance of the subclass.
+     */
+    static async getClient() {
+        // If no instance exists, create one and store the promise.
+        // This ensures that if multiple calls to getClient() happen concurrently,
+        // they will all await the same initialization process.
+        if (!this._instance) {
+            this._instance = (async () => {
+                const instance = new GOMongoClient();
+                // This behaves like the constructor,
+                // but allows for async initialization.
+                await instance.connect();
+                return instance;
+            })();
+        }
+        // Await the instance if it's still initializing,
+        // or return it immediately if ready.
+        const instance = await this._instance;
+        return instance.client;
+    }
+    /**
+     * Connects to Mongo, setting up the client instance.
+     * If SSH tunneling is required, it establishes the tunnel first.
+     * This method is called internally by the service and should not be used directly.
+     */
+    async connect() {
+        Logger.info('Connecting to GOMongoClient...');
+        const connectionString = await this.getConnectionString();
+        this.client = new MongoClient(connectionString);
+        this.client.on('close', () => {
+            console.warn('[GOMongoClient] Database connection closed unexpectedly.');
+        });
+        this.client.on('reconnect', () => {
+            console.log('[GOMongoClient] Database reconnected.');
+        });
+        await this.client.connect();
+    }
+    /**
+     * Constructs the connection string based on environment variables
+     * and SSH tunneling configuration, and handles both direct connections and SSH-tunneled
+     * connections, validating the necessary environment variables for each case.
+     * This method is called internally by the service and should not be used directly.
+     * @throws Will throw an error if required environment variables are missing or if the SSH tunnel setup fails.
+     * @returns A promise that resolves to the Mongo connection string.
+     */
+    async getConnectionString() {
+        //
+        //
+        // Validate required environment variables
+        if (process.env.GODB_MONGO_TUNNEL_ENABLED !== 'true' && process.env.GODB_MONGO_TUNNEL_ENABLED !== 'false') {
+            throw new Error('Missing GODB_MONGO_TUNNEL_ENABLED. Please indicate whether SSH tunneling is required by setting GODB_MONGO_TUNNEL_ENABLED to "true" or "false".');
+        }
+        if (!process.env.GODB_MONGO_HOST || !process.env.GODB_MONGO_PORT) {
+            throw new Error('Missing GODB_MONGO_HOST or GODB_MONGO_PORT');
+        }
+        if (process.env.GODB_MONGO_TUNNEL_ENABLED === 'false') {
+            return `mongodb://${process.env.GODB_MONGO_USER}:${process.env.GODB_MONGO_PASSWORD}@${process.env.GODB_MONGO_HOST}:${process.env.GODB_MONGO_PORT}`;
+        }
+        // SSH required
+        if (!process.env.GODB_MONGO_TUNNEL_LOCAL_PORT) {
+            throw new Error('Missing GODB_MONGO_TUNNEL_LOCAL_PORT');
+        }
+        if (!process.env.GODB_MONGO_TUNNEL_SSH_HOST || !process.env.GODB_MONGO_TUNNEL_SSH_USERNAME) {
+            throw new Error('Missing SSH config');
+        }
+        const sshConfig = {
+            forwardOptions: {
+                dstAddr: process.env.GODB_MONGO_HOST,
+                dstPort: Number(process.env.GODB_MONGO_PORT),
+                srcAddr: 'localhost',
+                srcPort: Number(process.env.GODB_MONGO_TUNNEL_LOCAL_PORT),
+            },
+            serverOptions: {
+                port: Number(process.env.GODB_MONGO_TUNNEL_LOCAL_PORT),
+            },
+            sshOptions: {
+                agent: process.env.SSH_AUTH_SOCK,
+                host: process.env.GODB_MONGO_TUNNEL_SSH_HOST,
+                keepaliveCountMax: 3,
+                keepaliveInterval: 10_000,
+                port: 22,
+                username: process.env.GODB_MONGO_TUNNEL_SSH_USERNAME,
+            },
+            tunnelOptions: {
+                autoClose: false,
+                reconnectOnError: true,
+            },
+        };
+        const sshOptions = {
+            maxRetries: 3,
+        };
+        this.tunnel = new SshTunnelService(sshConfig, sshOptions);
+        Logger.info('[GOMongoClient] Setting up SSH Tunnel...');
+        const connection = await this.tunnel.connect();
+        const addr = connection.address();
+        if (!addr || typeof addr !== 'object') {
+            throw new Error('[GOMongoClient] Failed to retrieve SSH tunnel address.');
+        }
+        return `mongodb://${process.env.GODB_MONGO_USER}:${process.env.GODB_MONGO_PASSWORD}@localhost:${addr.port}`;
+    }
+}

package/dist/clients/index.d.ts

@@ -0,0 +1,5 @@
+export * from './go-clickhouse.js';
+export * from './go-mongo.js';
+export * from './pcgidb-ticketing.js';
+export * from './pcgidb-validations.js';
+export * from './rawdb.js';

package/dist/clients/index.js

@@ -0,0 +1,5 @@
+export * from './go-clickhouse.js';
+export * from './go-mongo.js';
+export * from './pcgidb-ticketing.js';
+export * from './pcgidb-validations.js';
+export * from './rawdb.js';

package/dist/clients/pcgidb-ticketing.d.ts

@@ -0,0 +1,30 @@
+import { MongoClient } from 'mongodb';
+export declare class PCGIDBTicketingService {
+    private static _instance;
+    private client;
+    private tunnel;
+    /**
+     * Disallow direct instantiation of the service.
+     * Use getClient() instead to ensure singleton behavior.
+     */
+    private constructor();
+    /**
+     * Returns the singleton instance of the subclass.
+     */
+    static getClient(): Promise<MongoClient>;
+    /**
+     * Connects to Mongo, setting up the client instance.
+     * If SSH tunneling is required, it establishes the tunnel first.
+     * This method is called internally by the service and should not be used directly.
+     */
+    private connect;
+    /**
+     * Constructs the connection string based on environment variables
+     * and SSH tunneling configuration, and handles both direct connections and SSH-tunneled
+     * connections, validating the necessary environment variables for each case.
+     * This method is called internally by the service and should not be used directly.
+     * @throws Will throw an error if required environment variables are missing or if the SSH tunnel setup fails.
+     * @returns A promise that resolves to the Mongo connection string.
+     */
+    private getConnectionString;
+}

package/dist/clients/pcgidb-ticketing.js

@@ -0,0 +1,117 @@
+/* * */
+import { Logger } from '@tmlmobilidade/logger';
+import { SshTunnelService } from '@tmlmobilidade/ssh';
+import { MongoClient } from 'mongodb';
+/* * */
+export class PCGIDBTicketingService {
+    //
+    static _instance = null;
+    client;
+    tunnel = null;
+    /**
+     * Disallow direct instantiation of the service.
+     * Use getClient() instead to ensure singleton behavior.
+     */
+    constructor() { }
+    /**
+     * Returns the singleton instance of the subclass.
+     */
+    static async getClient() {
+        // If no instance exists, create one and store the promise.
+        // This ensures that if multiple calls to getClient() happen concurrently,
+        // they will all await the same initialization process.
+        if (!this._instance) {
+            this._instance = (async () => {
+                const instance = new PCGIDBTicketingService();
+                // This behaves like the constructor,
+                // but allows for async initialization.
+                await instance.connect();
+                return instance;
+            })();
+        }
+        // Await the instance if it's still initializing,
+        // or return it immediately if ready.
+        const instance = await this._instance;
+        return instance.client;
+    }
+    /**
+     * Connects to Mongo, setting up the client instance.
+     * If SSH tunneling is required, it establishes the tunnel first.
+     * This method is called internally by the service and should not be used directly.
+     */
+    async connect() {
+        Logger.info('Connecting to PCGIDBTicketingService...');
+        const connectionString = await this.getConnectionString();
+        this.client = new MongoClient(connectionString);
+        this.client.on('close', () => {
+            console.warn('[PCGIDBTicketingService] Database connection closed unexpectedly.');
+        });
+        this.client.on('reconnect', () => {
+            console.log('[PCGIDBTicketingService] Database reconnected.');
+        });
+        await this.client.connect();
+    }
+    /**
+     * Constructs the connection string based on environment variables
+     * and SSH tunneling configuration, and handles both direct connections and SSH-tunneled
+     * connections, validating the necessary environment variables for each case.
+     * This method is called internally by the service and should not be used directly.
+     * @throws Will throw an error if required environment variables are missing or if the SSH tunnel setup fails.
+     * @returns A promise that resolves to the Mongo connection string.
+     */
+    async getConnectionString() {
+        //
+        //
+        // Validate required environment variables
+        if (process.env.PCGI_MONGO_DB_TUNNEL_ENABLED !== 'true' && process.env.PCGI_MONGO_DB_TUNNEL_ENABLED !== 'false') {
+            throw new Error('Missing PCGI_MONGO_DB_TUNNEL_ENABLED. Please indicate whether SSH tunneling is required by setting PCGI_MONGO_DB_TUNNEL_ENABLED to "true" or "false".');
+        }
+        if (!process.env.PCGI_MONGO_DB_HOST || !process.env.PCGI_MONGO_DB_PORT) {
+            throw new Error('Missing PCGI_MONGO_DB_HOST or PCGI_MONGO_DB_PORT');
+        }
+        if (process.env.PCGI_MTicketingONGO_DB_TUNNEL_ENABLED === 'false') {
+            return `http://${process.env.PCGI_MTicketingONGO_DB_USER}:${process.env.PCGI_MTicketingONGO_DB_PASSWORD}@${process.env.PCGI_MTicketingONGO_DB_HOST}:${process.env.PCGI_MTicketingONGO_DB_PORT}`;
+        }
+        // SSH required
+        if (!process.env.PCGI_MTicketingONGO_DB_TUNNEL_LOCAL_PORT) {
+            throw new Error('Missing PCGI_MTicketingONGO_DB_TUNNEL_LOCAL_PORT');
+        }
+        if (!process.env.PCGI_MTicketingONGO_DB_TUNNEL_SSH_HOST || !process.env.PCGI_MTicketingONGO_DB_TUNNEL_SSH_USERNAME) {
+            throw new Error('Missing SSH config');
+        }
+        const sshConfig = {
+            forwardOptions: {
+                dstAddr: process.env.PCGI_MTicketingONGO_DB_HOST,
+                dstPort: Number(process.env.PCGI_MTicketingONGO_DB_PORT),
+                srcAddr: 'localhost',
+                srcPort: Number(process.env.PCGI_MTicketingONGO_DB_TUNNEL_LOCAL_PORT),
+            },
+            serverOptions: {
+                port: Number(process.env.PCGI_MTicketingONGO_DB_TUNNEL_LOCAL_PORT),
+            },
+            sshOptions: {
+                agent: process.env.SSH_AUTH_SOCK,
+                host: process.env.PCGI_MTicketingONGO_DB_TUNNEL_SSH_HOST,
+                keepaliveCountMax: 3,
+                keepaliveInterval: 10_000,
+                port: 22,
+                username: process.env.PCGI_MTicketingONGO_DB_TUNNEL_SSH_USERNAME,
+            },
+            tunnelOptions: {
+                autoClose: false,
+                reconnectOnError: true,
+            },
+        };
+        const sshOptions = {
+            maxRetries: 3,
+        };
+        this.tunnel = new SshTunnelService(sshConfig, sshOptions);
+        Logger.info('[PCGIDBTicketingService] Setting up SSH Tunnel...');
+        const connection = await this.tunnel.connect();
+        const addr = connection.address();
+        if (!addr || typeof addr !== 'object') {
+            throw new Error('[PCGIDBTicketingService] Failed to retrieve SSH tunnel address.');
+        }
+        return `http://${process.env.PCGI_MTicketingONGO_DB_USER}:${process.env.PCGI_MTicketingONGO_DB_PASSWORD}@localhost:${addr.port}`;
+    }
+}

package/dist/clients/pcgidb-validations.d.ts

@@ -0,0 +1,29 @@
+export declare class PCGIDBValidationsService {
+    private static _instance;
+    private client;
+    private tunnel;
+    /**
+     * Disallow direct instantiation of the service.
+     * Use getInstance() instead to ensure singleton behavior.
+     */
+    private constructor();
+    /**
+     * Returns the singleton instance of the subclass.
+     */
+    static getInstance(): Promise<PCGIDBValidationsService>;
+    /**
+     * Connects to Mongo, setting up the client instance.
+     * If SSH tunneling is required, it establishes the tunnel first.
+     * This method is called internally by the service and should not be used directly.
+     */
+    private connect;
+    /**
+     * Constructs the connection string based on environment variables
+     * and SSH tunneling configuration, and handles both direct connections and SSH-tunneled
+     * connections, validating the necessary environment variables for each case.
+     * This method is called internally by the service and should not be used directly.
+     * @throws Will throw an error if required environment variables are missing or if the SSH tunnel setup fails.
+     * @returns A promise that resolves to the Mongo connection string.
+     */
+    private getConnectionString;
+}

package/dist/clients/pcgidb-validations.js

@@ -0,0 +1,116 @@
+/* * */
+import { Logger } from '@tmlmobilidade/logger';
+import { SshTunnelService } from '@tmlmobilidade/ssh';
+import { MongoClient } from 'mongodb';
+/* * */
+export class PCGIDBValidationsService {
+    //
+    static _instance = null;
+    client;
+    tunnel = null;
+    /**
+     * Disallow direct instantiation of the service.
+     * Use getInstance() instead to ensure singleton behavior.
+     */
+    constructor() { }
+    /**
+     * Returns the singleton instance of the subclass.
+     */
+    static async getInstance() {
+        // If no instance exists, create one and store the promise.
+        // This ensures that if multiple calls to getInstance() happen concurrently,
+        // they will all await the same initialization process.
+        if (!this._instance) {
+            this._instance = (async () => {
+                const instance = new PCGIDBValidationsService();
+                // This behaves like the constructor,
+                // but allows for async initialization.
+                await instance.connect();
+                return instance;
+            })();
+        }
+        // Await the instance if it's still initializing,
+        // or return it immediately if ready.
+        return this._instance;
+    }
+    /**
+     * Connects to Mongo, setting up the client instance.
+     * If SSH tunneling is required, it establishes the tunnel first.
+     * This method is called internally by the service and should not be used directly.
+     */
+    async connect() {
+        Logger.info('Connecting to PCGIDBValidationsService...');
+        const connectionString = await this.getConnectionString();
+        this.client = new MongoClient(connectionString);
+        this.client.on('close', () => {
+            console.warn('[PCGIDBValidationsService] Database connection closed unexpectedly.');
+        });
+        this.client.on('reconnect', () => {
+            console.log('[PCGIDBValidationsService] Database reconnected.');
+        });
+        await this.client.connect();
+    }
+    /**
+     * Constructs the connection string based on environment variables
+     * and SSH tunneling configuration, and handles both direct connections and SSH-tunneled
+     * connections, validating the necessary environment variables for each case.
+     * This method is called internally by the service and should not be used directly.
+     * @throws Will throw an error if required environment variables are missing or if the SSH tunnel setup fails.
+     * @returns A promise that resolves to the Mongo connection string.
+     */
+    async getConnectionString() {
+        //
+        //
+        // Validate required environment variables
+        if (process.env.PCGI_MONGO_DB_TUNNEL_ENABLED !== 'true' && process.env.PCGI_MONGO_DB_TUNNEL_ENABLED !== 'false') {
+            throw new Error('Missing PCGI_MONGO_DB_TUNNEL_ENABLED. Please indicate whether SSH tunneling is required by setting PCGI_MONGO_DB_TUNNEL_ENABLED to "true" or "false".');
+        }
+        if (!process.env.PCGI_MONGO_DB_HOST || !process.env.PCGI_MONGO_DB_PORT) {
+            throw new Error('Missing PCGI_MONGO_DB_HOST or PCGI_MONGO_DB_PORT');
+        }
+        if (process.env.PCGI_MValidationsONGO_DB_TUNNEL_ENABLED === 'false') {
+            return `http://${process.env.PCGI_MValidationsONGO_DB_USER}:${process.env.PCGI_MValidationsONGO_DB_PASSWORD}@${process.env.PCGI_MValidationsONGO_DB_HOST}:${process.env.PCGI_MValidationsONGO_DB_PORT}`;
+        }
+        // SSH required
+        if (!process.env.PCGI_MValidationsONGO_DB_TUNNEL_LOCAL_PORT) {
+            throw new Error('Missing PCGI_MValidationsONGO_DB_TUNNEL_LOCAL_PORT');
+        }
+        if (!process.env.PCGI_MValidationsONGO_DB_TUNNEL_SSH_HOST || !process.env.PCGI_MValidationsONGO_DB_TUNNEL_SSH_USERNAME) {
+            throw new Error('Missing SSH config');
+        }
+        const sshConfig = {
+            forwardOptions: {
+                dstAddr: process.env.PCGI_MValidationsONGO_DB_HOST,
+                dstPort: Number(process.env.PCGI_MValidationsONGO_DB_PORT),
+                srcAddr: 'localhost',
+                srcPort: Number(process.env.PCGI_MValidationsONGO_DB_TUNNEL_LOCAL_PORT),
+            },
+            serverOptions: {
+                port: Number(process.env.PCGI_MValidationsONGO_DB_TUNNEL_LOCAL_PORT),
+            },
+            sshOptions: {
+                agent: process.env.SSH_AUTH_SOCK,
+                host: process.env.PCGI_MValidationsONGO_DB_TUNNEL_SSH_HOST,
+                keepaliveCountMax: 3,
+                keepaliveInterval: 10_000,
+                port: 22,
+                username: process.env.PCGI_MValidationsONGO_DB_TUNNEL_SSH_USERNAME,
+            },
+            tunnelOptions: {
+                autoClose: false,
+                reconnectOnError: true,
+            },
+        };
+        const sshOptions = {
+            maxRetries: 3,
+        };
+        this.tunnel = new SshTunnelService(sshConfig, sshOptions);
+        Logger.info('[PCGIDBValidationsService] Setting up SSH Tunnel...');
+        const connection = await this.tunnel.connect();
+        const addr = connection.address();
+        if (!addr || typeof addr !== 'object') {
+            throw new Error('[PCGIDBValidationsService] Failed to retrieve SSH tunnel address.');
+        }
+        return `http://${process.env.PCGI_MValidationsONGO_DB_USER}:${process.env.PCGI_MValidationsONGO_DB_PASSWORD}@localhost:${addr.port}`;
+    }
+}

package/dist/clients/rawdb.d.ts

@@ -0,0 +1,29 @@
+export declare class RAWDBService {
+    private static _instance;
+    private client;
+    private tunnel;
+    /**
+     * Disallow direct instantiation of the service.
+     * Use getInstance() instead to ensure singleton behavior.
+     */
+    private constructor();
+    /**
+     * Returns the singleton instance of the subclass.
+     */
+    static getInstance(): Promise<RAWDBService>;
+    /**
+     * Connects to Mongo, setting up the client instance.
+     * If SSH tunneling is required, it establishes the tunnel first.
+     * This method is called internally by the service and should not be used directly.
+     */
+    private connect;
+    /**
+     * Constructs the connection string based on environment variables
+     * and SSH tunneling configuration, and handles both direct connections and SSH-tunneled
+     * connections, validating the necessary environment variables for each case.
+     * This method is called internally by the service and should not be used directly.
+     * @throws Will throw an error if required environment variables are missing or if the SSH tunnel setup fails.
+     * @returns A promise that resolves to the Mongo connection string.
+     */
+    private getConnectionString;
+}