@modular-rest/server 1.19.0 → 1.20.1

package/dist/services/file/service.js

@@ -47,11 +47,11 @@ const trigger_operator_1 = __importDefault(require("../../class/trigger_operator
  */
 exports.name = 'file';
 /**
- * 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.
  */
 class FileService {
     /**
@@ -95,56 +95,43 @@ class FileService {
                 fs_1.default.mkdirSync(directoryOrConfig, { recursive: true });
             }
             this.directory = directoryOrConfig;
-            this.urlPath = null; // No URL path available with legacy format
-            return;
+            this.urlPath = '/assets'; // Default urlPath for legacy
         }
-        // New format: Extract only necessary properties from StaticPathOptions
-        const directory = directoryOrConfig.directory || '';
-        const urlPath = directoryOrConfig.urlPath || '/assets';
-        if (!directory) {
-            throw new Error('directory is required in uploadDirectoryConfig');
-        }
-        if (!fs_1.default.existsSync(directory)) {
-            fs_1.default.mkdirSync(directory, { recursive: true });
+        else {
+            const { directory, urlPath } = directoryOrConfig;
+            if (!fs_1.default.existsSync(directory)) {
+                fs_1.default.mkdirSync(directory, { recursive: true });
+            }
+            this.directory = directory;
+            this.urlPath = urlPath || '/assets';
         }
-        // Store only the necessary properties (ignore koa-static options)
-        this.directory = directory;
-        this.urlPath = urlPath;
     }
     /**
-     * @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, tag) {
         const typeParts = fileType.split('/');
         const fileFormat = typeParts[1] || typeParts[0] || 'unknown';
         const time = new Date().getTime();
         const fileName = `${time}.${fileFormat}`;
-        if (!FileService.instance.directory) {
-            throw new Error('Upload directory has not been set');
+        if (!this.directory) {
+            throw new Error('Upload directory not set');
         }
-        const fullPath = path_1.default.join(FileService.instance.directory, fileFormat, tag, fileName);
-        return { fileName, fullPath, fileFormat };
+        const fullPath = path_1.default.join(this.directory, fileFormat, tag, fileName);
+        return {
+            fileName,
+            fullPath,
+            fileFormat,
+        };
     }
     /**
-     * @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
@@ -167,10 +154,26 @@ class FileService {
         if (!FileService.instance.directory) {
             throw new Error('Upload directory has not been set');
         }
+        const fileType = file.mimetype || file.type || 'unknown/unknown';
+        const filePath = file.filepath || file.path;
+        const fileName = file.originalFilename || file.name || 'unknown';
+        if (!filePath) {
+            throw new Error('File path is missing');
+        }
         let storedFile;
         return new Promise(async (done, reject) => {
-            storedFile = FileService.instance.createStoredDetail(file.type, tag);
-            fs_1.default.copyFile(file.path, storedFile.fullPath, (err) => {
+            storedFile = FileService.instance.createStoredDetail(fileType, tag);
+            // Ensure destination directory exists
+            const destDir = path_1.default.dirname(storedFile.fullPath);
+            try {
+                if (!fs_1.default.existsSync(destDir)) {
+                    fs_1.default.mkdirSync(destDir, { recursive: true });
+                }
+            }
+            catch (err) {
+                return reject(err);
+            }
+            fs_1.default.copyFile(filePath, storedFile.fullPath, (err) => {
                 if (err) {
                     reject(err);
                 }
@@ -179,7 +182,14 @@ class FileService {
                 }
                 // remove temp file
                 if (removeFileAfterStore) {
-                    fs_1.default.unlinkSync(file.path);
+                    try {
+                        if (fs_1.default.existsSync(filePath)) {
+                            fs_1.default.unlinkSync(filePath);
+                        }
+                    }
+                    catch (e) {
+                        console.warn('Failed to remove temp file:', e);
+                    }
                 }
             });
         })
@@ -191,161 +201,119 @@ class FileService {
             }
             const data = {
                 owner: ownerId,
+                tag,
+                originalName: fileName,
                 fileName: storedFile.fileName,
-                originalName: file.name,
                 format: storedFile.fileFormat,
-                tag,
                 size: file.size,
             };
-            // Create new document
-            const doc = new CollectionModel(data);
-            return doc.save().then(savedDoc => {
-                trigger_operator_1.default.call('insert-one', 'cms', 'file', {
-                    query: null,
-                    queryResult: savedDoc,
-                });
-                return savedDoc;
-            });
+            return CollectionModel.create(data);
         })
-            .catch(err => {
-            // remove stored file
-            fs_1.default.unlinkSync(storedFile.fullPath);
-            throw err;
-        });
-    }
-    /**
-     * @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
-     * @example
-     * ```typescript
-     * import { fileService } from '@modular-rest/server';
-     *
-     * await fileService.removeFromDisc('/uploads/jpeg/profile/1234567890.jpeg');
-     * ```
-     */
-    removeFromDisc(path) {
-        return new Promise((done, reject) => {
-            fs_1.default.unlink(path, (err) => {
-                if (err)
-                    reject(err);
-                else
-                    done();
-            });
+            .then(async (doc) => {
+            trigger_operator_1.default.call('insert-one', 'cms', 'file', { queryResult: doc });
+            return doc;
         });
     }
     /**
-     * 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
+     * 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';
      *
-     * try {
-     *   await fileService.removeFile('file123');
-     *   console.log('File removed successfully');
-     * } catch (error) {
-     *   console.error('Failed to remove file:', error);
-     * }
+     * await fileService.removeFile('file123');
      * ```
      */
-    removeFile(fileId) {
+    async removeFile(fileId) {
         if (!FileService.instance.directory) {
             throw new Error('Upload directory has not been set');
         }
-        return new Promise(async (done, reject) => {
-            const CollectionModel = DataProvider.getCollection('cms', 'file');
-            if (!CollectionModel) {
-                return reject(new Error('Collection model not found'));
-            }
-            const fileDoc = await CollectionModel.findOne({ _id: fileId }).exec();
-            if (!fileDoc) {
-                return reject(new Error('File not found'));
+        const CollectionModel = DataProvider.getCollection('cms', 'file');
+        if (!CollectionModel) {
+            throw new Error('Collection model not found');
+        }
+        const doc = await CollectionModel.findById(fileId);
+        if (!doc) {
+            throw new Error('File not found');
+        }
+        const filePath = path_1.default.join(FileService.instance.directory, doc.format, doc.tag, doc.fileName);
+        if (fs_1.default.existsSync(filePath)) {
+            try {
+                await FileService.instance.removeFromDisc(filePath);
             }
-            await CollectionModel.deleteOne({ _id: fileId })
-                .exec()
-                .then(() => {
-                // create file path
-                const filePath = path_1.default.join(FileService.instance.directory, fileDoc.format, fileDoc.tag, fileDoc.fileName);
-                // Remove file from disc
-                return FileService.instance.removeFromDisc(filePath).catch(async (err) => {
-                    // Recreate fileDoc if removing file operation has error
-                    await new CollectionModel(fileDoc).save();
+            catch (err) {
+                // If the file is not found on disc, we can still proceed with deleting metadata
+                if (err.code !== 'ENOENT') {
                     throw err;
-                });
-            })
-                .then(() => {
-                trigger_operator_1.default.call('remove-one', 'cms', 'file', {
-                    query: { _id: fileId },
-                    queryResult: null,
-                });
-            })
-                .then(done)
-                .catch(reject);
+                }
+            }
+        }
+        await CollectionModel.findByIdAndDelete(fileId);
+        trigger_operator_1.default.call('remove-one', 'cms', 'file', { queryResult: doc });
+        return true;
+    }
+    /**
+     * Deletes a file from physical storage
+     * @param {string} path - Physical path to the file
+     * @returns {Promise<boolean>} True if deletion was successful
+     * @hidden
+     */
+    removeFromDisc(path) {
+        return new Promise((done, reject) => {
+            fs_1.default.unlink(path, err => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    done(true);
+                }
+            });
         });
     }
     /**
-     * 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) {
+    async getFile(fileId) {
         const CollectionModel = DataProvider.getCollection('cms', 'file');
         if (!CollectionModel) {
             throw new Error('Collection model not found');
         }
-        return CollectionModel.findOne({ _id: fileId })
-            .exec()
-            .then(doc => {
-            if (!doc) {
-                throw new Error('File not found');
-            }
-            return doc;
-        });
+        const doc = await CollectionModel.findById(fileId);
+        if (!doc) {
+            throw new Error('File not found');
+        }
+        return doc;
     }
     /**
-     * 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'
      * ```
      */
     async getFileLink(fileId) {
         const fileDoc = await FileService.instance.getFile(fileId);
         if (!FileService.instance.urlPath) {
-            throw new Error('Upload directory URL path is not defined. Please configure uploadDirectoryConfig with a urlPath property.');
+            throw new Error('Upload directory config has not been set');
         }
         const link = `${FileService.instance.urlPath}/${fileDoc.format}/${fileDoc.tag}/${fileDoc.fileName}`;
         return link;
     }
     /**
-     * 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';
@@ -367,3 +335,4 @@ class FileService {
  * @constant {FileService}
  */
 exports.main = new FileService();
+FileService.instance = exports.main;

package/dist/services/functions/service.js

@@ -61,17 +61,17 @@ const functions = [];
  */
 function defineFunction(options) {
     // Check if the function already exists
-    const existingFunction = functions.find(f => f.name === exports.name);
+    const existingFunction = functions.find(f => f.name === options.name);
     if (existingFunction) {
-        throw new Error(`Function with name ${exports.name} already exists`);
+        throw new Error(`Function with name ${options.name} already exists`);
     }
     // Check if the permission types provided
     if (!options.permissionTypes || !options.permissionTypes.length) {
-        throw new Error(`Permission types not provided for function ${exports.name}`);
+        throw new Error(`Permission types not provided for function ${options.name}`);
     }
     // Check if the callback is a function
     if (typeof options.callback !== 'function') {
-        throw new Error(`Callback is not a function for function ${exports.name}`);
+        throw new Error(`Callback is not a function for function ${options.name}`);
     }
     // Add the function to the list of functions
     return options;

package/dist/services/jwt/router.js

@@ -41,6 +41,7 @@ const koa_router_1 = __importDefault(require("koa-router"));
 const validator_1 = require("../../class/validator");
 const reply_1 = require("../../class/reply");
 const service = __importStar(require("./service"));
+const userManager = __importStar(require("../user_manager/service"));
 const name = 'verify';
 exports.name = name;
 const verify = new koa_router_1.default();
@@ -82,7 +83,7 @@ verify.post('/checkAccess', async (ctx) => {
         ctx.throw(412, err.message);
     });
     const userid = payload.id;
-    await global.services.userManager.main
+    await userManager.main
         .getUserById(userid)
         .then((user) => {
         const key = user.hasPermission(body.permissionField);

package/dist/services/user_manager/router.js

@@ -41,6 +41,7 @@ const koa_router_1 = __importDefault(require("koa-router"));
 const validator_1 = require("../../class/validator");
 const reply_1 = require("../../class/reply");
 const service = __importStar(require("./service"));
+const dataProvider = __importStar(require("../data_provider/service"));
 const name = 'user';
 exports.name = name;
 const userManager = new koa_router_1.default();
@@ -183,7 +184,6 @@ userManager.post('/getPermission', async (ctx) => {
         return;
     }
     const query = { _id: body.id };
-    const dataProvider = global.services.dataProvider;
     const permission = await dataProvider
         .getCollection('cms', 'permission')
         .findOne(query)

package/dist/services/user_manager/service.js

@@ -431,11 +431,19 @@ class UserManager {
         if (!this.isCodeValid(id, code)) {
             throw new Error('Invalid verification code');
         }
+        const tempId = this.tempIds[id];
+        const idType = tempId ? tempId.type : 'email';
         const userModel = DataProvider.getCollection('cms', 'auth');
         if (!userModel) {
             throw new Error('User model not found');
         }
-        const query = { email: id };
+        const query = {};
+        if (idType === 'phone') {
+            query.phone = id;
+        }
+        else {
+            query.email = id;
+        }
         // Get from database
         let gottenFromDB;
         try {
@@ -444,20 +452,30 @@ class UserManager {
         catch (error) {
             throw error;
         }
-        if (!gottenFromDB) {
-            throw new Error('User not found');
-        }
         try {
-            // Load user
-            const user = await user_1.User.loadFromModel(gottenFromDB);
-            // Update password
-            user.password = password;
-            // Save to database
-            await user.save();
-            // Get token payload
-            const payload = user.getBrief();
-            // Generate json web token
-            const token = await JWT.main.sign(payload);
+            let token;
+            if (!gottenFromDB) {
+                // Registration flow: create new user
+                const registrationData = {
+                    password,
+                    type: 'user',
+                };
+                if (idType === 'phone') {
+                    registrationData.phone = id;
+                }
+                else {
+                    registrationData.email = id;
+                }
+                token = await this.registerUser(registrationData);
+            }
+            else {
+                // Password reset flow: update existing user
+                const user = await user_1.User.loadFromModel(gottenFromDB);
+                user.password = password;
+                await user.save();
+                const payload = user.getBrief();
+                token = await JWT.main.sign(payload);
+            }
             // Remove temporary ID
             delete this.tempIds[id];
             return token;
@@ -493,11 +511,19 @@ class UserManager {
         if (!this.isCodeValid(id, code)) {
             throw new Error('Invalid verification code');
         }
+        const tempId = this.tempIds[id];
+        const idType = tempId ? tempId.type : 'email';
         const userModel = DataProvider.getCollection('cms', 'auth');
         if (!userModel) {
             throw new Error('User model not found');
         }
-        const query = { email: id };
+        const query = {};
+        if (idType === 'phone') {
+            query.phone = id;
+        }
+        else {
+            query.email = id;
+        }
         // Get from database
         let gottenFromDB;
         try {
@@ -557,8 +583,8 @@ class UserManager {
                 return reject(new Error('User model not found'));
             }
             try {
-                // Create user document
-                const userDoc = await userModel.create({
+                // Create user document with timeout
+                const createPromise = userModel.create({
                     ...detail,
                     type: detail.type || 'user',
                     permissionGroup: detail.permissionGroup || (0, permissionManager_1.getDefaultPermissionGroups)().title,
@@ -566,6 +592,11 @@ class UserManager {
                     email: detail.email || undefined,
                     password: detail.password || undefined,
                 });
+                // Add timeout wrapper to prevent hanging
+                const userDoc = await Promise.race([
+                    createPromise,
+                    new Promise((_, reject) => setTimeout(() => reject(new Error('User creation timeout after 10s')), 10000)),
+                ]);
                 // Load user from document
                 const user = await user_1.User.loadFromModel(userDoc);
                 // Get token payload

package/jest.config.ts

@@ -0,0 +1,18 @@
+import type { Config } from 'jest';
+
+const config: Config = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  roots: ['<rootDir>/tests', '<rootDir>/src'],
+  testMatch: ['**/__tests__/**/*.test.ts', '**/?(*.)+(spec|test).ts'],
+  moduleFileExtensions: ['ts', 'js', 'json'],
+  transform: {
+    '^.+\\.(ts|tsx)$': ['ts-jest', { tsconfig: '<rootDir>/tsconfig.json' }],
+  },
+  setupFilesAfterEnv: ['<rootDir>/tests/setup/jest.setup.ts'],
+  testTimeout: 60000,
+  maxWorkers: 1,
+  verbose: true,
+};
+
+export default config;

package/package.json

@@ -1,13 +1,16 @@
 {
 	"name": "@modular-rest/server",
-	"version": "1.19.0",
+	"version": "1.20.1",
 	"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",
 	"scripts": {
 		"build": "tsc",
 		"dev": "tsc --watch",
-		"test": "echo \"Error: no test specified\" && exit 1",
+		"test": "jest",
+		"test:watch": "jest --watch",
+		"test:router": "jest tests/router --runInBand",
+		"test:coverage": "jest --coverage --runInBand",
 		"play-test": "tsc -p tsconfig.json && node dist/play-test.js",
 		"docs": "typedoc --router kind src/index.ts"
 	},
@@ -44,6 +47,7 @@
 	},
 	"devDependencies": {
 		"@types/bson": "4.2.0",
+		"@types/jest": "30.0.0",
 		"@types/jsonwebtoken": "^9.0.5",
 		"@types/koa": "^2.14.0",
 		"@types/koa-mount": "^4.0.5",
@@ -52,6 +56,11 @@
 		"@types/koa__cors": "^5.0.0",
 		"@types/mongoose": "^5.10.5",
 		"@types/node": "^20.10.0",
+		"jest": "30.2.0",
+		"mongodb-memory-server": "11.0.1",
+		"supertest": "7.1.4",
+		"@types/supertest": "^6.0.2",
+		"ts-jest": "29.4.6",
 		"typedoc": "^0.28.1",
 		"typedoc-plugin-markdown": "^4.6.0",
 		"typedoc-plugin-missing-exports": "^4.0.0",

package/src/application.ts

@@ -203,17 +203,18 @@ export async function createRest(options: RestOptions): Promise<{ app: Koa; serv
         extension: '.js',
       },
     });
+  }
 
-    // 5. Plug in additional defined functions
-    if (config.functions) {
-      Combination.addFunctionsByArray(config.functions);
-    }
+  // 5. Plug in additional defined functions
+  if (config.functions) {
+    Combination.addFunctionsByArray(config.functions);
   }
 
   // 4. Setting up default services
   try {
     await require('./helper/presetup_services').setup(config);
   } catch (e) {
+    console.error(`[createRest] Error in setup:`, e);
     return Promise.reject(e);
   }