@modular-rest/server 1.18.1 → 1.20.0

package/dist/services/data_provider/model_registry.js

@@ -0,0 +1,214 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.modelRegistry = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+/**
+ * ModelRegistry - Singleton class for managing mongoose models and connections
+ * Pre-creates all models before database connections are established
+ */
+class ModelRegistry {
+    constructor() {
+        this.connections = {};
+        this.models = {};
+        this.collectionDefinitions = [];
+        this.mongoOption = null;
+        // Private constructor for singleton pattern
+    }
+    /**
+     * Get the singleton instance of ModelRegistry
+     * @returns {ModelRegistry} The singleton instance
+     */
+    static getInstance() {
+        if (!ModelRegistry.instance) {
+            ModelRegistry.instance = new ModelRegistry();
+        }
+        return ModelRegistry.instance;
+    }
+    /**
+     * Register a collection definition and create its model
+     * @param {CollectionDefinition} definition - The collection definition
+     * @param {MongoOption} mongoOption - MongoDB connection options
+     * @returns {Model<any>} The created mongoose model
+     */
+    registerCollection(definition, mongoOption) {
+        // Store mongoOption if not already stored
+        if (!this.mongoOption) {
+            this.mongoOption = mongoOption;
+        }
+        const { database, collection, schema } = definition;
+        // Check if this definition is already registered
+        const isAlreadyRegistered = this.collectionDefinitions.some(def => def.database === database && def.collection === collection);
+        // Store collection definition if not already registered
+        if (!isAlreadyRegistered) {
+            this.collectionDefinitions.push(definition);
+        }
+        // Initialize models object for this database if needed
+        if (!this.models[database]) {
+            this.models[database] = {};
+        }
+        // Check if model already exists
+        if (this.models[database][collection]) {
+            return this.models[database][collection];
+        }
+        // Get or create connection for this database
+        let connection = this.connections[database];
+        if (!connection) {
+            const fullDbName = (mongoOption.dbPrefix || '') + database;
+            const connectionString = mongoOption.mongoBaseAddress;
+            // Create connection (but don't connect yet)
+            connection = mongoose_1.default.createConnection(connectionString, {
+                useUnifiedTopology: true,
+                useNewUrlParser: true,
+                dbName: fullDbName,
+                serverSelectionTimeoutMS: 10000, // 10 second timeout for server selection
+                socketTimeoutMS: 45000, // 45 second timeout for socket operations
+            });
+            this.connections[database] = connection;
+        }
+        // Create model on the connection
+        // Mongoose allows creating models before connection is established
+        const model = connection.model(collection, schema);
+        this.models[database][collection] = model;
+        return model;
+    }
+    /**
+     * Get a model by database and collection name
+     * @param {string} database - Database name
+     * @param {string} collection - Collection name
+     * @returns {Model<any> | null} The mongoose model or null if not found
+     */
+    getModel(database, collection) {
+        if (!this.models[database] || !this.models[database][collection]) {
+            return null;
+        }
+        return this.models[database][collection];
+    }
+    /**
+     * Get a connection for a database
+     * @param {string} database - Database name
+     * @returns {Connection | null} The mongoose connection or null if not found
+     */
+    getConnection(database) {
+        return this.connections[database] || null;
+    }
+    /**
+     * Initialize all connections and connect to databases
+     * This should be called during server startup
+     * @param {MongoOption} mongoOption - MongoDB connection options
+     * @returns {Promise<void>} A promise that resolves when all connections are established
+     */
+    async initializeConnections(mongoOption) {
+        this.mongoOption = mongoOption;
+        // Group collection definitions by database
+        const dbGroups = {};
+        this.collectionDefinitions.forEach(definition => {
+            if (!dbGroups[definition.database]) {
+                dbGroups[definition.database] = [];
+            }
+            dbGroups[definition.database].push(definition);
+        });
+        // Connect to each database
+        const connectionPromises = Object.entries(dbGroups).map(([dbName]) => {
+            return new Promise((done, reject) => {
+                const connection = this.connections[dbName];
+                if (!connection) {
+                    // If connection doesn't exist, create it
+                    const fullDbName = (mongoOption.dbPrefix || '') + dbName;
+                    const connectionString = mongoOption.mongoBaseAddress;
+                    const newConnection = mongoose_1.default.createConnection(connectionString, {
+                        useUnifiedTopology: true,
+                        useNewUrlParser: true,
+                        dbName: fullDbName,
+                        serverSelectionTimeoutMS: 10000, // 10 second timeout for server selection
+                        socketTimeoutMS: 45000, // 45 second timeout for socket operations
+                    });
+                    this.connections[dbName] = newConnection;
+                    // Create models for this database if they don't exist
+                    const definitions = dbGroups[dbName];
+                    definitions.forEach(def => {
+                        if (!this.models[dbName]) {
+                            this.models[dbName] = {};
+                        }
+                        if (!this.models[dbName][def.collection]) {
+                            this.models[dbName][def.collection] = newConnection.model(def.collection, def.schema);
+                        }
+                    });
+                    newConnection.on('connected', () => {
+                        console.info(`- ${fullDbName} database has been connected`);
+                        done();
+                    });
+                    newConnection.on('error', err => {
+                        reject(err);
+                    });
+                }
+                else {
+                    // Connection already exists, just wait for it to be ready
+                    if (connection.readyState === 1) {
+                        // Already connected
+                        done();
+                    }
+                    else {
+                        connection.once('connected', () => {
+                            done();
+                        });
+                        connection.once('error', err => {
+                            reject(err);
+                        });
+                    }
+                }
+            });
+        });
+        await Promise.all(connectionPromises);
+    }
+    /**
+     * Get all registered collection definitions
+     * @returns {CollectionDefinition[]} Array of collection definitions
+     */
+    getCollectionDefinitions() {
+        return [...this.collectionDefinitions];
+    }
+    /**
+     * Get all models for a specific database
+     * @param {string} database - Database name
+     * @returns {Record<string, Model<any>> | null} Object mapping collection names to models, or null if database not found
+     */
+    getModelsForDatabase(database) {
+        return this.models[database] || null;
+    }
+    /**
+     * Check if a model exists
+     * @param {string} database - Database name
+     * @param {string} collection - Collection name
+     * @returns {boolean} True if model exists, false otherwise
+     */
+    hasModel(database, collection) {
+        return !!(this.models[database] && this.models[database][collection]);
+    }
+    /**
+     * Clear all internal state, including connections and models.
+     * Useful for testing when different database prefixes are used.
+     */
+    async clear() {
+        // Close all connections first
+        await Promise.all(Object.values(this.connections).map(async (connection) => {
+            if (connection.readyState !== 0) {
+                try {
+                    await connection.close();
+                }
+                catch (err) {
+                    // Ignore close errors
+                }
+            }
+        }));
+        this.connections = {};
+        this.models = {};
+        this.collectionDefinitions = [];
+        this.mongoOption = null;
+    }
+}
+// Export singleton instance
+exports.modelRegistry = ModelRegistry.getInstance();
+exports.default = exports.modelRegistry;

package/dist/services/data_provider/service.js

@@ -16,6 +16,7 @@ const trigger_operator_1 = __importDefault(require("../../class/trigger_operator
 exports.triggers = trigger_operator_1.default;
 const typeCasters_1 = __importDefault(require("./typeCasters"));
 exports.TypeCasters = typeCasters_1.default;
+const model_registry_1 = __importDefault(require("./model_registry"));
 /**
  * Service name constant
  * @constant {string}
@@ -39,15 +40,25 @@ const permissionDefinitions = {};
  */
 function connectToDatabaseByCollectionDefinitionList(dbName, collectionDefinitionList = [], mongoOption) {
     return new Promise((done, reject) => {
-        // Create db connection
-        const fullDbName = (mongoOption.dbPrefix || '') + dbName;
-        const connectionString = mongoOption.mongoBaseAddress;
-        console.info(`- Connecting to database: ${fullDbName}`);
-        const connection = mongoose_1.default.createConnection(connectionString, {
-            useUnifiedTopology: true,
-            useNewUrlParser: true,
-            dbName: fullDbName,
-        });
+        // Check if connection already exists in registry
+        let connection = model_registry_1.default.getConnection(dbName);
+        // Create db connection if it doesn't exist
+        if (!connection) {
+            const fullDbName = (mongoOption.dbPrefix || '') + dbName;
+            const connectionString = mongoOption.mongoBaseAddress;
+            console.info(`- Connecting to database: ${fullDbName}`);
+            connection = mongoose_1.default.createConnection(connectionString, {
+                useUnifiedTopology: true,
+                useNewUrlParser: true,
+                dbName: fullDbName,
+                serverSelectionTimeoutMS: 10000, // 10 second timeout for server selection
+                socketTimeoutMS: 45000, // 45 second timeout for socket operations
+            });
+        }
+        else {
+            const fullDbName = (mongoOption.dbPrefix || '') + dbName;
+            console.info(`- Using existing connection for database: ${fullDbName}`);
+        }
         // Store connection
         connections[dbName] = connection;
         // add db models from schemas
@@ -58,10 +69,30 @@ function connectToDatabaseByCollectionDefinitionList(dbName, collectionDefinitio
                 collections[dbName] = {};
             if (permissionDefinitions[dbName] == undefined)
                 permissionDefinitions[dbName] = {};
-            // create model from schema
-            // and store in on global collection object
-            const model = connection.model(collection, schema);
+            // Check if model already exists in registry (pre-created)
+            let model = model_registry_1.default.getModel(dbName, collection);
+            if (!model) {
+                // Model doesn't exist in registry, create it on the connection
+                // This can happen if defineCollection was called without mongoOption
+                model = connection.model(collection, schema);
+            }
+            else {
+                // Model exists in registry, verify it's using the same connection
+                // Mongoose models are bound to their connection, so we should use the registry model
+                // But we need to ensure the connection matches
+                const registryConnection = model_registry_1.default.getConnection(dbName);
+                if (registryConnection && registryConnection !== connection) {
+                    // Connections don't match, but this shouldn't happen in normal flow
+                    // Use the model from registry as it's already created
+                    model = model_registry_1.default.getModel(dbName, collection);
+                }
+            }
+            // Store model in global collections object
             collections[dbName][collection] = model;
+            // Also update the CollectionDefinition with the model if it has a setModel method
+            if (collectionDefinition.setModel) {
+                collectionDefinition.setModel(model);
+            }
             // define Access Definition from component permissions
             // and store it on global access definition object
             permissionDefinitions[dbName][collection] = new security_1.AccessDefinition({
@@ -83,10 +114,22 @@ function connectToDatabaseByCollectionDefinitionList(dbName, collectionDefinitio
                 });
             }
         });
-        connection.on('connected', () => {
+        // If connection is already connected, resolve immediately
+        if (connection.readyState === 1) {
+            const fullDbName = (mongoOption.dbPrefix || '') + dbName;
             console.info(`- ${fullDbName} database has been connected`);
             done();
-        });
+        }
+        else {
+            connection.on('connected', () => {
+                const fullDbName = (mongoOption.dbPrefix || '') + dbName;
+                console.info(`- ${fullDbName} database has been connected`);
+                done();
+            });
+            connection.on('error', err => {
+                reject(err);
+            });
+        }
     });
 }
 /**
@@ -113,6 +156,15 @@ function connectToDatabaseByCollectionDefinitionList(dbName, collectionDefinitio
  * ```
  */
 async function addCollectionDefinitionByList({ list, mongoOption, }) {
+    // First, ensure all collections are registered in the ModelRegistry
+    // This pre-creates models before connections are established
+    list.forEach(collectionDefinition => {
+        // Check if model already exists in registry
+        if (!model_registry_1.default.hasModel(collectionDefinition.database, collectionDefinition.collection)) {
+            // Register the collection and create its model
+            model_registry_1.default.registerCollection(collectionDefinition, mongoOption);
+        }
+    });
     // Group collection definitions by database
     const dbGroups = {};
     list.forEach(collectionDefinition => {
@@ -122,6 +174,7 @@ async function addCollectionDefinitionByList({ list, mongoOption, }) {
         dbGroups[collectionDefinition.database].push(collectionDefinition);
     });
     // Connect to each database
+    // Models are already pre-created, so connections will use existing models
     const connectionPromises = Object.entries(dbGroups).map(([dbName, collectionDefinitionList]) => connectToDatabaseByCollectionDefinitionList(dbName, collectionDefinitionList, mongoOption));
     await Promise.all(connectionPromises);
 }
@@ -185,6 +238,12 @@ function checkAccess(db, collection, operationType, queryOrDoc, user) {
             return true;
         if (permission.accessType === 'user_access' && user.type === 'user')
             return true;
+        if (typeof user.hasPermission === 'function' && user.hasPermission(permission.accessType)) {
+            if (operationType === security_1.AccessTypes.read)
+                return permission.read;
+            if (operationType === security_1.AccessTypes.write)
+                return permission.write;
+        }
         return false;
     });
 }

package/dist/services/file/service.d.ts

@@ -21,9 +21,12 @@ interface StoredFileDetail {
  * File upload options interface
  * @interface StoreFileOptions
  * @property {Object} file - File details
- * @property {string} file.path - Temporary file path
- * @property {string} file.type - MIME type of the file
- * @property {string} file.name - Original filename
+ * @property {string} [file.path] - Temporary file path (legacy)
+ * @property {string} [file.filepath] - Temporary file path (koa-body v6+)
+ * @property {string} [file.type] - MIME type of the file (legacy)
+ * @property {string} [file.mimetype] - MIME type of the file (koa-body v6+)
+ * @property {string} [file.name] - Original filename (legacy)
+ * @property {string} [file.originalFilename] - Original filename (koa-body v6+)
  * @property {number} file.size - File size in bytes
  * @property {string} ownerId - ID of the file owner
  * @property {string} tag - Tag for file organization
@@ -31,9 +34,12 @@ interface StoredFileDetail {
  */
 interface StoreFileOptions {
     file: {
-        path: string;
-        type: string;
-        name: string;
+        path?: string;
+        filepath?: string;
+        type?: string;
+        mimetype?: string;
+        name?: string;
+        originalFilename?: string;
         size: number;
     };
     ownerId: string;
@@ -41,11 +47,11 @@ interface StoreFileOptions {
     removeFileAfterStore?: boolean;
 }
 /**
- * File service for handling file storage and retrieval.
- *
- * This service provides functionality for storing, retrieving, and managing files.
- * It handles file storage on disk and maintains file metadata in the database.
- * Files are organized by format and tag in the upload directory.
+ * File service class for handling file operations
+ * @class FileService
+ * @description
+ * This class provides methods for managing file uploads, retrieval, and deletion.
+ * It handles physical file storage and database metadata management.
  */
 declare class FileService {
     /**
@@ -86,29 +92,17 @@ declare class FileService {
      */
     setUploadDirectory(directoryOrConfig: string | StaticPathOptions): void;
     /**
-     * @hidden
-     *
-     * Creates stored file details with unique filename
+     * Creates a unique filename and storage details
      * @param {string} fileType - MIME type of the file
-     * @param {string} tag - Tag for file organization
-     * @returns {StoredFileDetail} Storage details including filename and path
-     * @throws {Error} If upload directory is not set
-     *
-     * @example
-     * ```typescript
-     * import { fileService } from '@modular-rest/server';
-     *
-     * const details = fileService.createStoredDetail('image/jpeg', 'profile');
-     * // Returns: { fileName: '1234567890.jpeg', fullPath: '/uploads/jpeg/profile/1234567890.jpeg', fileFormat: 'jpeg' }
-     * ```
+     * @param {string} tag - File tag
+     * @returns {StoredFileDetail} Storage details including unique filename and path
+     * @hidden
      */
     createStoredDetail(fileType: string, tag: string): StoredFileDetail;
     /**
-     * @hidden
-     *
-     * Stores a file, removes the temporary file, and saves metadata to database
+     * Stores a file on disc and creates metadata in database
      * @param {StoreFileOptions} options - File storage options
-     * @returns {Promise<IFile>} Promise resolving to stored file document
+     * @returns {Promise<IFile>} The created file document
      * @throws {Error} If upload directory is not set or storage fails
      * @example
      * ```typescript
@@ -129,75 +123,50 @@ declare class FileService {
      */
     storeFile({ file, ownerId, tag, removeFileAfterStore }: StoreFileOptions): Promise<IFile>;
     /**
-     * @hidden
-     *
-     * Removes a file from the disk
-     * @param {string} path - File path to remove
-     * @returns {Promise<void>} Promise resolving when file is removed
-     * @throws {Error} If file removal fails
+     * Deletes a file from disc and database
+     * @param {string} fileId - ID of the file to delete
+     * @returns {Promise<boolean>} True if deletion was successful
+     * @throws {Error} If file is not found or deletion fails
      * @example
      * ```typescript
      * import { fileService } from '@modular-rest/server';
      *
-     * await fileService.removeFromDisc('/uploads/jpeg/profile/1234567890.jpeg');
+     * await fileService.removeFile('file123');
      * ```
      */
-    removeFromDisc(path: string): Promise<void>;
+    removeFile(fileId: string): Promise<boolean>;
     /**
-     * Removes a file from both database and disk
-     *
-     * @param {string} fileId - File ID to remove
-     * @returns {Promise<void>} Promise resolving when file is removed
-     * @throws {Error} If file is not found or removal fails
-     * @example
-     * ```typescript
-     * import { fileService } from '@modular-rest/server';
-     *
-     * try {
-     *   await fileService.removeFile('file123');
-     *   console.log('File removed successfully');
-     * } catch (error) {
-     *   console.error('Failed to remove file:', error);
-     * }
-     * ```
+     * Deletes a file from physical storage
+     * @param {string} path - Physical path to the file
+     * @returns {Promise<boolean>} True if deletion was successful
+     * @hidden
      */
-    removeFile(fileId: string): Promise<void>;
+    removeFromDisc(path: string): Promise<boolean>;
     /**
-     * Retrieves a file document from the database
-     *
-     * @param {string} fileId - File ID to retrieve
-     * @returns {Promise<IFile>} Promise resolving to file document
-     * @throws {Error} If collection model is not found or file is not found
-     * @example
-     * ```typescript
-     * import { fileService } from '@modular-rest/server';
-     *
-     * const fileDoc = await fileService.getFile('file123');
-     * console.log('File details:', fileDoc);
-     * ```
+     * Retrieves a file document from database
+     * @param {string} fileId - ID of the file
+     * @returns {Promise<IFile>} The file document
+     * @throws {Error} If file is not found
+     * @hidden
      */
     getFile(fileId: string): Promise<IFile>;
     /**
-     * Retrieves the public URL link for a file
-     *
-     * @param {string} fileId - File ID to get link for
-     * @returns {Promise<string>} Promise resolving to file URL
-     * @throws {Error} If URL path is not defined or file is not found
+     * Gets the public URL for a file
+     * @param {string} fileId - ID of the file
+     * @returns {Promise<string>} The public URL
      * @example
      * ```typescript
      * import { fileService } from '@modular-rest/server';
      *
-     * const link = await fileService.getFileLink('file123');
-     * // Returns: '/uploads/jpeg/profile/1234567890.jpeg'
+     * const url = await fileService.getFileLink('file123');
+     * // Returns: '/assets/jpeg/profile/1234567890.jpeg'
      * ```
      */
     getFileLink(fileId: string): Promise<string>;
     /**
-     * Gets the full filesystem path for a file
-     *
-     * @param {string} fileId - File ID to get path for
-     * @returns {Promise<string>} Promise resolving to full file path
-     * @throws {Error} If upload directory is not set or file is not found
+     * Gets the physical path for a file
+     * @param {string} fileId - ID of the file
+     * @returns {Promise<string>} The physical path
      * @example
      * ```typescript
      * import { fileService } from '@modular-rest/server';