@modular-rest/server 1.18.1 → 1.20.0

package/src/services/data_provider/model_registry.ts

@@ -0,0 +1,243 @@
+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,
+        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: 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,
+            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(): 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]);
+  }
+
+  /**
+   * Clear all internal state, including connections and models.
+   * Useful for testing when different database prefixes are used.
+   */
+  async clear(): Promise<void> {
+    // 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
+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,27 @@ 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,
+        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;
@@ -82,11 +93,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 +144,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 +190,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 +210,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)
   );
@@ -227,6 +283,10 @@ export function checkAccess(
     if (permission.accessType === 'god_access') return true;
     if (permission.accessType === 'anonymous_access' && user.type === 'anonymous') return true;
     if (permission.accessType === 'user_access' && user.type === 'user') return true;
+    if (typeof (user as any).hasPermission === 'function' && user.hasPermission(permission.accessType)) {
+      if (operationType === AccessTypes.read) return permission.read;
+      if (operationType === AccessTypes.write) return permission.write;
+    }
     return false;
   });
 }