@modular-rest/server 1.19.0 → 1.20.0

package/.nvmrc

@@ -1 +1 @@
-v21.5.0
+v22.12.0

package/dist/application.js

@@ -206,16 +206,17 @@ async function createRest(options) {
                 extension: '.js',
             },
         });
-        // 5. Plug in additional defined functions
-        if (config_1.config.functions) {
-            combinator_1.default.addFunctionsByArray(config_1.config.functions);
-        }
+    }
+    // 5. Plug in additional defined functions
+    if (config_1.config.functions) {
+        combinator_1.default.addFunctionsByArray(config_1.config.functions);
     }
     // 4. Setting up default services
     try {
         await require('./helper/presetup_services').setup(config_1.config);
     }
     catch (e) {
+        console.error(`[createRest] Error in setup:`, e);
         return Promise.reject(e);
     }
     /**

package/dist/class/combinator.js

@@ -43,7 +43,7 @@ class Combinator {
         // find route paths
         const option = {
             name: 'router',
-            filter: ['.js'],
+            filter: ['.js', '.ts'],
         };
         let routerPaths = [];
         try {
@@ -52,6 +52,8 @@ class Combinator {
         catch (e) {
             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]);
@@ -70,7 +72,7 @@ class Combinator {
         let rootObject_temp;
         const option = {
             name: filename.name,
-            filter: [filename.extension],
+            filter: [filename.extension, '.ts'],
         };
         let modulesPath = [];
         try {
@@ -79,6 +81,7 @@ class Combinator {
         catch (e) {
             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]);
@@ -117,7 +120,7 @@ class Combinator {
         // find route paths
         const option = {
             name: filename.name,
-            filter: [filename.extension],
+            filter: [filename.extension, '.ts'],
         };
         let functionsPaths = [];
         try {
@@ -126,6 +129,7 @@ class Combinator {
         catch (e) {
             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/dist/class/directory.d.ts

@@ -2,14 +2,12 @@ interface DirectorySettings {
     name?: string;
     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
  */
-declare function walk(dir: string, settings: DirectorySettings, done: WalkCallback): void;
+declare function walk(dir: string, settings: DirectorySettings): Promise<string[]>;
 /**
  * Find files in a directory with Promise API
  * @param dir - Directory to search

package/dist/class/directory.js

@@ -8,66 +8,45 @@ exports.find = find;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 /**
- * 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, settings, done) {
+async function walk(dir, settings) {
     let results = [];
-    // Read director file and folders
-    fs_1.default.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_1.default.join(dir, file);
-            fs_1.default.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;
+    const list = await fs_1.default.promises.readdir(dir);
+    for (const file of list) {
+        const filePath = path_1.default.join(dir, file);
+        const stat = await fs_1.default.promises.stat(filePath);
+        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_1.default.extname(filePath);
+            const fileName = path_1.default.basename(filePath).split('.')[0];
+            let fileNameKey = true;
+            // name filter
+            if (settings.name && settings.name !== fileName) {
+                fileNameKey = false;
+            }
+            // extension filter
+            if (settings.filter && fileNameKey) {
+                if (settings.filter.some(ext => ext.toLowerCase() === extension.toLowerCase())) {
+                    results.push(filePath);
                 }
-                // 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_1.default.extname(file);
-                    const fileName = path_1.default.basename(file).split('.')[0];
-                    let fileNameKey = true;
-                    // name filter
-                    if (settings.name && settings.name === fileName)
-                        fileNameKey = true;
-                    else
-                        fileNameKey = false;
-                    // extension filter
-                    if (settings.filter && fileNameKey) {
-                        settings.filter.forEach(function (element) {
-                            if (element.toLowerCase() === extension.toLowerCase())
-                                results.push(file);
-                        });
-                    }
-                    // push any file if no option
-                    else if (fileNameKey)
-                        results.push(file);
-                    if (!--pending)
-                        done(null, results);
-                }
-            });
-        });
-    });
+            }
+            // push any file if no name filter and no extension filter
+            else if (fileNameKey && !settings.filter) {
+                results.push(filePath);
+            }
+        }
+    }
+    return results;
 }
 /**
  * Find files in a directory with Promise API
@@ -75,13 +54,12 @@ function walk(dir, settings, done) {
  * @param settings - Settings for filtering files
  * @returns Promise resolving to an array of file paths
  */
-function find(dir, settings) {
-    return new Promise((resolve, reject) => {
-        walk(dir, settings, (err, result) => {
-            if (err)
-                reject(err);
-            else
-                resolve(result);
-        });
-    });
+async function find(dir, settings) {
+    try {
+        return await walk(dir, settings);
+    }
+    catch (err) {
+        console.error(`Error in directory.find for ${dir}:`, err);
+        return [];
+    }
 }

package/dist/helper/data_insertion.js

@@ -65,43 +65,110 @@ const userManager = __importStar(require("../services/user_manager/service"));
  */
 async function createAdminUser({ email, password }) {
     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((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 = 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: (0, permissionManager_1.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;
+                await Promise.race([
+                    userManager.main.registerUser({
+                        permissionGroup: (0, permissionManager_1.getDefaultAnonymousPermissionGroup)().title,
+                        email: '',
+                        phone: '',
+                        password: '',
+                        type: 'anonymous',
+                    }),
+                    new Promise((_, 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) {
             if (!email || !password) {
                 return Promise.reject('Invalid email or password for admin user.');
             }
-            await userManager.main.registerUser({
-                permissionGroup: (0, permissionManager_1.getDefaultAdministratorPermissionGroup)().title,
-                email: email,
-                password: password,
-                type: 'user',
+            // Wrap registerUser with timeout to prevent hanging
+            let timeoutId;
+            await Promise.race([
+                userManager.main.registerUser({
+                    permissionGroup: (0, permissionManager_1.getDefaultAdministratorPermissionGroup)().title,
+                    email: email,
+                    password: password,
+                    type: 'user',
+                }),
+                new Promise((_, 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) {

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

@@ -62,6 +62,11 @@ declare class ModelRegistry {
      * @returns {boolean} True if model exists, false otherwise
      */
     hasModel(database: string, collection: string): boolean;
+    /**
+     * Clear all internal state, including connections and models.
+     * Useful for testing when different database prefixes are used.
+     */
+    clear(): Promise<void>;
 }
 export declare const modelRegistry: ModelRegistry;
 export default modelRegistry;

package/dist/services/data_provider/model_registry.js

@@ -63,6 +63,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;
         }
@@ -120,6 +122,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;
                     // Create models for this database if they don't exist
@@ -183,6 +187,27 @@ class ModelRegistry {
     hasModel(database, collection) {
         return !!(this.models[database] && this.models[database][collection]);
     }
+    /**
+     * Clear all internal state, including connections and models.
+     * Useful for testing when different database prefixes are used.
+     */
+    async clear() {
+        // Close all connections first
+        await Promise.all(Object.values(this.connections).map(async (connection) => {
+            if (connection.readyState !== 0) {
+                try {
+                    await connection.close();
+                }
+                catch (err) {
+                    // Ignore close errors
+                }
+            }
+        }));
+        this.connections = {};
+        this.models = {};
+        this.collectionDefinitions = [];
+        this.mongoOption = null;
+    }
 }
 // Export singleton instance
 exports.modelRegistry = ModelRegistry.getInstance();

package/dist/services/data_provider/service.js

@@ -51,6 +51,8 @@ function connectToDatabaseByCollectionDefinitionList(dbName, collectionDefinitio
                 useUnifiedTopology: true,
                 useNewUrlParser: true,
                 dbName: fullDbName,
+                serverSelectionTimeoutMS: 10000, // 10 second timeout for server selection
+                socketTimeoutMS: 45000, // 45 second timeout for socket operations
             });
         }
         else {
@@ -236,6 +238,12 @@ function checkAccess(db, collection, operationType, queryOrDoc, user) {
             return true;
         if (permission.accessType === 'user_access' && user.type === 'user')
             return true;
+        if (typeof user.hasPermission === 'function' && user.hasPermission(permission.accessType)) {
+            if (operationType === security_1.AccessTypes.read)
+                return permission.read;
+            if (operationType === security_1.AccessTypes.write)
+                return permission.write;
+        }
         return false;
     });
 }

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

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