@modular-rest/server 1.11.14 → 1.11.15

package/dist/services/user_manager/router.js

@@ -0,0 +1,195 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = exports.name = void 0;
+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 name = 'user';
+exports.name = name;
+const userManager = new koa_router_1.default();
+exports.main = userManager;
+userManager.post('/register_id', async (ctx) => {
+    const body = ctx.request.body;
+    const validateOption = {
+        id: '',
+        idType: 'phone email',
+    };
+    // validate result
+    const bodyValidate = (0, validator_1.validateObject)(body, validateOption);
+    // fields validation
+    if (!bodyValidate.isValid) {
+        ctx.status = 412;
+        ctx.body = (0, reply_1.create)('e', { e: bodyValidate.requires });
+        return;
+    }
+    const serial = service.main.generateVerificationCode(body.id, body.idType);
+    if (serial) {
+        service.main.registerTemporaryID(body.id, body.idType, serial);
+        ctx.body = (0, reply_1.create)('s');
+    }
+    else {
+        ctx.status = 412;
+        ctx.body = (0, reply_1.create)('e', { e: 'Could not generate verification code.' });
+    }
+});
+userManager.post('/validateCode', async (ctx) => {
+    const body = ctx.request.body;
+    // validate result
+    const bodyValidate = (0, validator_1.validateObject)(body, 'id code');
+    // fields validation
+    if (!bodyValidate.isValid) {
+        ctx.status = 412;
+        ctx.body = (0, reply_1.create)('e', { e: bodyValidate.requires });
+        return;
+    }
+    const isValid = service.main.isCodeValid(body.id, body.code);
+    if (!isValid) {
+        ctx.status = 412;
+        ctx.body = (0, reply_1.create)('e', {
+            e: 'Verification code is wrong',
+            isValid: isValid,
+        });
+        return;
+    }
+    ctx.body = (0, reply_1.create)('s', { isValid: isValid });
+});
+userManager.post('/submit_password', async (ctx) => {
+    const body = ctx.request.body;
+    // validate result
+    const bodyValidate = (0, validator_1.validateObject)(body, 'id password code');
+    // fields validation
+    if (!bodyValidate.isValid) {
+        ctx.status = 412;
+        ctx.body = (0, reply_1.create)('e', { e: bodyValidate.requires });
+        return;
+    }
+    try {
+        const userId = await service.main.submitPasswordForTemporaryID(body.id, body.password, body.code);
+        if (userId) {
+            ctx.body = (0, reply_1.create)('s');
+        }
+        else {
+            ctx.status = 412;
+            ctx.body = (0, reply_1.create)('f');
+        }
+    }
+    catch (error) {
+        ctx.status = 412;
+        ctx.body = (0, reply_1.create)('f');
+    }
+});
+userManager.post('/change_password', async (ctx) => {
+    const body = ctx.request.body;
+    // validate result
+    const bodyValidate = (0, validator_1.validateObject)(body, 'id password code');
+    // fields validation
+    if (!bodyValidate.isValid) {
+        ctx.status = 412;
+        ctx.body = (0, reply_1.create)('e', { e: bodyValidate.requires });
+        return;
+    }
+    try {
+        const userId = await service.main.changePasswordForTemporaryID(body.id, body.password, body.code);
+        if (userId) {
+            ctx.body = (0, reply_1.create)('s');
+        }
+        else {
+            ctx.status = 412;
+            ctx.body = (0, reply_1.create)('f');
+        }
+    }
+    catch (error) {
+        ctx.status = 412;
+        ctx.body = (0, reply_1.create)('f');
+    }
+});
+userManager.post('/login', async (ctx) => {
+    const body = ctx.request.body;
+    const validateOption = {
+        id: '',
+        password: '',
+        idType: 'phone email',
+    };
+    // validate result
+    const bodyValidate = (0, validator_1.validateObject)(body, validateOption);
+    // fields validation
+    if (!bodyValidate.isValid) {
+        ctx.status = 412;
+        ctx.body = (0, reply_1.create)('e', { e: bodyValidate.requires });
+        return;
+    }
+    await service.main
+        .loginUser(body.id, body.idType, body.password)
+        .then(token => (ctx.body = (0, reply_1.create)('s', { token: token })))
+        .catch(err => {
+        ctx.status = 412;
+        ctx.body = (0, reply_1.create)('e', { e: err });
+    });
+});
+userManager.get('/loginAnonymous', async (ctx) => {
+    await service.main
+        .loginAnonymous()
+        .then(token => (ctx.body = (0, reply_1.create)('s', { token: token })))
+        .catch(err => {
+        ctx.status = 412;
+        ctx.body = (0, reply_1.create)('e', { e: err });
+    });
+});
+userManager.post('/getPermission', async (ctx) => {
+    const body = ctx.request.body;
+    // validate result
+    const bodyValidate = (0, validator_1.validateObject)(body, 'id');
+    // fields validation
+    if (!bodyValidate.isValid) {
+        ctx.status = 412;
+        ctx.body = (0, reply_1.create)('e', { e: bodyValidate.requires });
+        return;
+    }
+    const query = { _id: body.id };
+    const dataProvider = global.services.dataProvider;
+    const permission = await dataProvider
+        .getCollection('cms', 'permission')
+        .findOne(query)
+        .catch((err) => {
+        ctx.status = 412;
+        ctx.body = (0, reply_1.create)('e', { e: err });
+    });
+    ctx.body = (0, reply_1.create)('s', { permission: permission });
+});

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

@@ -0,0 +1,317 @@
+import { User } from '../../class/user';
+/**
+ * Service name constant
+ * @constant {string}
+ */
+export declare const name = "userManager";
+/**
+ * User registration details
+ * @interface UserRegistrationDetail
+ * @property {string} [permissionGroup] - User's permission group
+ * @property {string} [phone] - User's phone number
+ * @property {string} [email] - User's email address
+ * @property {string} [password] - User's password (base64 encoded)
+ * @property {'user' | 'anonymous'} [type='user'] - User type
+ * @property {any} [key: string] - Additional user properties
+ */
+interface UserRegistrationDetail {
+    permissionGroup?: string;
+    phone?: string;
+    email?: string;
+    password?: string;
+    type?: 'user' | 'anonymous';
+    [key: string]: any;
+}
+/**
+ * User manager class for handling user operations
+
+ * This service provides functionality for managing users, including:
+ * - User registration and authentication
+ * - Password management
+ * - Token generation and verification
+ * - Temporary ID handling for password reset and verification
+ *
+ */
+declare class UserManager {
+    /**
+     * @hidden
+     */
+    private tempIds;
+    /**
+     * @hidden
+     */
+    private verificationCodeGeneratorMethod?;
+    /**
+     * @hidden
+     */
+    constructor();
+    /**
+     * Sets a custom method for generating verification codes
+     * @param {Function} generatorMethod - Function that generates verification codes
+     * @example
+     * ```typescript
+     * import { userManager } from '@modular-rest/server';
+     *
+     * userManager.setCustomVerificationCodeGeneratorMethod((id, type) => {
+     *   return Math.random().toString(36).substring(2, 8).toUpperCase();
+     * });
+     * ```
+     */
+    setCustomVerificationCodeGeneratorMethod(generatorMethod: (id: string, idType: string) => string): void;
+    /**
+     * Generates a verification code for a user
+     * @param {string} id - User ID or identifier
+     * @param {string} idType - Type of ID (email, phone)
+     * @returns {string} Verification code
+     * @example
+     * ```typescript
+     * import { userManager } from '@modular-rest/server';
+     *
+     * const code = userManager.generateVerificationCode('user@example.com', 'email');
+     * // Returns: '123' (default) or custom generated code
+     * ```
+     */
+    generateVerificationCode(id: string, idType: string): string;
+    /**
+     * Gets a user by their ID
+     * @param {string} id - The ID of the user
+     * @returns {Promise<User>} Promise resolving to the user
+     * @throws {Error} If user model is not found or user is not found
+     * @example
+     * ```typescript
+     * import { userManager } from '@modular-rest/server';
+     *
+     * try {
+     *   const user = await userManager.getUserById('user123');
+     *   console.log('User details:', user);
+     * } catch (error) {
+     *   console.error('Failed to get user:', error);
+     * }
+     * ```
+     */
+    getUserById(id: string): Promise<User>;
+    /**
+     * Gets a user by their identity (email or phone)
+     * @param {string} id - The identity of the user
+     * @param {string} idType - The type of the identity (phone or email)
+     * @returns {Promise<User>} Promise resolving to the user
+     * @throws {Error} If user model is not found or user is not found
+     * @example
+     * ```typescript
+     * import { userManager } from '@modular-rest/server';
+     *
+     * // Get user by email
+     * const user = await userManager.getUserByIdentity('user@example.com', 'email');
+     *
+     * // Get user by phone
+     * const user = await userManager.getUserByIdentity('+1234567890', 'phone');
+     * ```
+     */
+    getUserByIdentity(id: string, idType: string): Promise<User>;
+    /**
+     * Gets a user by their JWT token
+     * @param {string} token - The JWT token of the user
+     * @returns {Promise<User>} Promise resolving to the user
+     * @throws {Error} If token is invalid or user is not found
+     * @example
+     * ```typescript
+     * import { userManager } from '@modular-rest/server';
+     *
+     * try {
+     *   const user = await userManager.getUserByToken('jwt.token.here');
+     *   console.log('Authenticated user:', user);
+     * } catch (error) {
+     *   console.error('Invalid token:', error);
+     * }
+     * ```
+     */
+    getUserByToken(token: string): Promise<User>;
+    /**
+     * Checks if a verification code is valid
+     * @param {string} id - The ID of the user
+     * @param {string} code - The verification code
+     * @returns {boolean} Whether the verification code is valid
+     * @example
+     * ```typescript
+     * import { userManager } from '@modular-rest/server';
+     *
+     * const isValid = userManager.isCodeValid('user123', '123');
+     * if (isValid) {
+     *   // Proceed with verification
+     * }
+     * ```
+     */
+    isCodeValid(id: string, code: string): boolean;
+    /**
+     * Logs in a user and returns their JWT token
+     * @param {string} [id=''] - The ID of the user (email or phone)
+     * @param {string} [idType=''] - The type of the ID (phone or email)
+     * @param {string} [password=''] - The password of the user
+     * @returns {Promise<string>} Promise resolving to the JWT token
+     * @throws {Error} If user is not found or credentials are invalid
+     * @example
+     * ```typescript
+     * import { userManager } from '@modular-rest/server';
+     *
+     * try {
+     *   // Login with email
+     *   const token = await userManager.loginUser('user@example.com', 'email', 'password123');
+     *
+     *   // Login with phone
+     *   const token = await userManager.loginUser('+1234567890', 'phone', 'password123');
+     * } catch (error) {
+     *   console.error('Login failed:', error);
+     * }
+     * ```
+     */
+    loginUser(id?: string, idType?: string, password?: string): Promise<string>;
+    /**
+     * Issues a JWT token for a user by email
+     * @param {string} email - The email of the user
+     * @returns {Promise<string>} Promise resolving to the JWT token
+     * @throws {Error} If user is not found
+     * @example
+     * ```typescript
+     * import { userManager } from '@modular-rest/server';
+     *
+     * try {
+     *   const token = await userManager.issueTokenForUser('user@example.com');
+     *   console.log('Issued token:', token);
+     * } catch (error) {
+     *   console.error('Failed to issue token:', error);
+     * }
+     * ```
+     */
+    issueTokenForUser(email: string): Promise<string>;
+    /**
+     * Logs in an anonymous user and returns their JWT token
+     * @returns {Promise<string>} Promise resolving to the JWT token
+     * @example
+     * ```typescript
+     * import { userManager } from '@modular-rest/server';
+     *
+     * const token = await userManager.loginAnonymous();
+     * console.log('Anonymous token:', token);
+     * ```
+     */
+    loginAnonymous(): Promise<string>;
+    /**
+     * Registers a temporary ID for verification or password reset
+     * @param {string} id - The ID to register
+     * @param {string} type - The type of temporary ID
+     * @param {string} code - The verification code
+     * @returns {string} The registered ID
+     * @example
+     * ```typescript
+     * import { userManager } from '@modular-rest/server';
+     *
+     * const tempId = userManager.registerTemporaryID('user@example.com', 'password_reset', '123456');
+     * ```
+     */
+    registerTemporaryID(id: string, type: string, code: string): string;
+    /**
+     * Submits a password for a temporary ID
+     * @param {string} id - The temporary ID
+     * @param {string} password - The new password
+     * @param {string} code - The verification code
+     * @returns {Promise<string>} Promise resolving to the JWT token
+     * @throws {Error} If verification code is invalid or user is not found
+     * @example
+     * ```typescript
+     * import { userManager } from '@modular-rest/server';
+     *
+     * try {
+     *   const token = await userManager.submitPasswordForTemporaryID(
+     *     'user@example.com',
+     *     'newpassword123',
+     *     '123456'
+     *   );
+     *   console.log('Password set successfully');
+     * } catch (error) {
+     *   console.error('Failed to set password:', error);
+     * }
+     * ```
+     */
+    submitPasswordForTemporaryID(id: string, password: string, code: string): Promise<string>;
+    /**
+     * Changes password for a temporary ID
+     * @param {string} id - The temporary ID
+     * @param {string} password - The new password
+     * @param {string} code - The verification code
+     * @returns {Promise<string>} Promise resolving to the JWT token
+     * @throws {Error} If verification code is invalid or user is not found
+     * @example
+     * ```typescript
+     * import { userManager } from '@modular-rest/server';
+     *
+     * try {
+     *   const token = await userManager.changePasswordForTemporaryID(
+     *     'user@example.com',
+     *     'newpassword123',
+     *     '123456'
+     *   );
+     *   console.log('Password changed successfully');
+     * } catch (error) {
+     *   console.error('Failed to change password:', error);
+     * }
+     * ```
+     */
+    changePasswordForTemporaryID(id: string, password: string, code: string): Promise<string>;
+    /**
+     * Registers a new user
+     * @param {UserRegistrationDetail} detail - User registration details
+     * @returns {Promise<string>} Promise resolving to the JWT token
+     * @throws {Error} If user model is not found or registration fails
+     * @example
+     * ```typescript
+     * import { userManager } from '@modular-rest/server';
+     *
+     * try {
+     *   const token = await userManager.registerUser({
+     *     email: 'user@example.com',
+     *     password: 'secure123',
+     *     permissionGroup: 'user',
+     *     phone: '+1234567890'
+     *   });
+     *   console.log('User registered successfully');
+     * } catch (error) {
+     *   console.error('Registration failed:', error);
+     * }
+     * ```
+     */
+    registerUser(detail: UserRegistrationDetail): Promise<string>;
+    /**
+     * Changes a user's password
+     * @param {Record<string, any>} query - Query to find the user
+     * @param {string} newPass - The new password
+     * @returns {Promise<void>} Promise resolving when password is changed
+     * @throws {Error} If user is not found or password change fails
+     * @example
+     * ```typescript
+     * import { userManager } from '@modular-rest/server';
+     *
+     * try {
+     *   await userManager.changePassword(
+     *     { email: 'user@example.com' },
+     *     'newpassword123'
+     *   );
+     *   console.log('Password changed successfully');
+     * } catch (error) {
+     *   console.error('Failed to change password:', error);
+     * }
+     * ```
+     */
+    changePassword(query: Record<string, any>, newPass: string): Promise<void>;
+    /**
+     * Gets the singleton instance of UserManager
+     * @returns {UserManager} The UserManager instance
+     * @hidden
+     */
+    static get instance(): UserManager;
+}
+/**
+ * Main user manager instance
+ * @constant {UserManager}
+ */
+export declare const main: UserManager;
+export {};