@ciscode/authentication-kit 1.1.1 → 1.1.2

package/dist/controllers/password-reset.controller.js

@@ -0,0 +1,146 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PasswordResetController = void 0;
+const common_1 = require("@nestjs/common");
+const node_crypto_1 = require("node:crypto");
+const bcryptjs_1 = __importDefault(require("bcryptjs"));
+const nodemailer_1 = __importDefault(require("nodemailer"));
+const user_model_1 = __importDefault(require("../models/user.model"));
+const client_model_1 = __importDefault(require("../models/client.model"));
+const ACCOUNT_TYPES = ['user', 'client'];
+const isAccountType = (value) => ACCOUNT_TYPES.includes(value);
+const getModel = (type) => (type === 'user' ? user_model_1.default : client_model_1.default);
+let PasswordResetController = class PasswordResetController {
+    async requestPasswordReset(req, res) {
+        try {
+            const { email, type } = req.body;
+            if (!email || !type) {
+                return res.status(400).json({ message: 'Email and type are required.' });
+            }
+            if (!isAccountType(type)) {
+                return res.status(400).json({ message: 'Invalid account type.' });
+            }
+            const Model = getModel(type);
+            const account = await Model.findOne({ email });
+            if (!account) {
+                return res.status(200).json({
+                    message: 'If that email address is in our system, a password reset link has been sent.'
+                });
+            }
+            const token = (0, node_crypto_1.randomBytes)(20).toString('hex');
+            account.resetPasswordToken = token;
+            account.resetPasswordExpires = Date.now() + 3600000;
+            await account.save();
+            const transporter = nodemailer_1.default.createTransport({
+                host: process.env.SMTP_HOST,
+                port: parseInt(process.env.SMTP_PORT, 10),
+                secure: process.env.SMTP_SECURE === 'true',
+                auth: {
+                    user: process.env.SMTP_USER,
+                    pass: process.env.SMTP_PASS
+                }
+            });
+            const resetUrl = `${process.env.FRONTEND_URL}/reset-password?token=${token}&type=${type}`;
+            const mailOptions = {
+                from: process.env.FROM_EMAIL,
+                to: account.email,
+                subject: 'Password Reset',
+                text: `You are receiving this email because you (or someone else) requested a password reset.
+Please click the link below, or paste it into your browser:
+${resetUrl}
+
+If you did not request this, please ignore this email.
+This link will expire in 1 hour.`
+            };
+            await transporter.sendMail(mailOptions);
+            return res.status(200).json({
+                message: 'If that email address is in our system, a password reset link has been sent.'
+            });
+        }
+        catch (error) {
+            console.error('Error in requestPasswordReset:', error);
+            return res.status(500).json({ message: 'Server error', error: error.message });
+        }
+    }
+    async resetPassword(req, res) {
+        try {
+            const { token, newPassword, type } = req.body;
+            if (!token || !newPassword || !type) {
+                return res.status(400).json({ message: 'Token, new password, and type are required.' });
+            }
+            if (!isAccountType(type)) {
+                return res.status(400).json({ message: 'Invalid account type.' });
+            }
+            const Model = getModel(type);
+            const account = await Model.findOne({
+                resetPasswordToken: token,
+                resetPasswordExpires: { $gt: Date.now() }
+            });
+            if (!account) {
+                return res.status(400).json({ message: 'Invalid or expired token.' });
+            }
+            const salt = await bcryptjs_1.default.genSalt(10);
+            account.password = await bcryptjs_1.default.hash(newPassword, salt);
+            account.resetPasswordToken = undefined;
+            account.resetPasswordExpires = undefined;
+            await account.save();
+            return res.status(200).json({ message: 'Password has been reset successfully.' });
+        }
+        catch (error) {
+            console.error('Error in resetPassword:', error);
+            return res.status(500).json({ message: 'Server error', error: error.message });
+        }
+    }
+    forgotPassword(req, res) {
+        return this.requestPasswordReset(req, res);
+    }
+    requestPasswordResetRoute(req, res) {
+        return this.requestPasswordReset(req, res);
+    }
+    resetPasswordRoute(req, res) {
+        return this.resetPassword(req, res);
+    }
+};
+exports.PasswordResetController = PasswordResetController;
+__decorate([
+    (0, common_1.Post)('forgot-password'),
+    __param(0, (0, common_1.Req)()),
+    __param(1, (0, common_1.Res)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", void 0)
+], PasswordResetController.prototype, "forgotPassword", null);
+__decorate([
+    (0, common_1.Post)('request-password-reset'),
+    __param(0, (0, common_1.Req)()),
+    __param(1, (0, common_1.Res)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", void 0)
+], PasswordResetController.prototype, "requestPasswordResetRoute", null);
+__decorate([
+    (0, common_1.Post)('reset-password'),
+    __param(0, (0, common_1.Req)()),
+    __param(1, (0, common_1.Res)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", void 0)
+], PasswordResetController.prototype, "resetPasswordRoute", null);
+exports.PasswordResetController = PasswordResetController = __decorate([
+    (0, common_1.Controller)('api/auth')
+], PasswordResetController);

package/dist/controllers/permissions.controller.d.ts

@@ -0,0 +1,7 @@
+import type { Request, Response } from 'express';
+export declare class PermissionsController {
+    createPermission(req: Request, res: Response): Promise<Response<any, Record<string, any>>>;
+    getPermissions(req: Request, res: Response): Promise<Response<any, Record<string, any>>>;
+    updatePermission(req: Request, res: Response): Promise<Response<any, Record<string, any>>>;
+    deletePermission(req: Request, res: Response): Promise<Response<any, Record<string, any>>>;
+}

package/dist/controllers/permissions.controller.js

@@ -0,0 +1,115 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PermissionsController = void 0;
+const common_1 = require("@nestjs/common");
+const permission_model_1 = __importDefault(require("../models/permission.model"));
+let PermissionsController = class PermissionsController {
+    async createPermission(req, res) {
+        try {
+            const { name, description } = req.body;
+            if (!name) {
+                return res.status(400).json({ message: 'Permission name is required.' });
+            }
+            const newPermission = new permission_model_1.default({ name, description });
+            await newPermission.save();
+            return res.status(201).json(newPermission);
+        }
+        catch (error) {
+            console.error('Error creating permission:', error);
+            return res.status(500).json({ message: 'Server error', error: error.message });
+        }
+    }
+    async getPermissions(req, res) {
+        try {
+            const { page, limit } = req.query;
+            const permissions = await permission_model_1.default.paginate({}, {
+                page: parseInt(page, 10) || 1,
+                limit: parseInt(limit, 10) || 10
+            });
+            return res.status(200).json(permissions);
+        }
+        catch (error) {
+            console.error('Error retrieving permissions:', error);
+            return res.status(500).json({ message: 'Server error', error: error.message });
+        }
+    }
+    async updatePermission(req, res) {
+        try {
+            const { id } = req.params;
+            const updatedPermission = await permission_model_1.default.findByIdAndUpdate(id, req.body, { new: true });
+            if (!updatedPermission) {
+                return res.status(404).json({ message: 'Permission not found.' });
+            }
+            return res.status(200).json(updatedPermission);
+        }
+        catch (error) {
+            console.error('Error updating permission:', error);
+            return res.status(500).json({ message: 'Server error', error: error.message });
+        }
+    }
+    async deletePermission(req, res) {
+        try {
+            const { id } = req.params;
+            const deletedPermission = await permission_model_1.default.findByIdAndDelete(id);
+            if (!deletedPermission) {
+                return res.status(404).json({ message: 'Permission not found.' });
+            }
+            return res.status(200).json({ message: 'Permission deleted successfully.' });
+        }
+        catch (error) {
+            console.error('Error deleting permission:', error);
+            return res.status(500).json({ message: 'Server error', error: error.message });
+        }
+    }
+};
+exports.PermissionsController = PermissionsController;
+__decorate([
+    (0, common_1.Post)('add-permission'),
+    __param(0, (0, common_1.Req)()),
+    __param(1, (0, common_1.Res)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], PermissionsController.prototype, "createPermission", null);
+__decorate([
+    (0, common_1.Get)('get-permission'),
+    __param(0, (0, common_1.Req)()),
+    __param(1, (0, common_1.Res)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], PermissionsController.prototype, "getPermissions", null);
+__decorate([
+    (0, common_1.Put)('update-permission/:id'),
+    __param(0, (0, common_1.Req)()),
+    __param(1, (0, common_1.Res)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], PermissionsController.prototype, "updatePermission", null);
+__decorate([
+    (0, common_1.Delete)('delete-permission/:id'),
+    __param(0, (0, common_1.Req)()),
+    __param(1, (0, common_1.Res)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], PermissionsController.prototype, "deletePermission", null);
+exports.PermissionsController = PermissionsController = __decorate([
+    (0, common_1.Controller)('api/auth/permissions')
+], PermissionsController);

package/dist/controllers/roles.controller.d.ts

@@ -0,0 +1,7 @@
+import type { Request, Response } from 'express';
+export declare class RolesController {
+    createRole(req: Request, res: Response): Promise<Response<any, Record<string, any>>>;
+    getRoles(req: Request, res: Response): Promise<Response<any, Record<string, any>>>;
+    updateRole(req: Request, res: Response): Promise<Response<any, Record<string, any>>>;
+    deleteRole(req: Request, res: Response): Promise<Response<any, Record<string, any>>>;
+}

package/dist/controllers/roles.controller.js

@@ -0,0 +1,113 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RolesController = void 0;
+const common_1 = require("@nestjs/common");
+const role_model_1 = __importDefault(require("../models/role.model"));
+let RolesController = class RolesController {
+    async createRole(req, res) {
+        try {
+            const { tenantId, name, description, permissions } = req.body;
+            if (!tenantId || !name) {
+                return res.status(400).json({ message: 'tenantId and role name are required.' });
+            }
+            const newRole = new role_model_1.default({ tenantId, name, description, permissions });
+            await newRole.save();
+            return res.status(201).json(newRole);
+        }
+        catch (error) {
+            console.error('Error creating role:', error);
+            return res.status(500).json({ message: 'Server error', error: error.message });
+        }
+    }
+    async getRoles(req, res) {
+        try {
+            const { tenantId } = req.params;
+            if (!tenantId) {
+                return res.status(400).json({ message: 'tenantId is required in the URL.' });
+            }
+            const roles = await role_model_1.default.paginate({ tenantId }, { page: 1, limit: 100 });
+            return res.status(200).json(roles);
+        }
+        catch (error) {
+            console.error('Error retrieving roles:', error);
+            return res.status(500).json({ message: 'Server error', error: error.message });
+        }
+    }
+    async updateRole(req, res) {
+        try {
+            const updatedRole = await role_model_1.default.findByIdAndUpdate(req.params.id, req.body, { new: true });
+            if (!updatedRole) {
+                return res.status(404).json({ message: 'Role not found.' });
+            }
+            return res.status(200).json(updatedRole);
+        }
+        catch (error) {
+            console.error('Error updating role:', error);
+            return res.status(500).json({ message: 'Server error', error: error.message });
+        }
+    }
+    async deleteRole(req, res) {
+        try {
+            const deletedRole = await role_model_1.default.findByIdAndDelete(req.params.id);
+            if (!deletedRole) {
+                return res.status(404).json({ message: 'Role not found.' });
+            }
+            return res.status(200).json({ message: 'Role deleted successfully.' });
+        }
+        catch (error) {
+            console.error('Error deleting role:', error);
+            return res.status(500).json({ message: 'Server error', error: error.message });
+        }
+    }
+};
+exports.RolesController = RolesController;
+__decorate([
+    (0, common_1.Post)(),
+    __param(0, (0, common_1.Req)()),
+    __param(1, (0, common_1.Res)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], RolesController.prototype, "createRole", null);
+__decorate([
+    (0, common_1.Get)(':tenantId'),
+    __param(0, (0, common_1.Req)()),
+    __param(1, (0, common_1.Res)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], RolesController.prototype, "getRoles", null);
+__decorate([
+    (0, common_1.Put)(':id'),
+    __param(0, (0, common_1.Req)()),
+    __param(1, (0, common_1.Res)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], RolesController.prototype, "updateRole", null);
+__decorate([
+    (0, common_1.Delete)(':id'),
+    __param(0, (0, common_1.Req)()),
+    __param(1, (0, common_1.Res)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], RolesController.prototype, "deleteRole", null);
+exports.RolesController = RolesController = __decorate([
+    (0, common_1.Controller)('api/auth/roles')
+], RolesController);

package/dist/controllers/users.controller.d.ts

@@ -0,0 +1,8 @@
+import type { Request, Response } from 'express';
+export declare class UsersController {
+    createUser(req: Request, res: Response): Promise<Response<any, Record<string, any>>>;
+    updateUser(req: Request, res: Response): Promise<Response<any, Record<string, any>>>;
+    deleteUser(req: Request, res: Response): Promise<Response<any, Record<string, any>>>;
+    createUserInvitation(req: Request, res: Response): Promise<Response<any, Record<string, any>>>;
+    getAllUsers(req: Request, res: Response): Promise<Response<any, Record<string, any>>>;
+}

package/dist/controllers/users.controller.js

@@ -0,0 +1,259 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UsersController = void 0;
+const common_1 = require("@nestjs/common");
+const user_model_1 = __importDefault(require("../models/user.model"));
+const nodemailer_1 = __importDefault(require("nodemailer"));
+const bcryptjs_1 = __importDefault(require("bcryptjs"));
+const node_crypto_1 = require("node:crypto");
+let UsersController = class UsersController {
+    async createUser(req, res) {
+        try {
+            const { email, password, name, tenantId, microsoftId, roles } = req.body;
+            if (!email) {
+                return res.status(400).json({ message: 'Email is required.' });
+            }
+            if (!tenantId) {
+                return res.status(400).json({ message: 'TenantId is required.' });
+            }
+            if (!microsoftId && !password) {
+                return res.status(400).json({ message: 'Password is required for local login.' });
+            }
+            const existingUser = await user_model_1.default.findOne({ email, tenantId });
+            if (existingUser) {
+                return res.status(400).json({ message: 'User with this email already exists.' });
+            }
+            const salt = await bcryptjs_1.default.genSalt(10);
+            const hashedPassword = password ? await bcryptjs_1.default.hash(password, salt) : undefined;
+            const status = 'pending';
+            const tokenExpiryHours = parseFloat(process.env.EMAIL_TOKEN_EXPIRATION_HOURS || '0') || 24;
+            const tokenExpiration = Date.now() + tokenExpiryHours * 60 * 60 * 1000;
+            const confirmationToken = (0, node_crypto_1.randomBytes)(20).toString('hex');
+            const newUser = new user_model_1.default({
+                email,
+                password: hashedPassword,
+                name,
+                tenantId,
+                microsoftId,
+                roles,
+                status,
+                resetPasswordToken: confirmationToken,
+                resetPasswordExpires: tokenExpiration
+            });
+            await newUser.save();
+            const transporter = nodemailer_1.default.createTransport({
+                host: process.env.SMTP_HOST,
+                port: parseInt(process.env.SMTP_PORT, 10),
+                secure: process.env.SMTP_SECURE === 'true',
+                auth: {
+                    user: process.env.SMTP_USER,
+                    pass: process.env.SMTP_PASS
+                }
+            });
+            const confirmationUrl = `${process.env.FRONTEND_URL}/confirm-email?token=${confirmationToken}&email=${encodeURIComponent(email)}`;
+            const mailOptions = {
+                from: process.env.FROM_EMAIL,
+                to: email,
+                subject: 'Confirm Your Email Address',
+                text: `Hello,
+
+Thank you for registering. Please confirm your account by clicking the link below:
+
+${confirmationUrl}
+
+This link will expire in ${tokenExpiryHours} hour(s).
+
+If you did not initiate this registration, please ignore this email.
+
+Thank you.`
+            };
+            await transporter.sendMail(mailOptions);
+            return res.status(201).json({ message: 'User created and confirmation email sent successfully.', user: newUser });
+        }
+        catch (error) {
+            console.error('Error creating user:', error);
+            return res.status(500).json({ message: 'Server error', error: error.message });
+        }
+    }
+    async updateUser(req, res) {
+        try {
+            const userId = req.params.id;
+            if (req.body.password) {
+                const salt = await bcryptjs_1.default.genSalt(10);
+                req.body.password = await bcryptjs_1.default.hash(req.body.password, salt);
+            }
+            const updatedUser = await user_model_1.default.findByIdAndUpdate(userId, req.body, { new: true });
+            if (!updatedUser) {
+                return res.status(404).json({ message: 'User not found.' });
+            }
+            return res.status(200).json(updatedUser);
+        }
+        catch (error) {
+            console.error('Error updating user:', error);
+            return res.status(500).json({ message: 'Server error', error: error.message });
+        }
+    }
+    async deleteUser(req, res) {
+        try {
+            const userId = req.params.id;
+            const deletedUser = await user_model_1.default.findByIdAndDelete(userId);
+            if (!deletedUser) {
+                return res.status(404).json({ message: 'User not found.' });
+            }
+            return res.status(200).json({ message: 'User deleted successfully.' });
+        }
+        catch (error) {
+            console.error('Error deleting user:', error);
+            return res.status(500).json({ message: 'Server error', error: error.message });
+        }
+    }
+    async createUserInvitation(req, res) {
+        try {
+            const { email, tenantId, name } = req.body;
+            if (!email) {
+                return res.status(400).json({ message: 'Email is required.' });
+            }
+            if (!tenantId) {
+                return res.status(400).json({ message: 'TenantId is required.' });
+            }
+            const existingUser = await user_model_1.default.findOne({ email, tenantId });
+            if (existingUser) {
+                return res.status(400).json({ message: 'User with this email already exists.' });
+            }
+            const token = (0, node_crypto_1.randomBytes)(20).toString('hex');
+            const tokenExpiration = Date.now() + 24 * 60 * 60 * 1000;
+            const newUser = new user_model_1.default({
+                email,
+                tenantId,
+                name,
+                resetPasswordToken: token,
+                resetPasswordExpires: tokenExpiration
+            });
+            await newUser.save();
+            const transporter = nodemailer_1.default.createTransport({
+                host: process.env.SMTP_HOST,
+                port: parseInt(process.env.SMTP_PORT, 10),
+                secure: process.env.SMTP_SECURE === 'true',
+                auth: {
+                    user: process.env.SMTP_USER,
+                    pass: process.env.SMTP_PASS
+                }
+            });
+            const invitationUrl = `${process.env.FRONTEND_URL}/set-password?token=${token}&email=${encodeURIComponent(email)}`;
+            const mailOptions = {
+                from: process.env.FROM_EMAIL,
+                to: email,
+                subject: "You're invited: Set up your password",
+                text: `Hello,
+
+You have been invited to join our platform. Please click on the link below to set your password and complete your registration:
+
+${invitationUrl}
+
+This link will expire in 24 hours. If you did not request this or believe it to be in error, please ignore this email.
+
+Thank you!`
+            };
+            await transporter.sendMail(mailOptions);
+            return res.status(201).json({ message: 'Invitation sent successfully. Please check your email.' });
+        }
+        catch (error) {
+            console.error('Error in createUserInvitation:', error);
+            return res.status(500).json({ message: 'Server error', error: error.message });
+        }
+    }
+    async getAllUsers(req, res) {
+        try {
+            const filter = {};
+            if (req.query.tenantId)
+                filter.tenantId = req.query.tenantId;
+            if (req.query.email)
+                filter.email = req.query.email;
+            const page = Math.max(parseInt(req.query.page, 10) || 1, 1);
+            const limit = Math.min(parseInt(req.query.limit, 10) || 20, 100);
+            const skip = (page - 1) * limit;
+            const [totalItems, users] = await Promise.all([
+                user_model_1.default.countDocuments(filter),
+                user_model_1.default.find(filter)
+                    .populate({ path: 'roles', select: '-__v' })
+                    .skip(skip)
+                    .limit(limit)
+                    .lean()
+            ]);
+            return res.status(200).json({
+                data: users,
+                pagination: {
+                    totalItems,
+                    limit,
+                    totalPages: Math.ceil(totalItems / limit) || 1,
+                    currentPage: page,
+                    hasNextPage: page * limit < totalItems,
+                    hasPrevPage: page > 1
+                }
+            });
+        }
+        catch (error) {
+            console.error('Error fetching users:', error);
+            return res.status(500).json({ message: 'Server error', error: error.message });
+        }
+    }
+};
+exports.UsersController = UsersController;
+__decorate([
+    (0, common_1.Post)(),
+    __param(0, (0, common_1.Req)()),
+    __param(1, (0, common_1.Res)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], UsersController.prototype, "createUser", null);
+__decorate([
+    (0, common_1.Put)(':id'),
+    __param(0, (0, common_1.Req)()),
+    __param(1, (0, common_1.Res)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], UsersController.prototype, "updateUser", null);
+__decorate([
+    (0, common_1.Delete)(':id'),
+    __param(0, (0, common_1.Req)()),
+    __param(1, (0, common_1.Res)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], UsersController.prototype, "deleteUser", null);
+__decorate([
+    (0, common_1.Post)('invite'),
+    __param(0, (0, common_1.Req)()),
+    __param(1, (0, common_1.Res)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], UsersController.prototype, "createUserInvitation", null);
+__decorate([
+    (0, common_1.Get)(),
+    __param(0, (0, common_1.Req)()),
+    __param(1, (0, common_1.Res)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], UsersController.prototype, "getAllUsers", null);
+exports.UsersController = UsersController = __decorate([
+    (0, common_1.Controller)('api/users')
+], UsersController);

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import 'reflect-metadata';
+export { AuthKitModule } from './auth-kit.module';
+export { AuthenticateGuard } from './middleware/authenticate.guard';
+export { AuthGuard } from './middleware/auth.guard';
+export { TenantGuard } from './middleware/tenant.guard';
+export { hasPermission } from './middleware/permission.guard';