@modular-rest/server 1.11.14 → 1.11.15

package/dist/class/user.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.User = void 0;
+const config_1 = require("../config");
+const validator_1 = require("./validator");
+/**
+ * User class representing a user in the system
+ *
+ * @public
+ */
+class User {
+    /**
+     * Create a user
+     * @param id - User ID
+     * @param permissionGroup - Permission group name
+     * @param phone - User phone
+     * @param email - User email
+     * @param password - User password
+     * @param type - User type
+     * @param model - Database model
+     *
+     * @hidden
+     */
+    constructor(id, permissionGroup, phone, email, password, type, model) {
+        this.id = id;
+        this.permissionGroup = permissionGroup;
+        this.email = email;
+        this.phone = phone;
+        this.password = password;
+        this.type = type;
+        this.dbModel = model;
+    }
+    /**
+     * Get brief user information
+     * @returns Brief user info object
+     */
+    getBrief() {
+        const permissionGroup = config_1.config.permissionGroups?.find(group => group.title === this.permissionGroup);
+        if (!permissionGroup) {
+            throw new Error('Permission group not found on user object');
+        }
+        const brief = {
+            id: this.id,
+            permissionGroup: permissionGroup,
+            phone: this.phone,
+            email: this.email,
+            type: this.type,
+        };
+        return brief;
+    }
+    /**
+     * Update user details
+     * @param detail - Object containing user details to update
+     */
+    setNewDetail(detail) {
+        if (detail.phone)
+            this.phone = detail.phone;
+        if (detail.email)
+            this.email = detail.email;
+        if (detail.password)
+            this.password = detail.password;
+    }
+    /**
+     * Check if user has a specific permission
+     * @param accessType - Permission to check
+     * @returns True if user has permission, false otherwise
+     */
+    hasPermission(accessType) {
+        const permissionGroup = config_1.config.permissionGroups?.find(group => group.title === this.permissionGroup);
+        if (permissionGroup == null)
+            return false;
+        let key = false;
+        if (permissionGroup.allowedAccessTypes) {
+            for (let i = 0; i < permissionGroup.allowedAccessTypes.length; i++) {
+                const userPermissionType = permissionGroup.allowedAccessTypes[i];
+                if (userPermissionType === accessType) {
+                    key = true;
+                    break;
+                }
+            }
+        }
+        return key;
+    }
+    /**
+     * Save user to database
+     */
+    async save() {
+        if (!this.dbModel) {
+            throw new Error('User model is not initialized');
+        }
+        this.dbModel['permissionGroup'] = this.permissionGroup;
+        this.dbModel['phone'] = this.phone;
+        this.dbModel['email'] = this.email;
+        this.dbModel['password'] = this.password;
+        await this.dbModel.save();
+    }
+    /**
+     * Load user from database model
+     * @param model - Database model
+     * @returns Promise resolving to User instance
+     */
+    static loadFromModel(model) {
+        return new Promise((done, reject) => {
+            // check required fields
+            const isValidData = (0, validator_1.validator)(model, '_id permissionGroup');
+            if (!isValidData.isValid) {
+                return reject(User.notValid(model));
+            }
+            const id = model.id;
+            const permissionGroup = model.permissionGroup;
+            const phone = model.phone;
+            const email = model.email;
+            const password = model.password;
+            const type = model.type;
+            //create user
+            const newUser = new User(id, permissionGroup, phone, email, password, type, model);
+            done(newUser);
+        });
+    }
+    /**
+     * Create user from model and details
+     * @param model - Mongoose model
+     * @param detail - User details
+     * @returns Promise resolving to User instance
+     */
+    static createFromModel(model, detail) {
+        return new Promise(async (done, reject) => {
+            //create user
+            try {
+                const newUserDoc = await new model(detail).save();
+                const newUser = await User.loadFromModel(newUserDoc);
+                done(newUser);
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    /**
+     * Create error for invalid user
+     * @param object - Invalid user object
+     * @returns Error message
+     */
+    static notValid(object) {
+        const error = `user detail are not valid ${JSON.stringify(object)}`;
+        console.error(error);
+        return error;
+    }
+}
+exports.User = User;
+exports.default = User;

package/dist/class/validator.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Validation result interface
+ */
+export interface ValidationResult {
+    isValid: boolean;
+    requires: string[];
+}
+/**
+ * Validates an object by checking if it contains all the required fields.
+ * @param obj - The object to be validated.
+ * @param requiredFields - The list of required fields. If it's a string, it should contain keys separated by spaces. If it's an object, it should contain key-value pairs where the key is the field name and the value is a boolean indicating whether the field is required or not.
+ * @returns Returns a ValidationResult object with validation status and missing fields.
+ * @throws Throws an error if the requiredFields parameter is not a string or an object.
+ */
+export declare function validator(obj: Record<string, any> | null, requiredFields: string | Record<string, string>): ValidationResult;
+/**
+ * Return the validator function to maintain compatibility with the JavaScript version
+ */
+export declare const validateObject: typeof validator;

package/dist/class/validator.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateObject = void 0;
+exports.validator = validator;
+/**
+ * Validates an object by checking if it contains all the required fields.
+ * @param obj - The object to be validated.
+ * @param requiredFields - The list of required fields. If it's a string, it should contain keys separated by spaces. If it's an object, it should contain key-value pairs where the key is the field name and the value is a boolean indicating whether the field is required or not.
+ * @returns Returns a ValidationResult object with validation status and missing fields.
+ * @throws Throws an error if the requiredFields parameter is not a string or an object.
+ */
+function validator(obj, requiredFields) {
+    /*
+        this method could validate an Object by given field's name list and return bool.
+        - requiredFields: is a string that contains keys being spared by " ".
+    */
+    const type = typeof requiredFields;
+    let result;
+    if (type === 'string')
+        result = checkSimple(obj, requiredFields);
+    else if (type === 'object')
+        result = checkComplex(obj, requiredFields);
+    else
+        throw 'requiredFields has wrong form, it must be string or object';
+    return result;
+}
+/**
+ * Check simple validation with space-separated string of keys
+ */
+function checkSimple(obj, requiredFields = '') {
+    let isValid = false;
+    const requires = requiredFields.split(' ');
+    const validMembers = [];
+    const notValidKeys = [];
+    // return if obj is null
+    if (obj == null)
+        return _returnResult(isValid, requires);
+    // Filter empty strings that might result from extra spaces
+    const requiredKeys = requires.filter(key => key !== '');
+    for (const key of requiredKeys) {
+        if (obj[key] !== undefined && obj[key] !== null)
+            validMembers.push(key);
+        else
+            notValidKeys.push(key);
+    }
+    // check validation
+    isValid = requiredKeys.length === validMembers.length;
+    return _returnResult(isValid, notValidKeys);
+}
+/**
+ * Check complex validation with object containing expected values
+ */
+function checkComplex(obj, requiredFields = {}) {
+    let isValid = false;
+    const requireKeys = Object.keys(requiredFields);
+    let validMembers = 0;
+    const notValidKeys = [];
+    // return if obj is null
+    if (obj == null)
+        return _returnResult(isValid, requireKeys);
+    for (let i = 0; i < requireKeys.length; i++) {
+        const key = requireKeys[i];
+        let isValidField = false;
+        // if field has specific values
+        if (requiredFields[key].length > 0) {
+            const expectedValues = requiredFields[key].split(' ');
+            if (typeof expectedValues !== 'object')
+                throw `${key} must be array of strings`;
+            for (const value of expectedValues) {
+                if (obj[key] === value) {
+                    isValidField = true;
+                    break;
+                }
+            }
+        }
+        // else does not have specific value
+        else if (obj[key] != null) {
+            isValidField = true;
+        }
+        if (isValidField)
+            validMembers++;
+        else
+            notValidKeys.push(key);
+    }
+    // check validation
+    isValid = requireKeys.length === validMembers;
+    return _returnResult(isValid, notValidKeys);
+}
+/**
+ * Create a validation result object
+ */
+function _returnResult(isValid, notValidKeys) {
+    return {
+        isValid: isValid,
+        requires: notValidKeys,
+    };
+}
+/**
+ * Return the validator function to maintain compatibility with the JavaScript version
+ */
+exports.validateObject = validator;

package/dist/config.d.ts

@@ -0,0 +1,113 @@
+import Koa from 'koa';
+import { CollectionDefinition } from './class/collection_definition';
+import { PermissionGroup } from './class/security';
+import { CmsTrigger } from './class/cms_trigger';
+import { DefinedFunction } from './services/functions/service';
+import { Options as KoaCorsOptions } from '@koa/cors';
+import { Options as KoaStaticOptionsBase } from 'koa-static';
+/**
+ * The options for the static file server, it's a combination of modular-rest and [koa-static options](https://github.com/koajs/static?tab=readme-ov-file#options)
+ */
+export type StaticPathOptions = KoaStaticOptionsBase & {
+    /**
+     * The actual path of the static files on your server
+     */
+    actualPath: string;
+    /**
+     * The path you want to serve the static files from
+     */
+    path: string;
+};
+/**
+ * JWT keypair configuration
+ * @interface KeyPair
+ * @property {string} private - Private key for JWT signing
+ * @property {string} public - Public key for JWT verification
+ */
+interface KeyPair {
+    private: string;
+    public: string;
+}
+/**
+ * MongoDB connection options
+ * @interface MongoOptions
+ * @property {string} dbPrefix - Prefix for database names
+ * @property {string} mongoBaseAddress - MongoDB connection URL
+ */
+interface MongoOptions {
+    dbPrefix: string;
+    mongoBaseAddress: string;
+}
+/**
+ * Admin user configuration
+ * @interface AdminUser
+ * @property {string} email - Admin user email
+ * @property {string} password - Admin user password
+ */
+interface AdminUser {
+    email: string;
+    password: string;
+}
+/**
+ * Configuration options for creating a REST API instance
+ * @interface RestOptions
+ * @property {KoaCorsOptions} [cors] - CORS configuration [options](https://github.com/koajs/cors?tab=readme-ov-file#corsoptions)
+ * @property {string} [modulesPath] - Path to custom modules directory
+ * @property {string} [uploadDirectory] - Directory for file uploads
+ * @property {any} [koaBodyOptions] - Options for koa-body middleware
+ * @property {StaticPathOptions} [staticPath] - Static file serving options
+ * @property {Function} [onBeforeInit] - Hook called before initialization
+ * @property {Function} [onAfterInit] - Hook called after initialization
+ * @property {number} [port] - Port to listen on
+ * @property {boolean} [dontListen] - Don't start the server
+ * @property {MongoOptions} [mongo] - MongoDB connection options
+ * @property {Object} [keypair] - JWT keypair for authentication
+ * @property {AdminUser} [adminUser] - Admin user configuration
+ * @property {Function} [verificationCodeGeneratorMethod] - Custom verification code generator
+ * @property {CollectionDefinition[]} [collectionDefinitions] - Custom collection definitions
+ * @property {PermissionGroup[]} [permissionGroups] - Custom permission groups
+ * @property {CmsTrigger[]} [authTriggers] - Authentication triggers
+ * @property {CmsTrigger[]} [fileTriggers] - File handling triggers
+ * @property {DefinedFunction[]} [functions] - Custom API functions
+ */
+export interface RestOptions {
+    cors?: KoaCorsOptions;
+    modulesPath?: string;
+    uploadDirectory?: string;
+    koaBodyOptions?: any;
+    staticPath?: StaticPathOptions;
+    onBeforeInit?: (koaApp: Koa) => void;
+    onAfterInit?: (koaApp: Koa) => void;
+    port?: number;
+    dontListen?: boolean;
+    mongo?: MongoOptions;
+    keypair?: KeyPair;
+    adminUser?: AdminUser;
+    verificationCodeGeneratorMethod?: () => string;
+    collectionDefinitions?: CollectionDefinition[];
+    permissionGroups?: PermissionGroup[];
+    authTriggers?: CmsTrigger[];
+    fileTriggers?: CmsTrigger[];
+    functions?: DefinedFunction[];
+}
+/**
+ * Global configuration object
+ * @type {RestOptions}
+ */
+export declare const config: RestOptions;
+/**
+ * Updates the global configuration with new options
+ * @param {RestOptions} options - New configuration options to merge
+ * @example
+ * ```typescript
+ * setConfig({
+ *   port: 3000,
+ *   mongo: {
+ *     mongoBaseAddress: 'mongodb://localhost:27017',
+ *     dbPrefix: 'myapp_'
+ *   }
+ * });
+ * ```
+ */
+export declare function setConfig(options: RestOptions): void;
+export {};

package/dist/config.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+exports.setConfig = setConfig;
+/**
+ * Global configuration object
+ * @type {RestOptions}
+ */
+exports.config = {};
+/**
+ * Updates the global configuration with new options
+ * @param {RestOptions} options - New configuration options to merge
+ * @example
+ * ```typescript
+ * setConfig({
+ *   port: 3000,
+ *   mongo: {
+ *     mongoBaseAddress: 'mongodb://localhost:27017',
+ *     dbPrefix: 'myapp_'
+ *   }
+ * });
+ * ```
+ */
+function setConfig(options) {
+    Object.assign(exports.config, options);
+}

package/dist/defult-permissions.d.ts

@@ -0,0 +1,2 @@
+import { PermissionGroup } from './class/security';
+export declare const permissionGroups: PermissionGroup[];

package/dist/defult-permissions.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.permissionGroups = void 0;
+const security_1 = require("./class/security");
+exports.permissionGroups = [
+    new security_1.PermissionGroup({
+        title: 'anonymous',
+        isAnonymous: true,
+        allowedAccessTypes: ['anonymous_access'],
+    }),
+    new security_1.PermissionGroup({
+        title: 'end-user',
+        isDefault: true,
+        allowedAccessTypes: [
+            'user_access',
+            'anonymous_access',
+            'upload_file_access',
+            'remove_file_access',
+        ],
+    }),
+    new security_1.PermissionGroup({
+        title: 'administrator',
+        allowedAccessTypes: [
+            'user_access',
+            'anonymous_access',
+            'upload_file_access',
+            'remove_file_access',
+            'advanced_settings',
+        ],
+    }),
+];

package/dist/events.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Supported event types:
+ * - onBeforeInit: (koaApp: Koa) => void; // A callback called before initializing the Koa server.
+ * - onAfterInit: (koaApp: Koa) => void; // A callback called after server initialization.
+ * - onNewUser: (user: any) => void; // A callback called when a new user is created.
+ *
+ * @param event - The event name to register
+ * @param callback - The callback function to be called when the event is triggered
+ * @throws Error if event is not a string or callback is not a function
+ */
+export declare function registerEventCallback(event: string, callback: (...args: any[]) => void): void;
+/**
+ * Get all registered callbacks for a specific event
+ * @param event - The event name to get callbacks for
+ * @returns Array of callbacks registered for the event
+ */
+export declare function getEventCallbacks(event: string): ((...args: any[]) => void)[];
+/**
+ * Trigger an event with arguments
+ * @param event - The event name to trigger
+ * @param args - Arguments to pass to the callback functions
+ */
+export declare function triggerEvent(event: string, ...args: any[]): void;

package/dist/events.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerEventCallback = registerEventCallback;
+exports.getEventCallbacks = getEventCallbacks;
+exports.triggerEvent = triggerEvent;
+/**
+ * Array to store all registered event callbacks
+ */
+const eventCallbacks = [];
+/**
+ * Supported event types:
+ * - onBeforeInit: (koaApp: Koa) => void; // A callback called before initializing the Koa server.
+ * - onAfterInit: (koaApp: Koa) => void; // A callback called after server initialization.
+ * - onNewUser: (user: any) => void; // A callback called when a new user is created.
+ *
+ * @param event - The event name to register
+ * @param callback - The callback function to be called when the event is triggered
+ * @throws Error if event is not a string or callback is not a function
+ */
+function registerEventCallback(event, callback) {
+    if (typeof event !== "string")
+        throw new Error("Event must be a string");
+    if (typeof callback !== "function")
+        throw new Error("Callback must be a function");
+    eventCallbacks.push({ event, callback });
+}
+/**
+ * Get all registered callbacks for a specific event
+ * @param event - The event name to get callbacks for
+ * @returns Array of callbacks registered for the event
+ */
+function getEventCallbacks(event) {
+    return eventCallbacks
+        .filter((cb) => cb.event === event)
+        .map((cb) => cb.callback);
+}
+/**
+ * Trigger an event with arguments
+ * @param event - The event name to trigger
+ * @param args - Arguments to pass to the callback functions
+ */
+function triggerEvent(event, ...args) {
+    const callbacks = getEventCallbacks(event);
+    for (const callback of callbacks) {
+        callback(...args);
+    }
+}

package/dist/helper/data_insertion.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Admin user credentials interface
+ * @interface AdminCredentials
+ * @property {string} email - Admin user email address
+ * @property {string} password - Admin user password
+ */
+interface AdminCredentials {
+    email: string;
+    password: string;
+}
+/**
+ * Creates default system users if they don't exist
+ * @function createAdminUser
+ * @param {AdminCredentials} credentials - Admin user credentials
+ * @returns {Promise<void>} A promise that resolves when the operation is complete
+ * @throws {Error} If admin credentials are invalid or if the operation fails
+ * @description
+ * This function performs the following operations:
+ * 1. Checks if an anonymous user exists, creates one if it doesn't
+ * 2. Checks if an administrator user exists, creates one if it doesn't
+ * 3. Uses the provided credentials for the administrator user
+ *
+ * @example
+ * ```typescript
+ * // Create default system users
+ * await createAdminUser({
+ *   email: 'admin@example.com',
+ *   password: 'secure-password'
+ * });
+ *
+ * // The function will:
+ * // 1. Create an anonymous user if it doesn't exist
+ * // 2. Create an admin user with the provided credentials if it doesn't exist
+ * // 3. Do nothing if both users already exist
+ * ```
+ */
+export declare function createAdminUser({ email, password }: AdminCredentials): Promise<void>;
+export {};

package/dist/helper/data_insertion.js

@@ -0,0 +1,110 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAdminUser = createAdminUser;
+const DataProvider = __importStar(require("../services/data_provider/service"));
+const permissionManager_1 = require("../services/user_manager/permissionManager");
+const userManager = __importStar(require("../services/user_manager/service"));
+/**
+ * Creates default system users if they don't exist
+ * @function createAdminUser
+ * @param {AdminCredentials} credentials - Admin user credentials
+ * @returns {Promise<void>} A promise that resolves when the operation is complete
+ * @throws {Error} If admin credentials are invalid or if the operation fails
+ * @description
+ * This function performs the following operations:
+ * 1. Checks if an anonymous user exists, creates one if it doesn't
+ * 2. Checks if an administrator user exists, creates one if it doesn't
+ * 3. Uses the provided credentials for the administrator user
+ *
+ * @example
+ * ```typescript
+ * // Create default system users
+ * await createAdminUser({
+ *   email: 'admin@example.com',
+ *   password: 'secure-password'
+ * });
+ *
+ * // The function will:
+ * // 1. Create an anonymous user if it doesn't exist
+ * // 2. Create an admin user with the provided credentials if it doesn't exist
+ * // 3. Do nothing if both users already exist
+ * ```
+ */
+async function createAdminUser({ email, password }) {
+    const authModel = DataProvider.getCollection('cms', 'auth');
+    try {
+        const isAnonymousExisted = await authModel.countDocuments({ type: 'anonymous' }).exec();
+        const isAdministratorExisted = await authModel
+            .countDocuments({ type: 'user', email: email })
+            .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();
+        }
+        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',
+            });
+            // await new authModel({
+            //   permission: getDefaultAdministratorPermissionGroup().title,
+            //   email: email,
+            //   password: password,
+            //   type: "user",
+            // }).save();
+        }
+    }
+    catch (e) {
+        return Promise.reject(e);
+    }
+}