@organizasyon/meeting-nanaman-app-backend 1.0.0

package/dist/jobs/mailer/templates/index.js

@@ -0,0 +1,17 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./auth"), exports);

package/dist/jobs/queues/index.d.ts

@@ -0,0 +1,3 @@
+export declare const processEmailQueue: () => Promise<void>;
+export declare const processPasswordResetQueue: () => Promise<void>;
+export declare const addToQueue: (type: string, data: any) => Promise<void>;

package/dist/jobs/queues/index.js

@@ -0,0 +1,115 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addToQueue = exports.processPasswordResetQueue = exports.processEmailQueue = void 0;
+const ioredis_1 = __importDefault(require("ioredis"));
+const mailer_1 = require("../mailer");
+const queues_1 = __importDefault(require("../../models/queues"));
+const redis = new ioredis_1.default({
+    host: process.env.REDIS_HOST || 'localhost',
+    port: Number(process.env.REDIS_PORT) || 6379,
+    password: process.env.REDIS_PASSWORD,
+    db: 0,
+});
+const processEmailQueue = async () => {
+    try {
+        const pendingEmails = await queues_1.default.find({
+            type: 'email',
+            status: 'pending',
+            deleted_at: null
+        })
+            .sort({ created_at: 1 })
+            .limit(10)
+            .lean()
+            .exec();
+        for (const emailJob of pendingEmails) {
+            try {
+                const { data } = emailJob;
+                if (data.action === 'password_changed') {
+                    await (0, mailer_1.sendPasswordChangedEmail)(data.email, data.name);
+                }
+                else if (data.action === 'passkey_registered') {
+                    await (0, mailer_1.sendPasskeyRegisteredEmail)(data.email, data.name, data.device_name || 'Unknown Device');
+                }
+                // Update queue status
+                await queues_1.default.updateOne({ _id: emailJob._id }, {
+                    status: 'completed',
+                    processed_at: Date.now(),
+                    updated_at: Date.now()
+                });
+                console.log(`Email sent successfully to ${data.email}`);
+            }
+            catch (error) {
+                console.error(`Failed to send email to ${emailJob.data.email}:`, error);
+                // Update queue status to failed
+                await queues_1.default.updateOne({ _id: emailJob._id }, {
+                    status: 'failed',
+                    error_message: String(error),
+                    attempts: emailJob.attempts + 1,
+                    updated_at: Date.now()
+                });
+            }
+        }
+    }
+    catch (error) {
+        console.error('Error processing email queue:', error);
+    }
+};
+exports.processEmailQueue = processEmailQueue;
+const processPasswordResetQueue = async () => {
+    try {
+        const pendingResets = await queues_1.default.find({
+            type: 'password_reset',
+            status: 'pending',
+            deleted_at: null
+        })
+            .sort({ created_at: 1 })
+            .limit(10)
+            .lean()
+            .exec();
+        for (const resetJob of pendingResets) {
+            try {
+                const { data } = resetJob;
+                await (0, mailer_1.sendPasswordResetEmail)(data.email, data.name, data.reset_token);
+                // Update queue status
+                await queues_1.default.updateOne({ _id: resetJob._id }, {
+                    status: 'completed',
+                    processed_at: Date.now(),
+                    updated_at: Date.now()
+                });
+                console.log(`Password reset email sent successfully to ${data.email}`);
+            }
+            catch (error) {
+                console.error(`Failed to send password reset email to ${resetJob.data.email}:`, error);
+                // Update queue status to failed
+                await queues_1.default.updateOne({ _id: resetJob._id }, {
+                    status: 'failed',
+                    error_message: String(error),
+                    attempts: resetJob.attempts + 1,
+                    updated_at: Date.now()
+                });
+            }
+        }
+    }
+    catch (error) {
+        console.error('Error processing password reset queue:', error);
+    }
+};
+exports.processPasswordResetQueue = processPasswordResetQueue;
+const addToQueue = async (type, data) => {
+    try {
+        await queues_1.default.create({
+            type,
+            data,
+            status: 'pending',
+            created_at: Date.now()
+        });
+    }
+    catch (error) {
+        console.error('Error adding to queue:', error);
+        throw error;
+    }
+};
+exports.addToQueue = addToQueue;

package/dist/middlewares/audit/index.js

@@ -0,0 +1 @@
+"use strict";

package/dist/middlewares/guard/index.d.ts

@@ -0,0 +1,11 @@
+import { Request, Response, NextFunction } from 'express';
+interface AuthenticatedRequest extends Request {
+    user?: {
+        userId: string;
+        email: string;
+        role: string;
+    };
+}
+export declare const authenticateToken: (req: AuthenticatedRequest, res: Response, next: NextFunction) => void;
+export declare const requireRole: (roles: string[]) => (req: AuthenticatedRequest, res: Response, next: NextFunction) => void;
+export default authenticateToken;

package/dist/middlewares/guard/index.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireRole = exports.authenticateToken = void 0;
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const authenticateToken = (req, res, next) => {
+    const authHeader = req.headers['authorization'];
+    const token = authHeader && authHeader.split(' ')[1]; // Bearer TOKEN
+    if (!token) {
+        res.status(401).json({ message: 'Access token required' });
+        return;
+    }
+    const jwtSecret = process.env.JWT_SECRET;
+    if (!jwtSecret) {
+        console.error('JWT_SECRET environment variable is required');
+        res.status(500).json({ message: 'Server configuration error' });
+        return;
+    }
+    jsonwebtoken_1.default.verify(token, jwtSecret, (err, decoded) => {
+        if (err) {
+            if (err.name === 'TokenExpiredError') {
+                res.status(401).json({ message: 'Token expired' });
+                return;
+            }
+            res.status(403).json({ message: 'Invalid token' });
+            return;
+        }
+        req.user = {
+            userId: decoded.userId,
+            email: decoded.email,
+            role: decoded.role
+        };
+        next();
+    });
+};
+exports.authenticateToken = authenticateToken;
+const requireRole = (roles) => {
+    return (req, res, next) => {
+        if (!req.user) {
+            res.status(401).json({ message: 'Authentication required' });
+            return;
+        }
+        if (!roles.includes(req.user.role)) {
+            res.status(403).json({ message: 'Insufficient permissions' });
+            return;
+        }
+        next();
+    };
+};
+exports.requireRole = requireRole;
+exports.default = exports.authenticateToken;

package/dist/middlewares/index.d.ts

@@ -0,0 +1,2 @@
+import { authenticateToken, requireRole } from './guard';
+export { authenticateToken, requireRole };

package/dist/middlewares/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireRole = exports.authenticateToken = void 0;
+// Import middleware modules when they are implemented
+const guard_1 = require("./guard");
+Object.defineProperty(exports, "authenticateToken", { enumerable: true, get: function () { return guard_1.authenticateToken; } });
+Object.defineProperty(exports, "requireRole", { enumerable: true, get: function () { return guard_1.requireRole; } });

package/dist/middlewares/meeting.d.ts

@@ -0,0 +1,9 @@
+import { Request, Response, NextFunction } from 'express';
+export declare const canJoinMeeting: (req: Request, res: Response, next: NextFunction) => Promise<Response<any, Record<string, any>> | undefined>;
+declare global {
+    namespace Express {
+        interface Request {
+            meeting?: any;
+        }
+    }
+}

package/dist/middlewares/meeting.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canJoinMeeting = void 0;
+const models_1 = require("../models");
+const canJoinMeeting = async (req, res, next) => {
+    try {
+        const { meetingId } = req.params;
+        const userId = req.user?._id;
+        const meeting = await models_1.Meetings.findById(meetingId);
+        if (!meeting) {
+            return res.status(404).json({ error: 'Meeting not found' });
+        }
+        if (!meeting.is_active) {
+            return res.status(403).json({ error: 'Meeting is not active' });
+        }
+        // Check if user is host or participant
+        const isHost = meeting.host_id.toString() === userId;
+        const isParticipant = meeting.participants.some((p) => p.user_id.toString() === userId);
+        if (!isHost && !isParticipant) {
+            return res.status(403).json({ error: 'You are not authorized to join this meeting' });
+        }
+        // Check meeting capacity
+        if (meeting.participant_count >= meeting.max_participants && !isHost) {
+            return res.status(403).json({ error: 'Meeting is full' });
+        }
+        req.meeting = meeting;
+        next();
+    }
+    catch (error) {
+        console.error('Error in canJoinMeeting middleware:', error);
+        res.status(500).json({ error: 'Internal server error' });
+    }
+};
+exports.canJoinMeeting = canJoinMeeting;

package/dist/models/employees/index.d.ts

@@ -0,0 +1,83 @@
+import mongoose from 'mongoose';
+declare const _default: mongoose.Model<{
+    first_name: string;
+    last_name: string;
+    created_at: number;
+    updated_at: number;
+    deleted_at: number;
+    middle_name?: string | null | undefined;
+    address?: string | null | undefined;
+    contact_number?: string | null | undefined;
+    email?: string | null | undefined;
+    position?: string | null | undefined;
+    department?: string | null | undefined;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    first_name: string;
+    last_name: string;
+    created_at: number;
+    updated_at: number;
+    deleted_at: number;
+    middle_name?: string | null | undefined;
+    address?: string | null | undefined;
+    contact_number?: string | null | undefined;
+    email?: string | null | undefined;
+    position?: string | null | undefined;
+    department?: string | null | undefined;
+}, {}, mongoose.DefaultSchemaOptions> & {
+    first_name: string;
+    last_name: string;
+    created_at: number;
+    updated_at: number;
+    deleted_at: number;
+    middle_name?: string | null | undefined;
+    address?: string | null | undefined;
+    contact_number?: string | null | undefined;
+    email?: string | null | undefined;
+    position?: string | null | undefined;
+    department?: string | null | undefined;
+} & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, {
+    first_name: string;
+    last_name: string;
+    created_at: number;
+    updated_at: number;
+    deleted_at: number;
+    middle_name?: string | null | undefined;
+    address?: string | null | undefined;
+    contact_number?: string | null | undefined;
+    email?: string | null | undefined;
+    position?: string | null | undefined;
+    department?: string | null | undefined;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    first_name: string;
+    last_name: string;
+    created_at: number;
+    updated_at: number;
+    deleted_at: number;
+    middle_name?: string | null | undefined;
+    address?: string | null | undefined;
+    contact_number?: string | null | undefined;
+    email?: string | null | undefined;
+    position?: string | null | undefined;
+    department?: string | null | undefined;
+}>, {}, mongoose.ResolveSchemaOptions<mongoose.DefaultSchemaOptions>> & mongoose.FlatRecord<{
+    first_name: string;
+    last_name: string;
+    created_at: number;
+    updated_at: number;
+    deleted_at: number;
+    middle_name?: string | null | undefined;
+    address?: string | null | undefined;
+    contact_number?: string | null | undefined;
+    email?: string | null | undefined;
+    position?: string | null | undefined;
+    department?: string | null | undefined;
+}> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>>;
+export default _default;

package/dist/models/employees/index.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = __importDefault(require("mongoose"));
+const employeeSchema = new mongoose_1.default.Schema({
+    first_name: {
+        type: String,
+        required: true,
+        trim: true,
+    },
+    middle_name: {
+        type: String,
+        trim: true,
+    },
+    last_name: {
+        type: String,
+        required: true,
+        trim: true,
+    },
+    address: {
+        type: String,
+        trim: true,
+    },
+    contact_number: {
+        type: String,
+        trim: true,
+    },
+    email: {
+        type: String,
+        trim: true,
+        index: true,
+    },
+    position: {
+        type: String,
+        trim: true,
+    },
+    department: {
+        type: String,
+        trim: true,
+    },
+    created_at: {
+        type: Number,
+        default: () => Date.now(),
+    },
+    updated_at: {
+        type: Number,
+        default: () => Date.now(),
+    },
+    deleted_at: {
+        type: Number,
+        default: null,
+        index: true,
+    },
+});
+// Virtual for full name
+employeeSchema.virtual('full_name').get(function () {
+    let fullName = `${this.first_name} ${this.last_name}`;
+    if (this.middle_name) {
+        fullName = `${this.first_name} ${this.middle_name} ${this.last_name}`;
+    }
+    return fullName;
+});
+// Ensure virtual fields are included in JSON output
+employeeSchema.set('toJSON', { virtuals: true });
+employeeSchema.set('toObject', { virtuals: true });
+// Compound indexes for better query performance
+employeeSchema.index({ first_name: 1, last_name: 1 });
+exports.default = mongoose_1.default.model('_employees', employeeSchema);