@modular-rest/server 1.18.1 → 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/collection_definition.d.ts

@@ -1,6 +1,7 @@
-import { Schema } from 'mongoose';
+import { Schema, Model } from 'mongoose';
 import { Permission } from './security';
 import { DatabaseTrigger } from './database_trigger';
+import { MongoOption } from '../services/data_provider/service';
 /**
  * Configuration options for creating a collection definition.
  * This interface defines the structure for configuring MongoDB collections with their associated
@@ -24,6 +25,11 @@ 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;
 }
 /**
  * To have define any collection in your database you haveto use below method in your `db.[js|ts]` file and export an array of CollectionDefinition instances.
@@ -31,7 +37,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
  *
@@ -48,9 +54,16 @@ interface CollectionDefinitionOptions {
  *     // trigger: DatabaseTrigger[]
  *   })
  * ]
+ *
+ * // Access the model directly:
+ * const userCollection = defineCollection({...});
+ * const UserModel = userCollection.model;
+ * const users = await UserModel.find();
  * ```
  */
-export declare function defineCollection(options: CollectionDefinitionOptions): CollectionDefinition;
+export declare function defineCollection(options: CollectionDefinitionOptions): CollectionDefinition & {
+    model: Model<any>;
+};
 /**
  * A class that represents a MongoDB collection configuration. Provides full support for schema validation, access control through permissions,
  * and custom triggers for various database operations.
@@ -99,6 +112,8 @@ export declare class CollectionDefinition {
     permissions: Permission[];
     /** @readonly Optional database triggers */
     triggers?: DatabaseTrigger[];
+    /** Optional mongoose model for this collection */
+    private _model;
     /**
      * Creates a new CollectionDefinition instance
      *
@@ -108,5 +123,15 @@ export declare class CollectionDefinition {
      * @beta
      */
     constructor({ database, collection, schema, permissions, triggers, }: CollectionDefinitionOptions);
+    /**
+     * Get the mongoose model for this collection
+     * @returns {Model<any> | null} The mongoose model or null if not set
+     */
+    getModel(): Model<any> | null;
+    /**
+     * Set the mongoose model for this collection
+     * @param {Model<any>} model - The mongoose model
+     */
+    setModel(model: Model<any>): void;
 }
 export {};

package/dist/class/collection_definition.js

@@ -1,14 +1,19 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CollectionDefinition = void 0;
 exports.defineCollection = defineCollection;
+const model_registry_1 = __importDefault(require("../services/data_provider/model_registry"));
+const config_1 = require("../config");
 /**
  * To have define any collection in your database you haveto use below method in your `db.[js|ts]` file and export an array of CollectionDefinition instances.
  *
  * @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
  *
@@ -25,10 +30,59 @@ exports.defineCollection = defineCollection;
  *     // trigger: DatabaseTrigger[]
  *   })
  * ]
+ *
+ * // Access the model directly:
+ * const userCollection = defineCollection({...});
+ * const UserModel = userCollection.model;
+ * const users = await UserModel.find();
  * ```
  */
 function defineCollection(options) {
-    return new CollectionDefinition(options);
+    const definition = new CollectionDefinition(options);
+    // Try to get mongoOption from options or config
+    let mongoOption = options.mongoOption;
+    if (!mongoOption && config_1.config.mongo) {
+        mongoOption = config_1.config.mongo;
+    }
+    // If mongoOption is available, register the collection and create the model
+    if (mongoOption) {
+        const model = model_registry_1.default.registerCollection(definition, mongoOption);
+        definition.setModel(model);
+    }
+    // Create a proxy object that includes both CollectionDefinition properties and model
+    const result = definition;
+    // 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 = model_registry_1.default.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;
+            if (!currentMongoOption && config_1.config.mongo) {
+                currentMongoOption = config_1.config.mongo;
+            }
+            if (currentMongoOption) {
+                const newModel = model_registry_1.default.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;
 }
 /**
  * A class that represents a MongoDB collection configuration. Provides full support for schema validation, access control through permissions,
@@ -77,11 +131,27 @@ class CollectionDefinition {
      * @beta
      */
     constructor({ database, collection, schema, permissions, triggers, }) {
+        /** Optional mongoose model for this collection */
+        this._model = null;
         this.database = database;
         this.collection = collection;
         this.schema = schema;
         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() {
+        return this._model;
+    }
+    /**
+     * Set the mongoose model for this collection
+     * @param {Model<any>} model - The mongoose model
+     */
+    setModel(model) {
+        this._model = model;
+    }
 }
 exports.CollectionDefinition = CollectionDefinition;

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/index.d.ts

@@ -40,7 +40,7 @@ export { createRest };
  *   ],
  *   uploadDirectoryConfig: {
  *     directory: './uploads',
-   *     urlPath: '/assets'
+ *     urlPath: '/assets'
  *   }
  * };
  * ```
@@ -118,6 +118,17 @@ export { paginator };
  * @description Database collection access utilities
  */
 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

package/dist/index.js

@@ -36,7 +36,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.userManager = exports.middleware = exports.fileService = exports.getCollection = exports.paginator = exports.reply = exports.validator = exports.TypeCasters = exports.defineFunction = exports.AccessTypes = exports.PermissionGroup = exports.PermissionTypes = exports.Permission = exports.AccessDefinition = exports.CmsTrigger = exports.DatabaseTrigger = exports.Schema = exports.schemas = exports.defineCollection = exports.CollectionDefinition = exports.createRest = void 0;
+exports.userManager = exports.middleware = exports.fileService = exports.modelRegistry = exports.getCollection = exports.paginator = exports.reply = exports.validator = exports.TypeCasters = exports.defineFunction = exports.AccessTypes = exports.PermissionGroup = exports.PermissionTypes = exports.Permission = exports.AccessDefinition = exports.CmsTrigger = exports.DatabaseTrigger = exports.Schema = exports.schemas = exports.defineCollection = exports.CollectionDefinition = exports.createRest = void 0;
 // Application
 const application_1 = require("./application");
 Object.defineProperty(exports, "createRest", { enumerable: true, get: function () { return application_1.createRest; } });
@@ -77,3 +77,15 @@ Object.defineProperty(exports, "PermissionGroup", { enumerable: true, get: funct
 Object.defineProperty(exports, "AccessTypes", { enumerable: true, get: function () { return security_1.AccessTypes; } });
 const middleware = __importStar(require("./middlewares"));
 exports.middleware = middleware;
+/**
+ * @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');
+ * ```
+ */
+var model_registry_1 = require("./services/data_provider/model_registry");
+Object.defineProperty(exports, "modelRegistry", { enumerable: true, get: function () { return model_registry_1.modelRegistry; } });

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

@@ -0,0 +1,72 @@
+import { 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
+ */
+declare class ModelRegistry {
+    private static instance;
+    private connections;
+    private models;
+    private collectionDefinitions;
+    private mongoOption;
+    private constructor();
+    /**
+     * Get the singleton instance of ModelRegistry
+     * @returns {ModelRegistry} The singleton instance
+     */
+    static getInstance(): ModelRegistry;
+    /**
+     * 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>;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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
+     */
+    initializeConnections(mongoOption: MongoOption): Promise<void>;
+    /**
+     * Get all registered collection definitions
+     * @returns {CollectionDefinition[]} Array of collection definitions
+     */
+    getCollectionDefinitions(): CollectionDefinition[];
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;