@tmlmobilidade/go-interfaces-pcgi-file-manager 20260720.1149.38 → 20260720.1248.5

package/dist/databases/file-management.d.ts

@@ -0,0 +1,9 @@
+import { MongoInterfaceTemplate } from '../interface.template.js';
+import { type MongoClient } from '@tmlmobilidade/go-clients-mongo';
+import { type PcgiTransactionEntity } from '@tmlmobilidade/go-types-apex';
+export declare class FileManagementDatabase {
+    readonly transactionEntity: MongoInterfaceTemplate<PcgiTransactionEntity>;
+    private readonly database;
+    private readonly databaseName;
+    constructor(instance: MongoClient);
+}

package/dist/databases/{location-management.js → file-management.js}

@@ -1,19 +1,15 @@
 /* * */
 import { MongoInterfaceTemplate } from '../interface.template.js';
-import z from 'zod';
 /* * */
-export class LocationManagementDatabase {
-    //
-    //
-    // Collections
-    locationEntity;
+export class FileManagementDatabase {
     //
+    transactionEntity;
     database;
-    databaseName = 'locationManagement';
+    databaseName = 'FileManagement';
     constructor(instance) {
         // Create the database instance
         this.database = instance.db(this.databaseName);
         // Create collection interfaces
-        this.locationEntity = new MongoInterfaceTemplate('locationEntities', this.database, z.any());
+        this.transactionEntity = new MongoInterfaceTemplate('transactionEntity', this.database);
     }
 }

package/dist/index.d.ts

@@ -1,13 +1,14 @@
-import { LocationManagementDatabase } from './databases/location-management.js';
+import { FileManagementDatabase } from './databases/file-management.js';
 declare class PCGIFileManagerClass {
     private static _instance;
-    readonly locationManagement: LocationManagementDatabase;
+    readonly fileManagement: FileManagementDatabase;
+    private constructor();
     /**
      * Establishes a connection to the Mongo database and initializes the collection.
-     * @throws Error if required RAW_DB_* environment variables are missing or if the connection fails.
+     * @param options Optional Mongo client connection options.
+     * @throws Error if the environment variable for the database URI is missing or if the connection fails.
      */
     static getInstance(): Promise<PCGIFileManagerClass>;
-    private constructor();
 }
 export declare const pcgiFileManager: PCGIFileManagerClass;
 export {};

package/dist/index.js

@@ -1,19 +1,19 @@
 /* * */
 import { MongoDatabaseClient } from '@tmlmobilidade/go-clients-mongo';
 import { asyncSingletonProxy } from '@tmlmobilidade/utils';
-import { LocationManagementDatabase } from './databases/location-management.js';
+import { FileManagementDatabase } from './databases/file-management.js';
 /* * */
 class PCGIFileManagerClass {
-    //
-    //
     //
     static _instance;
-    //
-    // Databases
-    locationManagement;
+    fileManagement;
+    constructor(mongoClient) {
+        this.fileManagement = new FileManagementDatabase(mongoClient);
+    }
     /**
      * Establishes a connection to the Mongo database and initializes the collection.
-     * @throws Error if required RAW_DB_* environment variables are missing or if the connection fails.
+     * @param options Optional Mongo client connection options.
+     * @throws Error if the environment variable for the database URI is missing or if the connection fails.
      */
     static async getInstance() {
         if (!PCGIFileManagerClass._instance) {
@@ -22,10 +22,6 @@ class PCGIFileManagerClass {
         }
         return PCGIFileManagerClass._instance;
     }
-    //
-    // Constructor
-    constructor(mongoClient) {
-        this.locationManagement = new LocationManagementDatabase(mongoClient);
-    }
 }
+/* * */
 export const pcgiFileManager = asyncSingletonProxy(PCGIFileManagerClass);

package/dist/interface.template.d.ts

@@ -1,19 +1,11 @@
-import { AnyBulkWriteOperation, BulkWriteOptions, BulkWriteResult, Collection, Db, Document, Filter, FindOptions, InsertOneOptions, SimplifiedMongoIndex, WithId } from '@tmlmobilidade/go-clients-mongo';
-import { z } from 'zod';
-export declare class MongoInterfaceTemplate<T extends Document, TCreate> {
-    private readonly collectionName;
-    private readonly createSchema;
-    private readonly database;
-    private readonly indexDescription;
+import { type Collection, type Db, type Document, type Filter, type FindOptions, type WithId } from '@tmlmobilidade/go-clients-mongo';
+export declare class MongoInterfaceTemplate<T extends Document> {
     private readonly collection;
-    private initPromise;
     /**
-     * @param collectionName - The name of the collection to create the interface for.
-     * @param database - The database to create the interface for.
-     * @param createSchema - The schema to use for creating documents.
-     * @param indexDescription - The index description to use for the collection.
+     * @param collectionName The name of the collection to create the interface for.
+     * @param database The database to create the interface for.
      */
-    constructor(collectionName: string, database: Db, createSchema: z.ZodSchema, indexDescription?: false | SimplifiedMongoIndex<T>[]);
+    constructor(collectionName: string, database: Db);
     /**
      * Counts documents matching the filter criteria.
      * @param filter The filter criteria to match documents.
@@ -49,51 +41,4 @@ export declare class MongoInterfaceTemplate<T extends Document, TCreate> {
      * @warning Use with caution: direct access to the collection allows for executing arbitrary queries.
      */
     getCollection(): Promise<Collection<T>>;
-    /**
-     * This method allows for performing multiple write operations
-     * in a single request, which can improve performance.
-     * The operations can include inserts, updates, deletes, and replacements.
-     * @param operations An array of bulk write operations to execute on the collection.
-     * @param options The options for the bulk write operation.
-     * @returns A promise that resolves to the result of the bulk write operation.
-     * @warning This method does not perform schema validation on the operations.
-     * It is the responsibility of the caller to ensure that the operations are valid and conform to the expected schemas.
-     */
-    bulkWrite(operations: AnyBulkWriteOperation<T>[], options?: BulkWriteOptions): Promise<BulkWriteResult>;
-    /**
-     * Inserts multiple documents into the collection after validating them against the create schema.
-     * @param data An array of documents to insert, conforming to the TCreate type.
-     * @param options Optional insert options to configure the behavior of the insert operation.
-     * @returns A promise that resolves to the result of the insertMany operation.
-     */
-    insertMany(data: TCreate[], options?: BulkWriteOptions): Promise<import("mongodb").InsertManyResult<T>>;
-    insertOne(data: TCreate, options?: InsertOneOptions): Promise<import("mongodb").InsertOneResult<T>>;
-    /**
-     * Initializes the MongoDB client and ensures that the specified database and collection exist.
-     * This method should be called before performing any operations on the database or collection.
-     * It handles the asynchronous setup process and logs any errors that occur during initialization.
-     * @throws Will throw an error if the client initialization or database/collection setup fails.
-     * @returns A promise that resolves when the initialization process is complete.
-     */
-    protected init(): Promise<void>;
-    private ensureInitialized;
-    /**
-     * Optional override for custom setup logic:
-     * 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.
-     * It constructs the necessary index creation queries based on the provided index descriptions and executes them using the client.
-     * @throws Will throw an error if any of the inputs are unsafe or if the index creation query fails.
-     * @returns A promise that resolves when the indexes are ensured to exist.
-     */
-    private syncIndexes;
 }

package/dist/interface.template.js

@@ -1,32 +1,14 @@
 /* * */
-import { isSameIndex, prepareMongoIndexOptions } from '@tmlmobilidade/go-clients-mongo';
-import { Logger } from '@tmlmobilidade/logger';
 /* * */
 export class MongoInterfaceTemplate {
-    //
-    collectionName;
-    createSchema;
-    database;
-    indexDescription;
     //
     collection;
-    initPromise = null;
     /**
-     * @param collectionName - The name of the collection to create the interface for.
-     * @param database - The database to create the interface for.
-     * @param createSchema - The schema to use for creating documents.
-     * @param indexDescription - The index description to use for the collection.
+     * @param collectionName The name of the collection to create the interface for.
+     * @param database The database to create the interface for.
      */
-    constructor(collectionName, database, createSchema, indexDescription = []) {
-        this.collectionName = collectionName;
+    constructor(collectionName, database) {
         this.collection = database.collection(collectionName);
-        this.database = database;
-        this.createSchema = createSchema;
-        this.indexDescription = indexDescription;
-        this.initPromise = this.init().catch((error) => {
-            Logger.error({ error, message: `MONGODB [${this.collectionName}]: Error @ constructor(): ${error.message}` });
-            throw error;
-        });
     }
     /**
      * Counts documents matching the filter criteria.
@@ -34,7 +16,6 @@ export class MongoInterfaceTemplate {
      * @returns A promise that resolves to the count of matching documents.
      */
     async count(filter) {
-        await this.ensureInitialized();
         return await this.collection.countDocuments(filter);
     }
     /**
@@ -44,7 +25,6 @@ export class MongoInterfaceTemplate {
      * @returns A promise that resolves to an array of distinct values for the given key.
      */
     async distinct(key, filter) {
-        await this.ensureInitialized();
         return this.collection.distinct(key, filter);
     }
     /**
@@ -55,7 +35,6 @@ export class MongoInterfaceTemplate {
      * @returns A promise that resolves to an array of matching documents.
      */
     async findMany(filter, options) {
-        await this.ensureInitialized();
         return await this.collection.find(filter, options).toArray();
     }
     /**
@@ -65,7 +44,6 @@ export class MongoInterfaceTemplate {
      * @returns A promise that resolves to the matching document or null if not found.
      */
     async findOne(filter, options) {
-        await this.ensureInitialized();
         return await this.collection.findOne(filter, options);
     }
     /**
@@ -75,136 +53,6 @@ export class MongoInterfaceTemplate {
      * @warning Use with caution: direct access to the collection allows for executing arbitrary queries.
      */
     async getCollection() {
-        await this.ensureInitialized();
         return this.collection;
     }
-    /**
-     * This method allows for performing multiple write operations
-     * in a single request, which can improve performance.
-     * The operations can include inserts, updates, deletes, and replacements.
-     * @param operations An array of bulk write operations to execute on the collection.
-     * @param options The options for the bulk write operation.
-     * @returns A promise that resolves to the result of the bulk write operation.
-     * @warning This method does not perform schema validation on the operations.
-     * It is the responsibility of the caller to ensure that the operations are valid and conform to the expected schemas.
-     */
-    async bulkWrite(operations, options) {
-        await this.ensureInitialized();
-        return await this.collection.bulkWrite(operations, options);
-    }
-    /**
-     * Inserts multiple documents into the collection after validating them against the create schema.
-     * @param data An array of documents to insert, conforming to the TCreate type.
-     * @param options Optional insert options to configure the behavior of the insert operation.
-     * @returns A promise that resolves to the result of the insertMany operation.
-     */
-    async insertMany(data, options) {
-        await this.ensureInitialized();
-        // If no create schema is defined, throw an error.
-        if (!this.createSchema)
-            throw new Error(`No schema defined for insert operation for ${this.collectionName} collection.`);
-        // Validate each document against the create schema
-        const parsedDocuments = data.map((doc) => {
-            const parseResult = this.createSchema.safeParse(doc);
-            if (!parseResult.success)
-                throw new Error(`Document validation failed: ${parseResult.error.message}`);
-            return parseResult.data;
-        });
-        // Attempt to insert the documents into the collection
-        return await this.collection.insertMany(parsedDocuments, options);
-    }
-    async insertOne(data, options) {
-        await this.ensureInitialized();
-        // If no create schema is defined, throw an error.
-        if (!this.createSchema)
-            throw new Error(`No schema defined for insert operation for ${this.collectionName} collection.`);
-        // Validate the document against the create schema
-        const parseResult = this.createSchema.safeParse(data);
-        if (!parseResult.success)
-            throw new Error(`Document validation failed: ${parseResult.error.message}`);
-        // Attempt to insert the document into the collection
-        return await this.collection.insertOne(parseResult.data, options);
-    }
-    /**
-     * Initializes the MongoDB client and ensures that the specified database and collection exist.
-     * This method should be called before performing any operations on the database or collection.
-     * It handles the asynchronous setup process and logs any errors that occur during initialization.
-     * @throws Will throw an error if the client initialization or database/collection setup fails.
-     * @returns A promise that resolves when the initialization process is complete.
-     */
-    async init() {
-        // 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();
-    }
-    async ensureInitialized() {
-        if (!this.initPromise)
-            this.initPromise = this.init();
-        await this.initPromise;
-    }
-    /**
-     * Optional override for custom setup logic:
-     * indexes, materialized views, constraints, etc.
-     */
-    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({ message: `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.
-     * It constructs the necessary index creation queries based on the provided index descriptions and executes them using the client.
-     * @throws Will throw an error if any of the inputs are unsafe or if the index creation query fails.
-     * @returns A promise that resolves when the indexes are ensured to exist.
-     */
-    async syncIndexes() {
-        try {
-            if (this.indexDescription === false) {
-                Logger.info({ message: `MONGODB [${this.collectionName}]: Skipping index synchronization.` });
-                return;
-            }
-            // Start index synchronization process
-            Logger.info({ message: `MONGODB [${this.collectionName}]: Synchronizing indexes...` });
-            // Normalize already applied and new indexes
-            // and filter the default _id index.
-            const existingIndexes = await this.collection.indexes();
-            const filteredExisting = existingIndexes.filter(idx => JSON.stringify(idx.key) !== JSON.stringify({ _id: 1 }));
-            // Setup desired indexes based on indexDescription
-            const indexesToCreate = [];
-            // Find indexes to create
-            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));
-                // If not, mark them for creation.
-                if (!found)
-                    indexesToCreate.push(desiredIdx);
-            }
-            // Create indexes
-            for (const idx of indexesToCreate) {
-                Logger.info({ message: `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.success(`MONGODB [${this.collectionName}]: Indexes synchronized.`);
-        }
-        catch (error) {
-            Logger.error({ error, message: `MONGODB [${this.collectionName}]: Error @ syncIndexes(): ${error.message}` });
-            throw error;
-        }
-    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@tmlmobilidade/go-interfaces-pcgi-file-manager",
-	"version": "20260720.1149.38",
+	"version": "20260720.1248.5",
 	"author": {
 		"email": "iso@tmlmobilidade.pt",
 		"name": "TML-ISO"
@@ -37,6 +37,7 @@
 	},
 	"dependencies": {
 		"@tmlmobilidade/go-clients-mongo": "*",
+		"@tmlmobilidade/go-types-apex": "*",
 		"@tmlmobilidade/logger": "*",
 		"@tmlmobilidade/utils": "*",
 		"luxon": "3.7.2",

package/dist/databases/location-management.d.ts

@@ -1,8 +0,0 @@
-import type { MongoClient } from '@tmlmobilidade/go-clients-mongo';
-import { MongoInterfaceTemplate } from '../interface.template.js';
-export declare class LocationManagementDatabase {
-    readonly locationEntity: MongoInterfaceTemplate<any, any>;
-    private readonly database;
-    private readonly databaseName;
-    constructor(instance: MongoClient);
-}