@modular-rest/server 1.18.1 → 1.20.0

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/class/combinator.ts

@@ -25,7 +25,7 @@ class Combinator {
     // find route paths
     const option = {
       name: 'router',
-      filter: ['.js'],
+      filter: ['.js', '.ts'],
     };
 
     let routerPaths: string[] = [];
@@ -35,6 +35,9 @@ class Combinator {
       console.log(e);
     }
 
+    // ignore type declarations
+    routerPaths = routerPaths.filter(routePath => !routePath.endsWith('.d.ts'));
+
     // create and combine routes into the app
     for (let i = 0; i < routerPaths.length; i++) {
       const service = require(routerPaths[i]);
@@ -62,7 +65,7 @@ class Combinator {
 
     const option = {
       name: filename.name,
-      filter: [filename.extension],
+      filter: [filename.extension, '.ts'],
     };
 
     let modulesPath: string[] = [];
@@ -72,6 +75,8 @@ class Combinator {
       console.log(e);
     }
 
+    modulesPath = modulesPath.filter(modulePath => !modulePath.endsWith('.d.ts'));
+
     // create and combine routes into the app
     for (let i = 0; i < modulesPath.length; i++) {
       const moduleObject = require(modulesPath[i]);
@@ -113,7 +118,7 @@ class Combinator {
     // find route paths
     const option = {
       name: filename.name,
-      filter: [filename.extension],
+      filter: [filename.extension, '.ts'],
     };
 
     let functionsPaths: string[] = [];
@@ -123,6 +128,8 @@ class Combinator {
       console.log(e);
     }
 
+    functionsPaths = functionsPaths.filter(functionPath => !functionPath.endsWith('.d.ts'));
+
     // create and combine routes into the app
     for (let i = 0; i < functionsPaths.length; i++) {
       const modularFunctions = require(functionsPaths[i]);

package/src/class/directory.ts

@@ -6,67 +6,49 @@ interface DirectorySettings {
   filter?: string[];
 }
 
-type WalkCallback = (err: Error | null, results: string[]) => void;
-
 /**
- * Walk through a directory and its subdirectories
+ * Walk through a directory and its subdirectories efficiently
  * @param dir - Directory to walk
  * @param settings - Settings for filtering files
- * @param done - Callback function
  */
-function walk(dir: string, settings: DirectorySettings, done: WalkCallback): void {
+async function walk(dir: string, settings: DirectorySettings): Promise<string[]> {
   let results: string[] = [];
+  const list = await fs.promises.readdir(dir);
 
-  // Read director file and folders
-  fs.readdir(dir, function (err, list) {
-    if (err) return done(err, results);
-
-    let pending = list.length;
-    if (!pending) return done(null, results);
-
-    list.forEach(function (file) {
-      file = path.join(dir, file);
-      fs.stat(file, function (err, stat) {
-        if (err) {
-          // Handle file stat error but continue with other files
-          console.error(`Error reading file stats for ${file}:`, err);
-          if (!--pending) done(null, results);
-          return;
-        }
-
-        // If directory, execute a recursive call
-        if (stat && stat.isDirectory()) {
-          // Add directory to array [comment if you need to remove the directories from the array]
-          // results.push(file);
-          walk(file, settings, function (err, res) {
-            results = results.concat(res);
-            if (!--pending) done(null, results);
-          });
-        } else {
-          // file filter
-          const extension = path.extname(file);
-          const fileName = path.basename(file).split('.')[0];
-          let fileNameKey = true;
-
-          // name filter
-          if (settings.name && settings.name === fileName) fileNameKey = true;
-          else fileNameKey = false;
+  for (const file of list) {
+    const filePath = path.join(dir, file);
+    const stat = await fs.promises.stat(filePath);
 
-          // extension filter
-          if (settings.filter && fileNameKey) {
-            settings.filter.forEach(function (element) {
-              if (element.toLowerCase() === extension.toLowerCase()) results.push(file);
-            });
-          }
+    if (stat && stat.isDirectory()) {
+      // Ignore common directories that should not be scanned
+      if (file === 'node_modules' || file === '.git' || file === 'dist') {
+        continue;
+      }
+      const res = await walk(filePath, settings);
+      results = results.concat(res);
+    } else {
+      const extension = path.extname(filePath);
+      const fileName = path.basename(filePath).split('.')[0];
+      let fileNameKey = true;
 
-          // push any file if no option
-          else if (fileNameKey) results.push(file);
+      // name filter
+      if (settings.name && settings.name !== fileName) {
+        fileNameKey = false;
+      }
 
-          if (!--pending) done(null, results);
+      // extension filter
+      if (settings.filter && fileNameKey) {
+        if (settings.filter.some(ext => ext.toLowerCase() === extension.toLowerCase())) {
+          results.push(filePath);
         }
-      });
-    });
-  });
+      }
+      // push any file if no name filter and no extension filter
+      else if (fileNameKey && !settings.filter) {
+        results.push(filePath);
+      }
+    }
+  }
+  return results;
 }
 
 /**
@@ -75,13 +57,13 @@ function walk(dir: string, settings: DirectorySettings, done: WalkCallback): voi
  * @param settings - Settings for filtering files
  * @returns Promise resolving to an array of file paths
  */
-function find(dir: string, settings: DirectorySettings): Promise<string[]> {
-  return new Promise((resolve, reject) => {
-    walk(dir, settings, (err, result) => {
-      if (err) reject(err);
-      else resolve(result);
-    });
-  });
+async function find(dir: string, settings: DirectorySettings): Promise<string[]> {
+  try {
+    return await walk(dir, settings);
+  } catch (err) {
+    console.error(`Error in directory.find for ${dir}:`, err);
+    return [];
+  }
 }
 
 export { walk, find };

package/src/helper/data_insertion.ts

@@ -45,28 +45,97 @@ interface AdminCredentials {
 export async function createAdminUser({ email, password }: AdminCredentials): Promise<void> {
   const authModel = DataProvider.getCollection('cms', 'auth');
 
+  // Wait for connection to be ready for queries
+  const connection = authModel.db;
+  if (connection) {
+    if (connection.readyState !== 1) {
+      await new Promise<void>((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          reject(new Error('Database connection timeout - connection not ready after 10s'));
+        }, 10000);
+
+        if (connection.readyState === 1) {
+          clearTimeout(timeout);
+          resolve();
+        } else {
+          connection.once('connected', () => {
+            clearTimeout(timeout);
+            resolve();
+          });
+          connection.once('error', err => {
+            clearTimeout(timeout);
+            reject(err);
+          });
+        }
+      });
+    }
+
+    // Test if database is actually ready by doing a simple operation
+    // This ensures the connection is fully initialized
+    let retries = 5;
+    let lastError: Error | null = null;
+    while (retries > 0) {
+      try {
+        await authModel.findOne({}).limit(1).maxTimeMS(3000).lean().exec();
+        // Additional small delay to ensure write operations will work
+        await new Promise(resolve => setTimeout(resolve, 100));
+        break; // Success, connection is ready
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+        retries--;
+        if (retries > 0) {
+          await new Promise(resolve => setTimeout(resolve, 500));
+        }
+      }
+    }
+    if (retries === 0 && lastError) {
+      throw new Error(`Database not ready for queries: ${lastError.message}`);
+    }
+  }
+
   try {
-    const isAnonymousExisted = await authModel.countDocuments({ type: 'anonymous' }).exec();
+    // Execute queries with explicit timeout handling
+    const queryOptions = { maxTimeMS: 5000 }; // 5 second timeout
+
+    const isAnonymousExisted = await authModel
+      .countDocuments({ type: 'anonymous' })
+      .maxTimeMS(5000)
+      .exec();
 
     const isAdministratorExisted = await authModel
       .countDocuments({ type: 'user', email: email })
+      .maxTimeMS(5000)
       .exec();
 
     if (isAnonymousExisted === 0) {
-      await userManager.main.registerUser({
-        permissionGroup: getDefaultAnonymousPermissionGroup().title,
-        email: '',
-        phone: '',
-        password: '',
-        type: 'anonymous',
-      });
-      // await new authModel({
-      //   permission: getDefaultAnonymousPermissionGroup().title,
-      //   email: "",
-      //   phone: "",
-      //   password: "",
-      //   type: "anonymous",
-      // }).save();
+      // Wrap registerUser with timeout to prevent hanging
+      try {
+        let timeoutId: NodeJS.Timeout;
+        await Promise.race([
+          userManager.main.registerUser({
+            permissionGroup: getDefaultAnonymousPermissionGroup().title,
+            email: '',
+            phone: '',
+            password: '',
+            type: 'anonymous',
+          }),
+          new Promise<never>((_, reject) => {
+            timeoutId = setTimeout(
+              () => reject(new Error('registerUser timeout for anonymous user after 15s')),
+              15000
+            );
+          }),
+        ]).finally(() => {
+          if (timeoutId!) clearTimeout(timeoutId);
+        });
+      } catch (err) {
+        // If anonymous user creation fails, log but don't fail completely
+        // It might already exist from a previous attempt
+        console.warn(
+          'Failed to create anonymous user:',
+          err instanceof Error ? err.message : String(err)
+        );
+      }
     }
 
     if (isAdministratorExisted === 0) {
@@ -74,19 +143,24 @@ export async function createAdminUser({ email, password }: AdminCredentials): Pr
         return Promise.reject('Invalid email or password for admin user.');
       }
 
-      await userManager.main.registerUser({
-        permissionGroup: getDefaultAdministratorPermissionGroup().title,
-        email: email,
-        password: password,
-        type: 'user',
+      // Wrap registerUser with timeout to prevent hanging
+      let timeoutId: NodeJS.Timeout;
+      await Promise.race([
+        userManager.main.registerUser({
+          permissionGroup: getDefaultAdministratorPermissionGroup().title,
+          email: email,
+          password: password,
+          type: 'user',
+        }),
+        new Promise<never>((_, reject) => {
+          timeoutId = setTimeout(
+            () => reject(new Error('registerUser timeout for admin user after 15s')),
+            15000
+          );
+        }),
+      ]).finally(() => {
+        if (timeoutId!) clearTimeout(timeoutId);
       });
-
-      // await new authModel({
-      //   permission: getDefaultAdministratorPermissionGroup().title,
-      //   email: email,
-      //   password: password,
-      //   type: "user",
-      // }).save();
     }
   } catch (e) {
     return Promise.reject(e);

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