@tmlmobilidade/databases 20260323.417.47 → 20260324.1249.38

package/dist/clients/go-clickhouse.js

@@ -40,7 +40,7 @@ export class GOClickHouseClient {
      * This method is called internally by the service and should not be used directly.
      */
     async connect() {
-        Logger.info('Connecting to GOClickHouseClient...');
+        Logger.info('[GOClickHouseClient] Connecting to database...');
         const connectionString = await this.getConnectionString();
         this.client = createClient({ url: connectionString });
     }
@@ -56,39 +56,39 @@ export class GOClickHouseClient {
         //
         //
         // 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.GO_CLICKHOUSE_TUNNEL_ENABLED !== 'true' && process.env.GO_CLICKHOUSE_TUNNEL_ENABLED !== 'false') {
+            throw new Error('Missing GO_CLICKHOUSE_TUNNEL_ENABLED. Please indicate whether SSH tunneling is required by setting GO_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.GO_CLICKHOUSE_HOST || !process.env.GO_CLICKHOUSE_PORT) {
+            throw new Error('Missing GO_CLICKHOUSE_HOST or GO_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}`;
+        if (process.env.GO_CLICKHOUSE_TUNNEL_ENABLED === 'false') {
+            return `http://${process.env.GO_CLICKHOUSE_USER}:${process.env.GO_CLICKHOUSE_PASSWORD}@${process.env.GO_CLICKHOUSE_HOST}:${process.env.GO_CLICKHOUSE_PORT}`;
         }
         // SSH required
-        if (!process.env.GODB_CLICKHOUSE_TUNNEL_LOCAL_PORT) {
-            throw new Error('Missing GODB_CLICKHOUSE_TUNNEL_LOCAL_PORT');
+        if (!process.env.GO_CLICKHOUSE_TUNNEL_LOCAL_PORT) {
+            throw new Error('Missing GO_CLICKHOUSE_TUNNEL_LOCAL_PORT');
         }
-        if (!process.env.GODB_CLICKHOUSE_TUNNEL_SSH_HOST || !process.env.GODB_CLICKHOUSE_TUNNEL_SSH_USERNAME) {
+        if (!process.env.GO_CLICKHOUSE_TUNNEL_SSH_HOST || !process.env.GO_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),
+                dstAddr: process.env.GO_CLICKHOUSE_HOST,
+                dstPort: Number(process.env.GO_CLICKHOUSE_PORT),
                 srcAddr: 'localhost',
-                srcPort: Number(process.env.GODB_CLICKHOUSE_TUNNEL_LOCAL_PORT),
+                srcPort: Number(process.env.GO_CLICKHOUSE_TUNNEL_LOCAL_PORT),
             },
             serverOptions: {
-                port: Number(process.env.GODB_CLICKHOUSE_TUNNEL_LOCAL_PORT),
+                port: Number(process.env.GO_CLICKHOUSE_TUNNEL_LOCAL_PORT),
             },
             sshOptions: {
                 agent: process.env.SSH_AUTH_SOCK,
-                host: process.env.GODB_CLICKHOUSE_TUNNEL_SSH_HOST,
+                host: process.env.GO_CLICKHOUSE_TUNNEL_SSH_HOST,
                 keepaliveCountMax: 3,
                 keepaliveInterval: 10_000,
                 port: 22,
-                username: process.env.GODB_CLICKHOUSE_TUNNEL_SSH_USERNAME,
+                username: process.env.GO_CLICKHOUSE_TUNNEL_SSH_USERNAME,
             },
             tunnelOptions: {
                 autoClose: false,
@@ -105,6 +105,6 @@ export class GOClickHouseClient {
         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}`;
+        return `http://${process.env.GO_CLICKHOUSE_USER}:${process.env.GO_CLICKHOUSE_PASSWORD}@localhost:${addr.port}`;
     }
 }

package/dist/clients/go-mongo.js

@@ -40,7 +40,7 @@ export class GOMongoClient {
      * This method is called internally by the service and should not be used directly.
      */
     async connect() {
-        Logger.info('Connecting to GOMongoClient...');
+        Logger.info('[GOMongoClient] Connecting to database...');
         const connectionString = await this.getConnectionString();
         this.client = new MongoClient(connectionString);
         this.client.on('close', () => {
@@ -63,39 +63,45 @@ export class GOMongoClient {
         //
         //
         // 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.GO_MONGO_TUNNEL_ENABLED !== 'true' && process.env.GO_MONGO_TUNNEL_ENABLED !== 'false') {
+            throw new Error('Missing GO_MONGO_TUNNEL_ENABLED. Please indicate whether SSH tunneling is required by setting GO_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.GO_MONGO_HOST_1 || !process.env.GO_MONGO_PORT_1) {
+            throw new Error('Missing GO_MONGO_HOST_1 or GO_MONGO_PORT_1');
         }
-        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}`;
+        if (!process.env.GO_MONGO_HOST_2 || !process.env.GO_MONGO_PORT_2) {
+            throw new Error('Missing GO_MONGO_HOST_2 or GO_MONGO_PORT_2');
+        }
+        if (!process.env.GO_MONGO_HOST_3 || !process.env.GO_MONGO_PORT_3) {
+            throw new Error('Missing GO_MONGO_HOST_3 or GO_MONGO_PORT_3');
+        }
+        if (process.env.GO_MONGO_TUNNEL_ENABLED === 'false') {
+            return `mongodb://${process.env.GO_MONGO_USER}:${process.env.GO_MONGO_PASSWORD}@${process.env.GO_MONGO_HOST_1}:${process.env.GO_MONGO_PORT_1},${process.env.GO_MONGO_HOST_2}:${process.env.GO_MONGO_PORT_2},${process.env.GO_MONGO_HOST_3}:${process.env.GO_MONGO_PORT_3}/`;
         }
         // SSH required
-        if (!process.env.GODB_MONGO_TUNNEL_LOCAL_PORT) {
-            throw new Error('Missing GODB_MONGO_TUNNEL_LOCAL_PORT');
+        if (!process.env.GO_MONGO_TUNNEL_LOCAL_PORT) {
+            throw new Error('Missing GO_MONGO_TUNNEL_LOCAL_PORT');
         }
-        if (!process.env.GODB_MONGO_TUNNEL_SSH_HOST || !process.env.GODB_MONGO_TUNNEL_SSH_USERNAME) {
+        if (!process.env.GO_MONGO_TUNNEL_SSH_HOST || !process.env.GO_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),
+                dstAddr: process.env.GO_MONGO_HOST_1,
+                dstPort: Number(process.env.GO_MONGO_PORT_1),
                 srcAddr: 'localhost',
-                srcPort: Number(process.env.GODB_MONGO_TUNNEL_LOCAL_PORT),
+                srcPort: Number(process.env.GO_MONGO_TUNNEL_LOCAL_PORT),
             },
             serverOptions: {
-                port: Number(process.env.GODB_MONGO_TUNNEL_LOCAL_PORT),
+                port: Number(process.env.GO_MONGO_TUNNEL_LOCAL_PORT),
             },
             sshOptions: {
                 agent: process.env.SSH_AUTH_SOCK,
-                host: process.env.GODB_MONGO_TUNNEL_SSH_HOST,
+                host: process.env.GO_MONGO_TUNNEL_SSH_HOST,
                 keepaliveCountMax: 3,
                 keepaliveInterval: 10_000,
                 port: 22,
-                username: process.env.GODB_MONGO_TUNNEL_SSH_USERNAME,
+                username: process.env.GO_MONGO_TUNNEL_SSH_USERNAME,
             },
             tunnelOptions: {
                 autoClose: false,
@@ -112,6 +118,6 @@ export class GOMongoClient {
         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}`;
+        return `mongodb://${process.env.GO_MONGO_USER}:${process.env.GO_MONGO_PASSWORD}@localhost:${addr.port}/`;
     }
 }

package/dist/clients/index.d.ts

@@ -1,5 +1,6 @@
 export * from './go-clickhouse.js';
 export * from './go-mongo.js';
-export * from './pcgidb-ticketing.js';
-export * from './pcgidb-validations.js';
-export * from './rawdb.js';
+export * from './pcgi-file-manager.js';
+export * from './pcgi-raw.js';
+export * from './pcgi-ticketing.js';
+export * from './pcgi-validations.js';

package/dist/clients/index.js

@@ -1,5 +1,6 @@
 export * from './go-clickhouse.js';
 export * from './go-mongo.js';
-export * from './pcgidb-ticketing.js';
-export * from './pcgidb-validations.js';
-export * from './rawdb.js';
+export * from './pcgi-file-manager.js';
+export * from './pcgi-raw.js';
+export * from './pcgi-ticketing.js';
+export * from './pcgi-validations.js';

package/dist/clients/{pcgidb-ticketing.d.ts → pcgi-file-manager.d.ts}

@@ -1,5 +1,5 @@
 import { MongoClient } from 'mongodb';
-export declare class PCGIDBTicketingService {
+export declare class PCGIFileManagerClient {
     private static _instance;
     private client;
     private tunnel;

package/dist/clients/pcgi-file-manager.js

@@ -0,0 +1,123 @@
+/* * */
+import { Logger } from '@tmlmobilidade/logger';
+import { SshTunnelService } from '@tmlmobilidade/ssh';
+import { MongoClient } from 'mongodb';
+/* * */
+export class PCGIFileManagerClient {
+    //
+    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 PCGIFileManagerClient();
+                // 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('[PCGIFileManagerClient] Connecting to database...');
+        const connectionString = await this.getConnectionString();
+        this.client = new MongoClient(connectionString);
+        this.client.on('close', () => {
+            console.warn('[PCGIFileManagerClient] Database connection closed unexpectedly.');
+        });
+        this.client.on('reconnect', () => {
+            console.log('[PCGIFileManagerClient] 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_FILE_MANAGER_TUNNEL_ENABLED !== 'true' && process.env.PCGI_FILE_MANAGER_TUNNEL_ENABLED !== 'false') {
+            throw new Error('Missing PCGI_FILE_MANAGER_TUNNEL_ENABLED. Please indicate whether SSH tunneling is required by setting PCGI_FILE_MANAGER_TUNNEL_ENABLED to "true" or "false".');
+        }
+        if (!process.env.PCGI_FILE_MANAGER_HOST_1 || !process.env.PCGI_FILE_MANAGER_PORT_1) {
+            throw new Error('Missing PCGI_FILE_MANAGER_HOST_1 or PCGI_FILE_MANAGER_PORT_1');
+        }
+        if (!process.env.PCGI_FILE_MANAGER_HOST_2 || !process.env.PCGI_FILE_MANAGER_PORT_2) {
+            throw new Error('Missing PCGI_FILE_MANAGER_HOST_2 or PCGI_FILE_MANAGER_PORT_2');
+        }
+        if (!process.env.PCGI_FILE_MANAGER_HOST_3 || !process.env.PCGI_FILE_MANAGER_PORT_3) {
+            throw new Error('Missing PCGI_FILE_MANAGER_HOST_3 or PCGI_FILE_MANAGER_PORT_3');
+        }
+        if (process.env.PCGI_FILE_MANAGER_TUNNEL_ENABLED === 'false') {
+            return `mongodb://${process.env.PCGI_FILE_MANAGER_USER}:${process.env.PCGI_FILE_MANAGER_PASSWORD}@${process.env.PCGI_FILE_MANAGER_HOST_1}:${process.env.PCGI_FILE_MANAGER_PORT_1},${process.env.PCGI_FILE_MANAGER_HOST_2}:${process.env.PCGI_FILE_MANAGER_PORT_2},${process.env.PCGI_FILE_MANAGER_HOST_3}:${process.env.PCGI_FILE_MANAGER_PORT_3}/`;
+        }
+        // SSH required
+        if (!process.env.PCGI_FILE_MANAGER_TUNNEL_LOCAL_PORT) {
+            throw new Error('Missing PCGI_FILE_MANAGER_TUNNEL_LOCAL_PORT');
+        }
+        if (!process.env.PCGI_FILE_MANAGER_TUNNEL_SSH_HOST || !process.env.PCGI_FILE_MANAGER_TUNNEL_SSH_USERNAME) {
+            throw new Error('Missing SSH config');
+        }
+        const sshConfig = {
+            forwardOptions: {
+                dstAddr: process.env.PCGI_FILE_MANAGER_HOST_1,
+                dstPort: Number(process.env.PCGI_FILE_MANAGER_PORT_1),
+                srcAddr: 'localhost',
+                srcPort: Number(process.env.PCGI_FILE_MANAGER_TUNNEL_LOCAL_PORT),
+            },
+            serverOptions: {
+                port: Number(process.env.PCGI_FILE_MANAGER_TUNNEL_LOCAL_PORT),
+            },
+            sshOptions: {
+                agent: process.env.SSH_AUTH_SOCK,
+                host: process.env.PCGI_FILE_MANAGER_TUNNEL_SSH_HOST,
+                keepaliveCountMax: 3,
+                keepaliveInterval: 10_000,
+                port: 22,
+                username: process.env.PCGI_FILE_MANAGER_TUNNEL_SSH_USERNAME,
+            },
+            tunnelOptions: {
+                autoClose: false,
+                reconnectOnError: true,
+            },
+        };
+        const sshOptions = {
+            maxRetries: 3,
+        };
+        this.tunnel = new SshTunnelService(sshConfig, sshOptions);
+        Logger.info('[PCGIFileManagerClient] Setting up SSH Tunnel...');
+        const connection = await this.tunnel.connect();
+        const addr = connection.address();
+        if (!addr || typeof addr !== 'object') {
+            throw new Error('[PCGIFileManagerClient] Failed to retrieve SSH tunnel address.');
+        }
+        return `mongodb://${process.env.PCGI_FILE_MANAGER_USER}:${process.env.PCGI_FILE_MANAGER_PASSWORD}@localhost:${addr.port}/`;
+    }
+}

package/dist/clients/{rawdb.d.ts → pcgi-raw.d.ts}

@@ -1,16 +1,17 @@
-export declare class RAWDBService {
+import { MongoClient } from 'mongodb';
+export declare class PCGIRawClient {
     private static _instance;
     private client;
     private tunnel;
     /**
      * Disallow direct instantiation of the service.
-     * Use getInstance() instead to ensure singleton behavior.
+     * Use getClient() instead to ensure singleton behavior.
      */
     private constructor();
     /**
      * Returns the singleton instance of the subclass.
      */
-    static getInstance(): Promise<RAWDBService>;
+    static getClient(): Promise<MongoClient>;
     /**
      * Connects to Mongo, setting up the client instance.
      * If SSH tunneling is required, it establishes the tunnel first.

package/dist/clients/{pcgidb-ticketing.js → pcgi-raw.js}

@@ -3,7 +3,7 @@ import { Logger } from '@tmlmobilidade/logger';
 import { SshTunnelService } from '@tmlmobilidade/ssh';
 import { MongoClient } from 'mongodb';
 /* * */
-export class PCGIDBTicketingService {
+export class PCGIRawClient {
     //
     static _instance = null;
     client;
@@ -22,7 +22,7 @@ export class PCGIDBTicketingService {
         // they will all await the same initialization process.
         if (!this._instance) {
             this._instance = (async () => {
-                const instance = new PCGIDBTicketingService();
+                const instance = new PCGIRawClient();
                 // This behaves like the constructor,
                 // but allows for async initialization.
                 await instance.connect();
@@ -40,14 +40,14 @@ export class PCGIDBTicketingService {
      * This method is called internally by the service and should not be used directly.
      */
     async connect() {
-        Logger.info('Connecting to PCGIDBTicketingService...');
+        Logger.info('[PCGIRawClient] Connecting to database...');
         const connectionString = await this.getConnectionString();
         this.client = new MongoClient(connectionString);
         this.client.on('close', () => {
-            console.warn('[PCGIDBTicketingService] Database connection closed unexpectedly.');
+            console.warn('[PCGIRawClient] Database connection closed unexpectedly.');
         });
         this.client.on('reconnect', () => {
-            console.log('[PCGIDBTicketingService] Database reconnected.');
+            console.log('[PCGIRawClient] Database reconnected.');
         });
         await this.client.connect();
     }
@@ -63,39 +63,45 @@ export class PCGIDBTicketingService {
         //
         //
         // 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_RAW_TUNNEL_ENABLED !== 'true' && process.env.PCGI_RAW_TUNNEL_ENABLED !== 'false') {
+            throw new Error('Missing PCGI_RAW_TUNNEL_ENABLED. Please indicate whether SSH tunneling is required by setting PCGI_RAW_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_RAW_HOST_1 || !process.env.PCGI_RAW_PORT_1) {
+            throw new Error('Missing PCGI_RAW_HOST_1 or PCGI_RAW_PORT_1');
         }
-        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}`;
+        if (!process.env.PCGI_RAW_HOST_2 || !process.env.PCGI_RAW_PORT_2) {
+            throw new Error('Missing PCGI_RAW_HOST_2 or PCGI_RAW_PORT_2');
+        }
+        if (!process.env.PCGI_RAW_HOST_3 || !process.env.PCGI_RAW_PORT_3) {
+            throw new Error('Missing PCGI_RAW_HOST_3 or PCGI_RAW_PORT_3');
+        }
+        if (process.env.PCGI_RAW_TUNNEL_ENABLED === 'false') {
+            return `mongodb://${process.env.PCGI_RAW_USER}:${process.env.PCGI_RAW_PASSWORD}@${process.env.PCGI_RAW_HOST_1}:${process.env.PCGI_RAW_PORT_1},${process.env.PCGI_RAW_HOST_2}:${process.env.PCGI_RAW_PORT_2},${process.env.PCGI_RAW_HOST_3}:${process.env.PCGI_RAW_PORT_3}/`;
         }
         // 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_RAW_TUNNEL_LOCAL_PORT) {
+            throw new Error('Missing PCGI_RAW_TUNNEL_LOCAL_PORT');
         }
-        if (!process.env.PCGI_MTicketingONGO_DB_TUNNEL_SSH_HOST || !process.env.PCGI_MTicketingONGO_DB_TUNNEL_SSH_USERNAME) {
+        if (!process.env.PCGI_RAW_TUNNEL_SSH_HOST || !process.env.PCGI_RAW_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),
+                dstAddr: process.env.PCGI_RAW_HOST_1,
+                dstPort: Number(process.env.PCGI_RAW_PORT_1),
                 srcAddr: 'localhost',
-                srcPort: Number(process.env.PCGI_MTicketingONGO_DB_TUNNEL_LOCAL_PORT),
+                srcPort: Number(process.env.PCGI_RAW_TUNNEL_LOCAL_PORT),
             },
             serverOptions: {
-                port: Number(process.env.PCGI_MTicketingONGO_DB_TUNNEL_LOCAL_PORT),
+                port: Number(process.env.PCGI_RAW_TUNNEL_LOCAL_PORT),
             },
             sshOptions: {
                 agent: process.env.SSH_AUTH_SOCK,
-                host: process.env.PCGI_MTicketingONGO_DB_TUNNEL_SSH_HOST,
+                host: process.env.PCGI_RAW_TUNNEL_SSH_HOST,
                 keepaliveCountMax: 3,
                 keepaliveInterval: 10_000,
                 port: 22,
-                username: process.env.PCGI_MTicketingONGO_DB_TUNNEL_SSH_USERNAME,
+                username: process.env.PCGI_RAW_TUNNEL_SSH_USERNAME,
             },
             tunnelOptions: {
                 autoClose: false,
@@ -106,12 +112,12 @@ export class PCGIDBTicketingService {
             maxRetries: 3,
         };
         this.tunnel = new SshTunnelService(sshConfig, sshOptions);
-        Logger.info('[PCGIDBTicketingService] Setting up SSH Tunnel...');
+        Logger.info('[PCGIRawClient] 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.');
+            throw new Error('[PCGIRawClient] Failed to retrieve SSH tunnel address.');
         }
-        return `http://${process.env.PCGI_MTicketingONGO_DB_USER}:${process.env.PCGI_MTicketingONGO_DB_PASSWORD}@localhost:${addr.port}`;
+        return `mongodb://${process.env.PCGI_RAW_USER}:${process.env.PCGI_RAW_PASSWORD}@localhost:${addr.port}/`;
     }
 }

package/dist/clients/{pcgidb-validations.d.ts → pcgi-ticketing.d.ts}

@@ -1,16 +1,17 @@
-export declare class PCGIDBValidationsService {
+import { MongoClient } from 'mongodb';
+export declare class PCGITicketingClient {
     private static _instance;
     private client;
     private tunnel;
     /**
      * Disallow direct instantiation of the service.
-     * Use getInstance() instead to ensure singleton behavior.
+     * Use getClient() instead to ensure singleton behavior.
      */
     private constructor();
     /**
      * Returns the singleton instance of the subclass.
      */
-    static getInstance(): Promise<PCGIDBValidationsService>;
+    static getClient(): Promise<MongoClient>;
     /**
      * Connects to Mongo, setting up the client instance.
      * If SSH tunneling is required, it establishes the tunnel first.

package/dist/clients/{rawdb.js → pcgi-ticketing.js}

@@ -3,26 +3,26 @@ import { Logger } from '@tmlmobilidade/logger';
 import { SshTunnelService } from '@tmlmobilidade/ssh';
 import { MongoClient } from 'mongodb';
 /* * */
-export class RAWDBService {
+export class PCGITicketingClient {
     //
     static _instance = null;
     client;
     tunnel = null;
     /**
      * Disallow direct instantiation of the service.
-     * Use getInstance() instead to ensure singleton behavior.
+     * Use getClient() instead to ensure singleton behavior.
      */
     constructor() { }
     /**
      * Returns the singleton instance of the subclass.
      */
-    static async getInstance() {
+    static async getClient() {
         // If no instance exists, create one and store the promise.
-        // This ensures that if multiple calls to getInstance() happen concurrently,
+        // 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 RAWDBService();
+                const instance = new PCGITicketingClient();
                 // This behaves like the constructor,
                 // but allows for async initialization.
                 await instance.connect();
@@ -31,7 +31,8 @@ export class RAWDBService {
         }
         // Await the instance if it's still initializing,
         // or return it immediately if ready.
-        return this._instance;
+        const instance = await this._instance;
+        return instance.client;
     }
     /**
      * Connects to Mongo, setting up the client instance.
@@ -39,14 +40,14 @@ export class RAWDBService {
      * This method is called internally by the service and should not be used directly.
      */
     async connect() {
-        Logger.info('Connecting to RAWDBService...');
+        Logger.info('[PCGITicketingClient] Connecting to database...');
         const connectionString = await this.getConnectionString();
         this.client = new MongoClient(connectionString);
         this.client.on('close', () => {
-            console.warn('[RAWDBService] Database connection closed unexpectedly.');
+            console.warn('[PCGITicketingClient] Database connection closed unexpectedly.');
         });
         this.client.on('reconnect', () => {
-            console.log('[RAWDBService] Database reconnected.');
+            console.log('[PCGITicketingClient] Database reconnected.');
         });
         await this.client.connect();
     }
@@ -62,39 +63,45 @@ export class RAWDBService {
         //
         //
         // Validate required environment variables
-        if (process.env.RAW_MONGO_DB_TUNNEL_ENABLED !== 'true' && process.env.RAW_MONGO_DB_TUNNEL_ENABLED !== 'false') {
-            throw new Error('Missing RAW_MONGO_DB_TUNNEL_ENABLED. Please indicate whether SSH tunneling is required by setting RAW_MONGO_DB_TUNNEL_ENABLED to "true" or "false".');
+        if (process.env.PCGI_TICKETING_TUNNEL_ENABLED !== 'true' && process.env.PCGI_TICKETING_TUNNEL_ENABLED !== 'false') {
+            throw new Error('Missing PCGI_TICKETING_TUNNEL_ENABLED. Please indicate whether SSH tunneling is required by setting PCGI_TICKETING_TUNNEL_ENABLED to "true" or "false".');
         }
-        if (!process.env.RAW_MONGO_DB_HOST || !process.env.RAW_MONGO_DB_PORT) {
-            throw new Error('Missing RAW_MONGO_DB_HOST or RAW_MONGO_DB_PORT');
+        if (!process.env.PCGI_TICKETING_HOST_1 || !process.env.PCGI_TICKETING_PORT_1) {
+            throw new Error('Missing PCGI_TICKETING_HOST_1 or PCGI_TICKETING_PORT_1');
         }
-        if (process.env.RAW_MONGO_DB_TUNNEL_ENABLED === 'false') {
-            return `http://${process.env.RAW_MONGO_DB_USER}:${process.env.RAW_MONGO_DB_PASSWORD}@${process.env.RAW_MONGO_DB_HOST}:${process.env.RAW_MONGO_DB_PORT}`;
+        if (!process.env.PCGI_TICKETING_HOST_2 || !process.env.PCGI_TICKETING_PORT_2) {
+            throw new Error('Missing PCGI_TICKETING_HOST_2 or PCGI_TICKETING_PORT_2');
+        }
+        if (!process.env.PCGI_TICKETING_HOST_3 || !process.env.PCGI_TICKETING_PORT_3) {
+            throw new Error('Missing PCGI_TICKETING_HOST_3 or PCGI_TICKETING_PORT_3');
+        }
+        if (process.env.PCGI_TICKETING_TUNNEL_ENABLED === 'false') {
+            return `mongodb://${process.env.PCGI_TICKETING_USER}:${process.env.PCGI_TICKETING_PASSWORD}@${process.env.PCGI_TICKETING_HOST_1}:${process.env.PCGI_TICKETING_PORT_1},${process.env.PCGI_TICKETING_HOST_2}:${process.env.PCGI_TICKETING_PORT_2},${process.env.PCGI_TICKETING_HOST_3}:${process.env.PCGI_TICKETING_PORT_3}/`;
         }
         // SSH required
-        if (!process.env.RAW_MONGO_DB_TUNNEL_LOCAL_PORT) {
-            throw new Error('Missing RAW_MONGO_DB_TUNNEL_LOCAL_PORT');
+        if (!process.env.PCGI_TICKETING_TUNNEL_LOCAL_PORT) {
+            throw new Error('Missing PCGI_TICKETING_TUNNEL_LOCAL_PORT');
         }
-        if (!process.env.RAW_MONGO_DB_TUNNEL_SSH_HOST || !process.env.RAW_MONGO_DB_TUNNEL_SSH_USERNAME) {
+        if (!process.env.PCGI_TICKETING_TUNNEL_SSH_HOST || !process.env.PCGI_TICKETING_TUNNEL_SSH_USERNAME) {
             throw new Error('Missing SSH config');
         }
         const sshConfig = {
             forwardOptions: {
-                dstAddr: process.env.RAW_MONGO_DB_HOST,
-                dstPort: Number(process.env.RAW_MONGO_DB_PORT),
+                dstAddr: process.env.PCGI_TICKETING_HOST_1,
+                dstPort: Number(process.env.PCGI_TICKETING_PORT_1),
                 srcAddr: 'localhost',
-                srcPort: Number(process.env.RAW_MONGO_DB_TUNNEL_LOCAL_PORT),
+                srcPort: Number(process.env.PCGI_TICKETING_TUNNEL_LOCAL_PORT),
             },
             serverOptions: {
-                port: Number(process.env.RAW_MONGO_DB_TUNNEL_LOCAL_PORT),
+                port: Number(process.env.PCGI_TICKETING_TUNNEL_LOCAL_PORT),
             },
             sshOptions: {
                 agent: process.env.SSH_AUTH_SOCK,
-                host: process.env.RAW_MONGO_DB_TUNNEL_SSH_HOST,
+                host: process.env.PCGI_TICKETING_TUNNEL_SSH_HOST,
                 keepaliveCountMax: 3,
                 keepaliveInterval: 10_000,
                 port: 22,
-                username: process.env.RAW_MONGO_DB_TUNNEL_SSH_USERNAME,
+                username: process.env.PCGI_TICKETING_TUNNEL_SSH_USERNAME,
             },
             tunnelOptions: {
                 autoClose: false,
@@ -105,12 +112,12 @@ export class RAWDBService {
             maxRetries: 3,
         };
         this.tunnel = new SshTunnelService(sshConfig, sshOptions);
-        Logger.info('[RAWDBService] Setting up SSH Tunnel...');
+        Logger.info('[PCGITicketingClient] Setting up SSH Tunnel...');
         const connection = await this.tunnel.connect();
         const addr = connection.address();
         if (!addr || typeof addr !== 'object') {
-            throw new Error('[RAWDBService] Failed to retrieve SSH tunnel address.');
+            throw new Error('[PCGITicketingClient] Failed to retrieve SSH tunnel address.');
         }
-        return `http://${process.env.RAW_MONGO_DB_USER}:${process.env.RAW_MONGO_DB_PASSWORD}@localhost:${addr.port}`;
+        return `mongodb://${process.env.PCGI_TICKETING_USER}:${process.env.PCGI_TICKETING_PASSWORD}@localhost:${addr.port}/`;
     }
 }

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

@@ -0,0 +1,30 @@
+import { MongoClient } from 'mongodb';
+export declare class PCGIValidationsClient {
+    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;
+}