@modular-rest/server 1.18.0 → 1.19.0

package/dist/class/collection_definition.d.ts

@@ -1,6 +1,7 @@
-import { Schema } from 'mongoose';
+import { Schema, Model } from 'mongoose';
 import { Permission } from './security';
 import { DatabaseTrigger } from './database_trigger';
+import { MongoOption } from '../services/data_provider/service';
 /**
  * Configuration options for creating a collection definition.
  * This interface defines the structure for configuring MongoDB collections with their associated
@@ -24,6 +25,11 @@ interface CollectionDefinitionOptions {
      * @see https://mongoosejs.com/docs/5.x/docs/guide.html
      */
     schema: Schema<any>;
+    /**
+     * Optional MongoDB connection options. If not provided, will use config.mongo if available.
+     * This is used to pre-create the model before server startup.
+     */
+    mongoOption?: MongoOption;
 }
 /**
  * To have define any collection in your database you haveto use below method in your `db.[js|ts]` file and export an array of CollectionDefinition instances.
@@ -31,7 +37,7 @@ interface CollectionDefinitionOptions {
  * @param {CollectionDefinitionOptions} options - The options for the collection
  * @expandType CollectionDefinitionOptions
  *
- * @returns A new instance of CollectionDefinition
+ * @returns A CollectionDefinition instance with a model property that returns the mongoose model
  *
  * @public
  *
@@ -48,9 +54,16 @@ interface CollectionDefinitionOptions {
  *     // trigger: DatabaseTrigger[]
  *   })
  * ]
+ *
+ * // Access the model directly:
+ * const userCollection = defineCollection({...});
+ * const UserModel = userCollection.model;
+ * const users = await UserModel.find();
  * ```
  */
-export declare function defineCollection(options: CollectionDefinitionOptions): CollectionDefinition;
+export declare function defineCollection(options: CollectionDefinitionOptions): CollectionDefinition & {
+    model: Model<any>;
+};
 /**
  * A class that represents a MongoDB collection configuration. Provides full support for schema validation, access control through permissions,
  * and custom triggers for various database operations.
@@ -99,6 +112,8 @@ export declare class CollectionDefinition {
     permissions: Permission[];
     /** @readonly Optional database triggers */
     triggers?: DatabaseTrigger[];
+    /** Optional mongoose model for this collection */
+    private _model;
     /**
      * Creates a new CollectionDefinition instance
      *
@@ -108,5 +123,15 @@ export declare class CollectionDefinition {
      * @beta
      */
     constructor({ database, collection, schema, permissions, triggers, }: CollectionDefinitionOptions);
+    /**
+     * Get the mongoose model for this collection
+     * @returns {Model<any> | null} The mongoose model or null if not set
+     */
+    getModel(): Model<any> | null;
+    /**
+     * Set the mongoose model for this collection
+     * @param {Model<any>} model - The mongoose model
+     */
+    setModel(model: Model<any>): void;
 }
 export {};

package/dist/class/collection_definition.js

@@ -1,14 +1,19 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CollectionDefinition = void 0;
 exports.defineCollection = defineCollection;
+const model_registry_1 = __importDefault(require("../services/data_provider/model_registry"));
+const config_1 = require("../config");
 /**
  * To have define any collection in your database you haveto use below method in your `db.[js|ts]` file and export an array of CollectionDefinition instances.
  *
  * @param {CollectionDefinitionOptions} options - The options for the collection
  * @expandType CollectionDefinitionOptions
  *
- * @returns A new instance of CollectionDefinition
+ * @returns A CollectionDefinition instance with a model property that returns the mongoose model
  *
  * @public
  *
@@ -25,10 +30,59 @@ exports.defineCollection = defineCollection;
  *     // trigger: DatabaseTrigger[]
  *   })
  * ]
+ *
+ * // Access the model directly:
+ * const userCollection = defineCollection({...});
+ * const UserModel = userCollection.model;
+ * const users = await UserModel.find();
  * ```
  */
 function defineCollection(options) {
-    return new CollectionDefinition(options);
+    const definition = new CollectionDefinition(options);
+    // Try to get mongoOption from options or config
+    let mongoOption = options.mongoOption;
+    if (!mongoOption && config_1.config.mongo) {
+        mongoOption = config_1.config.mongo;
+    }
+    // If mongoOption is available, register the collection and create the model
+    if (mongoOption) {
+        const model = model_registry_1.default.registerCollection(definition, mongoOption);
+        definition.setModel(model);
+    }
+    // Create a proxy object that includes both CollectionDefinition properties and model
+    const result = definition;
+    // Add model property getter
+    Object.defineProperty(result, 'model', {
+        get() {
+            // If model was already set, return it
+            const existingModel = definition.getModel();
+            if (existingModel) {
+                return existingModel;
+            }
+            // Otherwise, try to get from registry
+            const registryModel = model_registry_1.default.getModel(definition.database, definition.collection);
+            if (registryModel) {
+                definition.setModel(registryModel);
+                return registryModel;
+            }
+            // If still not found, try to get mongoOption from config and register now
+            let currentMongoOption = mongoOption;
+            if (!currentMongoOption && config_1.config.mongo) {
+                currentMongoOption = config_1.config.mongo;
+            }
+            if (currentMongoOption) {
+                const newModel = model_registry_1.default.registerCollection(definition, currentMongoOption);
+                definition.setModel(newModel);
+                return newModel;
+            }
+            throw new Error(`Model for ${definition.database}.${definition.collection} is not available. ` +
+                `Ensure mongoOption is provided in defineCollection options, config.mongo is set, ` +
+                `or the collection is registered via addCollectionDefinitionByList before accessing the model.`);
+        },
+        enumerable: true,
+        configurable: true,
+    });
+    return result;
 }
 /**
  * A class that represents a MongoDB collection configuration. Provides full support for schema validation, access control through permissions,
@@ -77,11 +131,27 @@ class CollectionDefinition {
      * @beta
      */
     constructor({ database, collection, schema, permissions, triggers, }) {
+        /** Optional mongoose model for this collection */
+        this._model = null;
         this.database = database;
         this.collection = collection;
         this.schema = schema;
         this.permissions = permissions;
         this.triggers = triggers;
     }
+    /**
+     * Get the mongoose model for this collection
+     * @returns {Model<any> | null} The mongoose model or null if not set
+     */
+    getModel() {
+        return this._model;
+    }
+    /**
+     * Set the mongoose model for this collection
+     * @param {Model<any>} model - The mongoose model
+     */
+    setModel(model) {
+        this._model = model;
+    }
 }
 exports.CollectionDefinition = CollectionDefinition;

package/dist/index.d.ts

@@ -40,7 +40,7 @@ export { createRest };
  *   ],
  *   uploadDirectoryConfig: {
  *     directory: './uploads',
-   *     urlPath: '/assets'
+ *     urlPath: '/assets'
  *   }
  * };
  * ```
@@ -118,6 +118,17 @@ export { paginator };
  * @description Database collection access utilities
  */
 export { getCollection };
+/**
+ * @description Model registry for managing mongoose models and connections
+ * @example
+ * ```typescript
+ * import { modelRegistry } from '@modular-rest/server';
+ *
+ * // Get a model directly from registry
+ * const userModel = modelRegistry.getModel('myapp', 'users');
+ * ```
+ */
+export { modelRegistry } from './services/data_provider/model_registry';
 /**
  * @description File handling utilities
  * @example

package/dist/index.js

@@ -36,7 +36,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.userManager = exports.middleware = exports.fileService = exports.getCollection = exports.paginator = exports.reply = exports.validator = exports.TypeCasters = exports.defineFunction = exports.AccessTypes = exports.PermissionGroup = exports.PermissionTypes = exports.Permission = exports.AccessDefinition = exports.CmsTrigger = exports.DatabaseTrigger = exports.Schema = exports.schemas = exports.defineCollection = exports.CollectionDefinition = exports.createRest = void 0;
+exports.userManager = exports.middleware = exports.fileService = exports.modelRegistry = exports.getCollection = exports.paginator = exports.reply = exports.validator = exports.TypeCasters = exports.defineFunction = exports.AccessTypes = exports.PermissionGroup = exports.PermissionTypes = exports.Permission = exports.AccessDefinition = exports.CmsTrigger = exports.DatabaseTrigger = exports.Schema = exports.schemas = exports.defineCollection = exports.CollectionDefinition = exports.createRest = void 0;
 // Application
 const application_1 = require("./application");
 Object.defineProperty(exports, "createRest", { enumerable: true, get: function () { return application_1.createRest; } });
@@ -77,3 +77,15 @@ Object.defineProperty(exports, "PermissionGroup", { enumerable: true, get: funct
 Object.defineProperty(exports, "AccessTypes", { enumerable: true, get: function () { return security_1.AccessTypes; } });
 const middleware = __importStar(require("./middlewares"));
 exports.middleware = middleware;
+/**
+ * @description Model registry for managing mongoose models and connections
+ * @example
+ * ```typescript
+ * import { modelRegistry } from '@modular-rest/server';
+ *
+ * // Get a model directly from registry
+ * const userModel = modelRegistry.getModel('myapp', 'users');
+ * ```
+ */
+var model_registry_1 = require("./services/data_provider/model_registry");
+Object.defineProperty(exports, "modelRegistry", { enumerable: true, get: function () { return model_registry_1.modelRegistry; } });

package/dist/services/data_provider/model_registry.d.ts

@@ -0,0 +1,67 @@
+import { Connection, Model } from 'mongoose';
+import { CollectionDefinition } from '../../class/collection_definition';
+import { MongoOption } from './service';
+/**
+ * ModelRegistry - Singleton class for managing mongoose models and connections
+ * Pre-creates all models before database connections are established
+ */
+declare class ModelRegistry {
+    private static instance;
+    private connections;
+    private models;
+    private collectionDefinitions;
+    private mongoOption;
+    private constructor();
+    /**
+     * Get the singleton instance of ModelRegistry
+     * @returns {ModelRegistry} The singleton instance
+     */
+    static getInstance(): ModelRegistry;
+    /**
+     * 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: CollectionDefinition, mongoOption: MongoOption): Model<any>;
+    /**
+     * 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: string, collection: string): Model<any> | null;
+    /**
+     * Get a connection for a database
+     * @param {string} database - Database name
+     * @returns {Connection | null} The mongoose connection or null if not found
+     */
+    getConnection(database: string): Connection | 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
+     */
+    initializeConnections(mongoOption: MongoOption): Promise<void>;
+    /**
+     * Get all registered collection definitions
+     * @returns {CollectionDefinition[]} Array of collection definitions
+     */
+    getCollectionDefinitions(): CollectionDefinition[];
+    /**
+     * 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: string): Record<string, Model<any>> | 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: string, collection: string): boolean;
+}
+export declare const modelRegistry: ModelRegistry;
+export default modelRegistry;

package/dist/services/data_provider/model_registry.js

@@ -0,0 +1,189 @@
+"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,
+            });
+            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,
+                    });
+                    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]);
+    }
+}
+// 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,23 @@ 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,
+            });
+        }
+        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 +67,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 +112,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 +154,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 +172,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);
 }

package/dist/services/user_manager/db.js

@@ -18,7 +18,7 @@ const authSchema = new mongoose_1.Schema({
 authSchema.index({ email: 1 }, { unique: true });
 authSchema.pre(['save', 'updateOne'], function (next) {
     // Encode the password before saving
-    if (this.isModified && this.isModified('password')) {
+    if (this.isModified && this.isModified('password') && this.password) {
         this.password = Buffer.from(this.password).toString('base64');
     }
     next();

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@modular-rest/server",
-	"version": "1.18.0",
+	"version": "1.19.0",
 	"description": "TypeScript version of a nodejs module based on KOAJS for developing Rest-APIs in a modular solution.",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",

package/src/class/collection_definition.ts

@@ -1,6 +1,9 @@
-import { Schema } from 'mongoose';
+import { Schema, Model } from 'mongoose';
 import { Permission } from './security';
 import { DatabaseTrigger } from './database_trigger';
+import modelRegistry from '../services/data_provider/model_registry';
+import { MongoOption } from '../services/data_provider/service';
+import { config } from '../config';
 
 /**
  * Configuration options for creating a collection definition.
@@ -26,6 +29,12 @@ interface CollectionDefinitionOptions {
    * @see https://mongoosejs.com/docs/5.x/docs/guide.html
    */
   schema: Schema<any>;
+
+  /**
+   * Optional MongoDB connection options. If not provided, will use config.mongo if available.
+   * This is used to pre-create the model before server startup.
+   */
+  mongoOption?: MongoOption;
 }
 
 /**
@@ -34,7 +43,7 @@ interface CollectionDefinitionOptions {
  * @param {CollectionDefinitionOptions} options - The options for the collection
  * @expandType CollectionDefinitionOptions
  *
- * @returns A new instance of CollectionDefinition
+ * @returns A CollectionDefinition instance with a model property that returns the mongoose model
  *
  * @public
  *
@@ -51,10 +60,72 @@ interface CollectionDefinitionOptions {
  *     // trigger: DatabaseTrigger[]
  *   })
  * ]
+ *
+ * // Access the model directly:
+ * const userCollection = defineCollection({...});
+ * const UserModel = userCollection.model;
+ * const users = await UserModel.find();
  * ```
  */
-export function defineCollection(options: CollectionDefinitionOptions) {
-  return new CollectionDefinition(options);
+export function defineCollection(
+  options: CollectionDefinitionOptions
+): CollectionDefinition & { model: Model<any> } {
+  const definition = new CollectionDefinition(options);
+
+  // Try to get mongoOption from options or config
+  let mongoOption: MongoOption | undefined = options.mongoOption;
+  if (!mongoOption && config.mongo) {
+    mongoOption = config.mongo as MongoOption;
+  }
+
+  // If mongoOption is available, register the collection and create the model
+  if (mongoOption) {
+    const model = modelRegistry.registerCollection(definition, mongoOption);
+    definition.setModel(model);
+  }
+
+  // Create a proxy object that includes both CollectionDefinition properties and model
+  const result = definition as CollectionDefinition & { model: Model<any> };
+
+  // Add model property getter
+  Object.defineProperty(result, 'model', {
+    get() {
+      // If model was already set, return it
+      const existingModel = definition.getModel();
+      if (existingModel) {
+        return existingModel;
+      }
+
+      // Otherwise, try to get from registry
+      const registryModel = modelRegistry.getModel(definition.database, definition.collection);
+      if (registryModel) {
+        definition.setModel(registryModel);
+        return registryModel;
+      }
+
+      // If still not found, try to get mongoOption from config and register now
+      let currentMongoOption: MongoOption | undefined = mongoOption;
+      if (!currentMongoOption && config.mongo) {
+        currentMongoOption = config.mongo as MongoOption;
+      }
+
+      if (currentMongoOption) {
+        const newModel = modelRegistry.registerCollection(definition, currentMongoOption);
+        definition.setModel(newModel);
+        return newModel;
+      }
+
+      throw new Error(
+        `Model for ${definition.database}.${definition.collection} is not available. ` +
+          `Ensure mongoOption is provided in defineCollection options, config.mongo is set, ` +
+          `or the collection is registered via addCollectionDefinitionByList before accessing the model.`
+      );
+    },
+    enumerable: true,
+    configurable: true,
+  });
+
+  return result;
 }
 
 /**
@@ -110,6 +181,9 @@ export class CollectionDefinition {
   /** @readonly Optional database triggers */
   triggers?: DatabaseTrigger[];
 
+  /** Optional mongoose model for this collection */
+  private _model: Model<any> | null = null;
+
   /**
    * Creates a new CollectionDefinition instance
    *
@@ -131,4 +205,20 @@ export class CollectionDefinition {
     this.permissions = permissions;
     this.triggers = triggers;
   }
+
+  /**
+   * Get the mongoose model for this collection
+   * @returns {Model<any> | null} The mongoose model or null if not set
+   */
+  getModel(): Model<any> | null {
+    return this._model;
+  }
+
+  /**
+   * Set the mongoose model for this collection
+   * @param {Model<any>} model - The mongoose model
+   */
+  setModel(model: Model<any>): void {
+    this._model = model;
+  }
 }

package/src/index.ts

@@ -56,7 +56,7 @@ export { createRest };
  *   ],
  *   uploadDirectoryConfig: {
  *     directory: './uploads',
-   *     urlPath: '/assets'
+ *     urlPath: '/assets'
  *   }
  * };
  * ```
@@ -147,6 +147,18 @@ export { paginator };
  */
 export { getCollection };
 
+/**
+ * @description Model registry for managing mongoose models and connections
+ * @example
+ * ```typescript
+ * import { modelRegistry } from '@modular-rest/server';
+ *
+ * // Get a model directly from registry
+ * const userModel = modelRegistry.getModel('myapp', 'users');
+ * ```
+ */
+export { modelRegistry } from './services/data_provider/model_registry';
+
 /**
  * @description File handling utilities
  * @example

package/src/services/data_provider/model_registry.ts

@@ -0,0 +1,215 @@
+import mongoose, { Connection, Model } from 'mongoose';
+import { CollectionDefinition } from '../../class/collection_definition';
+import { MongoOption } from './service';
+
+/**
+ * ModelRegistry - Singleton class for managing mongoose models and connections
+ * Pre-creates all models before database connections are established
+ */
+class ModelRegistry {
+  private static instance: ModelRegistry;
+  private connections: Record<string, Connection> = {};
+  private models: Record<string, Record<string, Model<any>>> = {};
+  private collectionDefinitions: CollectionDefinition[] = [];
+  private mongoOption: MongoOption | null = null;
+
+  private constructor() {
+    // Private constructor for singleton pattern
+  }
+
+  /**
+   * Get the singleton instance of ModelRegistry
+   * @returns {ModelRegistry} The singleton instance
+   */
+  static getInstance(): ModelRegistry {
+    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: CollectionDefinition, mongoOption: MongoOption): Model<any> {
+    // 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.createConnection(connectionString, {
+        useUnifiedTopology: true,
+        useNewUrlParser: true,
+        dbName: fullDbName,
+      });
+
+      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: string, collection: string): Model<any> | null {
+    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: string): Connection | null {
+    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: MongoOption): Promise<void> {
+    this.mongoOption = mongoOption;
+
+    // Group collection definitions by database
+    const dbGroups: Record<string, CollectionDefinition[]> = {};
+    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<void>((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.createConnection(connectionString, {
+            useUnifiedTopology: true,
+            useNewUrlParser: true,
+            dbName: fullDbName,
+          });
+
+          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(): CollectionDefinition[] {
+    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: string): Record<string, Model<any>> | null {
+    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: string, collection: string): boolean {
+    return !!(this.models[database] && this.models[database][collection]);
+  }
+}
+
+// Export singleton instance
+export const modelRegistry = ModelRegistry.getInstance();
+export default modelRegistry;

package/src/services/data_provider/service.ts

@@ -5,6 +5,7 @@ import TypeCasters from './typeCasters';
 import { config } from '../../config';
 import { CollectionDefinition } from '../../class/collection_definition';
 import { User } from '../../class/user';
+import modelRegistry from './model_registry';
 
 /**
  * Service name constant
@@ -58,17 +59,25 @@ function connectToDatabaseByCollectionDefinitionList(
   mongoOption: MongoOption
 ): Promise<void> {
   return new Promise((done, reject) => {
-    // Create db connection
-    const fullDbName = (mongoOption.dbPrefix || '') + dbName;
-    const connectionString = mongoOption.mongoBaseAddress;
+    // Check if connection already exists in registry
+    let connection = modelRegistry.getConnection(dbName);
 
-    console.info(`- Connecting to database: ${fullDbName}`);
+    // Create db connection if it doesn't exist
+    if (!connection) {
+      const fullDbName = (mongoOption.dbPrefix || '') + dbName;
+      const connectionString = mongoOption.mongoBaseAddress;
 
-    const connection = mongoose.createConnection(connectionString, {
-      useUnifiedTopology: true,
-      useNewUrlParser: true,
-      dbName: fullDbName,
-    });
+      console.info(`- Connecting to database: ${fullDbName}`);
+
+      connection = mongoose.createConnection(connectionString, {
+        useUnifiedTopology: true,
+        useNewUrlParser: true,
+        dbName: fullDbName,
+      });
+    } else {
+      const fullDbName = (mongoOption.dbPrefix || '') + dbName;
+      console.info(`- Using existing connection for database: ${fullDbName}`);
+    }
 
     // Store connection
     connections[dbName] = connection;
@@ -82,11 +91,33 @@ function connectToDatabaseByCollectionDefinitionList(
 
       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 = modelRegistry.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 = modelRegistry.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 = modelRegistry.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 AccessDefinition({
@@ -111,10 +142,22 @@ function connectToDatabaseByCollectionDefinitionList(
       }
     });
 
-    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);
+      });
+    }
   });
 }
 
@@ -145,6 +188,16 @@ export async function addCollectionDefinitionByList({
   list,
   mongoOption,
 }: CollectionDefinitionListOption): Promise<void> {
+  // 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 (!modelRegistry.hasModel(collectionDefinition.database, collectionDefinition.collection)) {
+      // Register the collection and create its model
+      modelRegistry.registerCollection(collectionDefinition, mongoOption);
+    }
+  });
+
   // Group collection definitions by database
   const dbGroups: Record<string, CollectionDefinition[]> = {};
   list.forEach(collectionDefinition => {
@@ -155,6 +208,7 @@ export async function addCollectionDefinitionByList({
   });
 
   // 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)
   );

package/src/services/user_manager/db.ts

@@ -24,7 +24,7 @@ const authSchema = new Schema(
 authSchema.index({ email: 1 }, { unique: true });
 authSchema.pre(['save', 'updateOne'], function (this: AuthDocument, next) {
   // Encode the password before saving
-  if (this.isModified && this.isModified('password')) {
+  if (this.isModified && this.isModified('password') && this.password) {
     this.password = Buffer.from(this.password).toString('base64');
   }
   next();