@tmlmobilidade/databases 20260324.1249.38 → 20260324.1728.13

package/dist/clients/go-mongo.js

@@ -42,7 +42,14 @@ export class GOMongoClient {
     async connect() {
         Logger.info('[GOMongoClient] Connecting to database...');
         const connectionString = await this.getConnectionString();
-        this.client = new MongoClient(connectionString);
+        this.client = new MongoClient(connectionString, {
+            connectTimeoutMS: 10_000,
+            directConnection: process.env.GO_MONGO_TUNNEL_ENABLED === 'true',
+            maxPoolSize: 20,
+            minPoolSize: 2,
+            readPreference: 'secondaryPreferred',
+            serverSelectionTimeoutMS: 10_000,
+        });
         this.client.on('close', () => {
             console.warn('[GOMongoClient] Database connection closed unexpectedly.');
         });

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

@@ -42,7 +42,14 @@ export class PCGIFileManagerClient {
     async connect() {
         Logger.info('[PCGIFileManagerClient] Connecting to database...');
         const connectionString = await this.getConnectionString();
-        this.client = new MongoClient(connectionString);
+        this.client = new MongoClient(connectionString, {
+            connectTimeoutMS: 10_000,
+            directConnection: process.env.PCGI_FILE_MANAGER_TUNNEL_ENABLED === 'true',
+            maxPoolSize: 20,
+            minPoolSize: 2,
+            readPreference: 'secondaryPreferred',
+            serverSelectionTimeoutMS: 10_000,
+        });
         this.client.on('close', () => {
             console.warn('[PCGIFileManagerClient] Database connection closed unexpectedly.');
         });

package/dist/clients/pcgi-raw.js

@@ -42,7 +42,14 @@ export class PCGIRawClient {
     async connect() {
         Logger.info('[PCGIRawClient] Connecting to database...');
         const connectionString = await this.getConnectionString();
-        this.client = new MongoClient(connectionString);
+        this.client = new MongoClient(connectionString, {
+            connectTimeoutMS: 10_000,
+            directConnection: process.env.PCGI_RAW_TUNNEL_ENABLED === 'true',
+            maxPoolSize: 20,
+            minPoolSize: 2,
+            readPreference: 'secondaryPreferred',
+            serverSelectionTimeoutMS: 10_000,
+        });
         this.client.on('close', () => {
             console.warn('[PCGIRawClient] Database connection closed unexpectedly.');
         });

package/dist/clients/pcgi-ticketing.js

@@ -42,7 +42,14 @@ export class PCGITicketingClient {
     async connect() {
         Logger.info('[PCGITicketingClient] Connecting to database...');
         const connectionString = await this.getConnectionString();
-        this.client = new MongoClient(connectionString);
+        this.client = new MongoClient(connectionString, {
+            connectTimeoutMS: 10_000,
+            directConnection: process.env.PCGI_TICKETING_TUNNEL_ENABLED === 'true',
+            maxPoolSize: 20,
+            minPoolSize: 2,
+            readPreference: 'secondaryPreferred',
+            serverSelectionTimeoutMS: 10_000,
+        });
         this.client.on('close', () => {
             console.warn('[PCGITicketingClient] Database connection closed unexpectedly.');
         });

package/dist/clients/pcgi-validations.js

@@ -42,7 +42,14 @@ export class PCGIValidationsClient {
     async connect() {
         Logger.info('[PCGIValidationsClient] Connecting to database...');
         const connectionString = await this.getConnectionString();
-        this.client = new MongoClient(connectionString);
+        this.client = new MongoClient(connectionString, {
+            connectTimeoutMS: 10_000,
+            directConnection: process.env.PCGI_VALIDATIONS_TUNNEL_ENABLED === 'true',
+            maxPoolSize: 20,
+            minPoolSize: 2,
+            readPreference: 'secondaryPreferred',
+            serverSelectionTimeoutMS: 10_000,
+        });
         this.client.on('close', () => {
             console.warn('[PCGIValidationsClient] Database connection closed unexpectedly.');
         });

package/dist/interfaces/vehicle-events/raw-vehicle-events.d.ts

@@ -4,7 +4,7 @@ import { type RawVehicleEvent } from '@tmlmobilidade/types';
 declare class RawVehicleEventsNewClass extends MongoInterfaceTemplate<RawVehicleEvent, RawVehicleEvent, Partial<RawVehicleEvent>> {
     private static _instance;
     protected readonly collectionName = "raw_vehicle_events";
-    protected readonly databaseName = "raw_vehicle_events";
+    protected readonly databaseName = "raw";
     protected readonly indexDescription: SimplifiedMongoIndex<RawVehicleEvent>[];
     protected createSchema: import("zod").ZodDiscriminatedUnion<"version", [import("zod").ZodObject<{
         _id: import("zod").ZodString;

package/dist/interfaces/vehicle-events/raw-vehicle-events.js

@@ -8,7 +8,7 @@ class RawVehicleEventsNewClass extends MongoInterfaceTemplate {
     //
     static _instance = null;
     collectionName = 'raw_vehicle_events';
-    databaseName = 'raw_vehicle_events';
+    databaseName = 'raw';
     indexDescription = [
         { key: { agency_id: 1, created_at: 1 } },
     ];

package/dist/templates/mongodb.d.ts

@@ -119,6 +119,12 @@ export declare abstract class MongoInterfaceTemplate<T extends Document, TCreate
      * indexes, materialized views, constraints, etc.
      */
     protected postInit(): Promise<void>;
+    /**
+     * Ensures that the specified collection exists in the MongoDB database,
+     * creating it if it does not already exist.
+     * @returns A promise that resolves when the collection is ensured to exist.
+     */
+    private createCollectionIfNotExists;
     /**
      * Ensures that the specified indexes exist in MongoDB, creating them if they do not already exist.
      * This method performs input validation to prevent unsafe operations and logs the outcome of the operation.

package/dist/templates/mongodb.js

@@ -1,5 +1,5 @@
 /* * */
-import { isSameIndex, normalizeMongoIndex } from '../utils/mongo/index.js';
+import { isSameIndex, prepareMongoIndexOptions } from '../utils/mongo/index.js';
 import { Logger } from '@tmlmobilidade/logger';
 /* * */
 export class MongoInterfaceTemplate {
@@ -177,7 +177,9 @@ export class MongoInterfaceTemplate {
         this.client = await this.connectToClient();
         this.database = this.client.db(this.databaseName);
         this.collection = this.database.collection(this.collectionName);
-        // Ensure the collection indexes are in sync with the provided index description
+        // Ensure the collection exists and its indexes are in sync
+        // with the provided index description.
+        await this.createCollectionIfNotExists();
         await this.syncIndexes();
         // Call postInit for any additional setup logic defined in subclasses
         await this.postInit();
@@ -189,6 +191,18 @@ export class MongoInterfaceTemplate {
     async postInit() {
         // no-op by default
     }
+    /**
+     * Ensures that the specified collection exists in the MongoDB database,
+     * creating it if it does not already exist.
+     * @returns A promise that resolves when the collection is ensured to exist.
+     */
+    async createCollectionIfNotExists() {
+        const collections = await this.database.listCollections({ name: this.collectionName }).toArray();
+        if (collections.length)
+            return;
+        await this.database.createCollection(this.collectionName);
+        Logger.info(`MONGODB [${this.collectionName}]: Collection created.`);
+    }
     /**
      * Ensures that the specified indexes exist in MongoDB, creating them if they do not already exist.
      * This method performs input validation to prevent unsafe operations and logs the outcome of the operation.
@@ -198,12 +212,11 @@ export class MongoInterfaceTemplate {
      */
     async syncIndexes() {
         try {
+            Logger.info(`MONGODB [${this.collectionName}]: Synchronizing indexes...`);
             // Normalize already applied and new indexes
             // and filter the default _id index.
             const existingIndexes = await this.collection.indexes();
-            const normalizedExisting = existingIndexes.map((normalizeMongoIndex));
-            const filteredExisting = normalizedExisting.filter(idx => JSON.stringify(idx.key) !== JSON.stringify({ _id: 1 }));
-            const normalizedDesired = this.indexDescription.map(idx => normalizeMongoIndex(idx));
+            const filteredExisting = existingIndexes.filter(idx => JSON.stringify(idx.key) !== JSON.stringify({ _id: 1 }));
             // Setup desired indexes based on indexDescription
             const indexesToDrop = [];
             const indexesToCreate = [];
@@ -211,13 +224,13 @@ export class MongoInterfaceTemplate {
             for (const existingIdx of filteredExisting) {
                 // For the list of existing indexes,
                 // check if they are present in the desired index description.
-                const found = normalizedDesired.some(desiredIdx => isSameIndex(existingIdx, desiredIdx));
+                const found = this.indexDescription.some(desiredIdx => isSameIndex(existingIdx, desiredIdx));
                 // If not, mark them for dropping.
                 if (!found)
-                    indexesToDrop.push(existingIdx);
+                    indexesToDrop.push(existingIdx.name);
             }
             // Find indexes to create
-            for (const desiredIdx of normalizedDesired) {
+            for (const desiredIdx of this.indexDescription) {
                 // For the list of desired indexes,
                 // check if they are present in the existing indexes.
                 const found = filteredExisting.some(existingIdx => isSameIndex(existingIdx, desiredIdx));
@@ -226,20 +239,20 @@ export class MongoInterfaceTemplate {
                     indexesToCreate.push(desiredIdx);
             }
             // Drop indexes
-            for (const idx of indexesToDrop) {
-                if (!idx.name)
+            for (const idxName of indexesToDrop) {
+                if (!idxName)
                     continue;
-                await this.collection.dropIndex(idx.name);
+                Logger.info(`MONGODB [${this.collectionName}]: Dropping index ${idxName}.`);
+                await this.collection.dropIndex(idxName);
+                Logger.success(`MONGODB [${this.collectionName}]: Dropped index ${idxName}.`);
             }
             // Create indexes
             for (const idx of indexesToCreate) {
-                await this.collection.createIndex(idx.key, {
-                    expireAfterSeconds: idx.expireAfterSeconds ?? undefined,
-                    sparse: idx.sparse,
-                    unique: idx.unique,
-                });
+                Logger.info(`MONGODB [${this.collectionName}]: Creating index on keys ${JSON.stringify(idx.key)} with options ${JSON.stringify(prepareMongoIndexOptions(idx))}.`);
+                await this.collection.createIndex(idx.key, prepareMongoIndexOptions(idx));
+                Logger.success(`MONGODB [${this.collectionName}]: Created index on keys ${JSON.stringify(idx.key)}.`);
             }
-            Logger.info(`MONGODB [${this.collectionName}]: Indexes synchronized.`);
+            Logger.success(`MONGODB [${this.collectionName}]: Indexes synchronized.`);
         }
         catch (error) {
             Logger.error(`MONGODB [${this.collectionName}]: Error @ syncIndexes(): ${error.message}`);

package/dist/types/mongo/index-description.d.ts

@@ -9,10 +9,3 @@ export interface SimplifiedMongoIndex<T> {
     sparse?: boolean;
     unique?: boolean;
 }
-/**
- * A MongoDB index description type that is normalized
- * to ensure all expected properties are present and have consistent types.
- */
-export type ComparableMongoIndex<T> = Required<SimplifiedMongoIndex<T>> & {
-    name?: string;
-};

package/dist/utils/mongo/manage-indexes.d.ts

@@ -1,12 +1,13 @@
-import { type ComparableMongoIndex, type SimplifiedMongoIndex } from '../../types/mongo/index-description.js';
-import { type IndexDescriptionInfo } from 'mongodb';
+import { type SimplifiedMongoIndex } from '../../types/mongo/index-description.js';
+import { type CreateIndexesOptions, type IndexDescriptionInfo } from 'mongodb';
 /**
- * Normalizes a MongoDB index description by ensuring that
- * all expected properties are present and have consistent types.
- * @param indexDescription The original index description from MongoDB.
- * @returns A normalized index description with default values for missing properties.
+ * Prepares MongoDB index options by extracting relevant properties
+ * from a simplified index description. This function ensures that
+ * only valid options are included when creating indexes in MongoDB.
+ * @param idx A simplified index description defined by the user.
+ * @returns An object containing valid MongoDB index options based on the provided description.
  */
-export declare function normalizeMongoIndex<T>(indexDescription: IndexDescriptionInfo | SimplifiedMongoIndex<T>): ComparableMongoIndex<T>;
+export declare function prepareMongoIndexOptions<T>(idx: SimplifiedMongoIndex<T>): CreateIndexesOptions;
 /**
  * Compares two normalized MongoDB index descriptions for equivalence.
  * Two indexes are considered the same if they have identical key definitions
@@ -15,4 +16,4 @@ export declare function normalizeMongoIndex<T>(indexDescription: IndexDescriptio
  * @param b The second normalized index description to compare.
  * @returns True if the indexes are considered the same, false otherwise.
  */
-export declare function isSameIndex<T>(a: ComparableMongoIndex<T>, b: ComparableMongoIndex<T>): boolean;
+export declare function isSameIndex<T>(a: IndexDescriptionInfo | SimplifiedMongoIndex<T>, b: IndexDescriptionInfo | SimplifiedMongoIndex<T>): boolean;

package/dist/utils/mongo/manage-indexes.js

@@ -1,13 +1,30 @@
 /* * */
+/**
+ * Prepares MongoDB index options by extracting relevant properties
+ * from a simplified index description. This function ensures that
+ * only valid options are included when creating indexes in MongoDB.
+ * @param idx A simplified index description defined by the user.
+ * @returns An object containing valid MongoDB index options based on the provided description.
+ */
+export function prepareMongoIndexOptions(idx) {
+    const result = {};
+    if (idx.expireAfterSeconds !== undefined)
+        result.expireAfterSeconds = idx.expireAfterSeconds;
+    if (idx.sparse !== undefined)
+        result.sparse = idx.sparse;
+    if (idx.unique !== undefined)
+        result.unique = idx.unique;
+    return result;
+}
 /**
  * Normalizes a MongoDB index description by ensuring that
  * all expected properties are present and have consistent types.
- * @param indexDescription The original index description from MongoDB.
+ * @param indexDescription The existing indexes from MongoDB or a simplified structure defined by the user.
  * @returns A normalized index description with default values for missing properties.
  */
-export function normalizeMongoIndex(indexDescription) {
+function normalizeMongoIndex(indexDescription) {
     return {
-        expireAfterSeconds: indexDescription.expireAfterSeconds ?? null,
+        expireAfterSeconds: indexDescription.expireAfterSeconds ?? undefined,
         key: indexDescription.key,
         sparse: !!indexDescription.sparse,
         unique: !!indexDescription.unique,
@@ -22,14 +39,18 @@ export function normalizeMongoIndex(indexDescription) {
  * @returns True if the indexes are considered the same, false otherwise.
  */
 export function isSameIndex(a, b) {
+    // Normalize both index descriptions
+    // to ensure consistent comparison.
+    const normalizedA = normalizeMongoIndex(a);
+    const normalizedB = normalizeMongoIndex(b);
     // Sort keys to ensure consistent comparison regardless of order.
-    const aKeySorted = Object.fromEntries(Object.entries(a.key).sort());
-    const bKeySorted = Object.fromEntries(Object.entries(b.key).sort());
+    const aKeySorted = Object.fromEntries(Object.entries(normalizedA.key).sort());
+    const bKeySorted = Object.fromEntries(Object.entries(normalizedB.key).sort());
     // Check if keys are the same and if unique/sparse settings match.
     const matchingKeys = JSON.stringify(aKeySorted) === JSON.stringify(bKeySorted);
-    const matchingUnique = !!a.unique === !!b.unique;
-    const matchingSparse = !!a.sparse === !!b.sparse;
-    const matchingExpire = a.expireAfterSeconds === b.expireAfterSeconds;
+    const matchingUnique = !!normalizedA.unique === !!normalizedB.unique;
+    const matchingSparse = !!normalizedA.sparse === !!normalizedB.sparse;
+    const matchingExpire = normalizedA.expireAfterSeconds === normalizedB.expireAfterSeconds;
     // Consider indexes the same if all properties match.
     return matchingKeys && matchingUnique && matchingSparse && matchingExpire;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@tmlmobilidade/databases",
-	"version": "20260324.1249.38",
+	"version": "20260324.1728.13",
 	"author": {
 		"email": "iso@tmlmobilidade.pt",
 		"name": "TML-ISO"