@modular-rest/server 1.19.0 → 1.20.1

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/services/data_provider/model_registry.ts

@@ -73,6 +73,8 @@ class ModelRegistry {
         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;
@@ -139,6 +141,8 @@ class ModelRegistry {
             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;
@@ -208,6 +212,30 @@ class ModelRegistry {
   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

package/src/services/data_provider/service.ts

@@ -73,6 +73,8 @@ function connectToDatabaseByCollectionDefinitionList(
         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;
@@ -281,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;
   });
 }