@organizasyon/meeting-nanaman-app-backend 1.0.0

package/src/middlewares/guard/index.ts

@@ -0,0 +1,64 @@
+import { Request, Response, NextFunction } from 'express';
+import jwt from 'jsonwebtoken';
+
+interface AuthenticatedRequest extends Request {
+  user?: {
+    userId: string;
+    email: string;
+    role: string;
+  };
+}
+
+export const authenticateToken = (req: AuthenticatedRequest, res: Response, next: NextFunction): void => {
+  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;
+  }
+
+  jwt.verify(token, jwtSecret, (err: any, decoded: any) => {
+    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();
+  });
+};
+
+export const requireRole = (roles: string[]) => {
+  return (req: AuthenticatedRequest, res: Response, next: NextFunction): void => {
+    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();
+  };
+};
+
+export default authenticateToken;

package/src/middlewares/index.ts

@@ -0,0 +1,5 @@
+// Import middleware modules when they are implemented
+import { authenticateToken, requireRole } from './guard';
+
+// Placeholder for future middleware exports
+export { authenticateToken, requireRole };

package/src/middlewares/meeting.ts

@@ -0,0 +1,45 @@
+import { Request, Response, NextFunction } from 'express';
+import { Users as UserModel, Meetings as MeetingModel } from '../models';
+
+export const canJoinMeeting = async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const { meetingId } = req.params;
+    const userId = (req as any).user?._id;
+
+    const meeting = await MeetingModel.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: any) => 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 as any).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' });
+  }
+};
+
+declare global {
+  namespace Express {
+    interface Request {
+      meeting?: any;
+    }
+  }
+}

package/src/models/employees/index.ts

@@ -0,0 +1,70 @@
+import mongoose from 'mongoose';
+
+const employeeSchema = new mongoose.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 });
+
+export default mongoose.model('_employees', employeeSchema);

package/src/models/index.ts

@@ -0,0 +1,8 @@
+import Employees from './employees';
+import Users from './users';
+import Passkeys from './passkeys';
+import Queues from './queues';
+import Meetings from './meetings';
+
+export { Employees, Users, Passkeys, Queues, Meetings };
+export default { Employees, Users, Passkeys, Queues, Meetings };

package/src/models/meetings/index.ts

@@ -0,0 +1,112 @@
+import mongoose from 'mongoose';
+
+const meetingSchema = new mongoose.Schema({
+    title: {
+        type: String,
+        required: true,
+        trim: true,
+    },
+    description: {
+        type: String,
+        trim: true,
+    },
+    host_id: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: '_users',
+        required: true,
+        index: true,
+    },
+    participants: [{
+        user_id: {
+            type: mongoose.Schema.Types.ObjectId,
+            ref: '_users',
+            required: false,
+        },
+        email: {
+            type: String,
+            required: false,
+        },
+        joined_at: {
+            type: Number,
+            default: null,
+        },
+        left_at: {
+            type: Number,
+            default: null,
+        },
+        is_active: {
+            type: Boolean,
+            default: false,
+        },
+        status: {
+            type: String,
+            enum: ['pending', 'accepted'],
+            default: 'accepted',
+        },
+    }],
+    scheduled_at: {
+        type: Number,
+        default: () => Date.now(),
+    },
+    started_at: {
+        type: Number,
+        default: null,
+    },
+    ended_at: {
+        type: Number,
+        default: null,
+    },
+    meeting_type: {
+        type: String,
+        enum: ['video', 'audio'],
+        default: 'video',
+    },
+    meeting_url: {
+        type: String,
+        unique: true,
+        required: true,
+    },
+    max_participants: {
+        type: Number,
+        default: 50,
+    },
+    is_active: {
+        type: Boolean,
+        default: 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 participant count
+meetingSchema.virtual('participant_count').get(function() {
+    return this.participants.filter(p => p.is_active).length;
+});
+
+// Virtual for duration (in minutes)
+meetingSchema.virtual('duration_minutes').get(function() {
+    if (!this.started_at) return 0;
+    const end = this.ended_at || Date.now();
+    return Math.floor((end - this.started_at) / (1000 * 60));
+});
+
+// Ensure virtual fields are included in JSON output
+meetingSchema.set('toJSON', { virtuals: true });
+meetingSchema.set('toObject', { virtuals: true });
+
+// Indexes for better query performance
+meetingSchema.index({ host_id: 1, scheduled_at: -1 });
+meetingSchema.index({ 'participants.user_id': 1 });
+
+export default mongoose.model('_meetings', meetingSchema);

package/src/models/passkeys/index.ts

@@ -0,0 +1,53 @@
+import mongoose from 'mongoose';
+
+const passkeySchema = new mongoose.Schema({
+  user_id: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: '_users',
+    required: true,
+    index: true,
+  },
+  credential_id: {
+    type: String,
+    required: true,
+    unique: true,
+  },
+  device_id: {
+    type: String,
+    required: true,
+  },
+  name: {
+    type: String,
+    required: true,
+  },
+  public_key: {
+    type: String,
+    required: true,
+  },
+  created_at: {
+    type: Number,
+    default: () => Date.now(),
+  },
+  updated_at: {
+    type: Number,
+    default: () => Date.now(),
+  },
+  last_used_at: {
+    type: Number,
+    default: null,
+  },
+  is_active: {
+    type: Boolean,
+    default: true,
+  },
+  deleted_at: {
+    type: Number,
+    default: null,
+    index: true,
+  },
+});
+
+// Compound indexes for better query performance
+passkeySchema.index({ user_id: 1, credential_id: 1 });
+
+export default mongoose.model('_passkeys', passkeySchema);

package/src/models/queues/index.ts

@@ -0,0 +1,55 @@
+import mongoose from 'mongoose';
+
+const queueSchema = new mongoose.Schema({
+  type: {
+    type: String,
+    required: true,
+    enum: ['email', 'password_reset', 'passkey'],
+    index: true,
+  },
+  data: {
+    type: mongoose.Schema.Types.Mixed,
+    required: true,
+  },
+  status: {
+    type: String,
+    required: true,
+    enum: ['pending', 'processing', 'completed', 'failed'],
+    default: 'pending',
+    index: true,
+  },
+  attempts: {
+    type: Number,
+    default: 0,
+  },
+  max_attempts: {
+    type: Number,
+    default: 3,
+  },
+  error_message: {
+    type: String,
+    default: null,
+  },
+  created_at: {
+    type: Number,
+    default: () => Date.now(),
+  },
+  updated_at: {
+    type: Number,
+    default: () => Date.now(),
+  },
+  processed_at: {
+    type: Number,
+    default: null,
+  },
+  deleted_at: {
+    type: Number,
+    default: null,
+    index: true,
+  },
+});
+
+// Compound indexes for better query performance
+queueSchema.index({ type: 1, status: 1, created_at: -1 });
+
+export default mongoose.model('_queues', queueSchema);

package/src/models/users/index.ts

@@ -0,0 +1,92 @@
+import mongoose from 'mongoose';
+
+const userSchema = new mongoose.Schema({
+    email: {
+        type: String,
+        required: true,
+        unique: true,
+        trim: true,
+        lowercase: true,
+        index: true,
+    },
+    password: {
+        type: String,
+        required: true,
+    },
+    first_name: {
+        type: String,
+        required: true,
+        trim: true,
+    },
+    middle_name: {
+        type: String,
+        trim: true,
+    },
+    last_name: {
+        type: String,
+        required: true,
+        trim: true,
+    },
+    role: {
+        type: String,
+        enum: ['admin', 'manager', 'employee'],
+        default: 'employee',
+    },
+    is_active: {
+        type: Boolean,
+        default: true,
+    },
+    employee_id: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: '_employees',
+        default: null,
+        index: true,
+    },
+    created_at: {
+        type: Number,
+        default: () => Date.now(),
+    },
+    updated_at: {
+        type: Number,
+        default: () => Date.now(),
+    },
+    reset_token: {
+        type: String,
+        default: null,
+    },
+    reset_token_expires: {
+        type: Number,
+        default: null,
+    },
+    deleted_at: {
+        type: Number,
+        default: null,
+        index: true,
+    },
+    fcm_token: {
+        type: String,
+        default: null,
+    },
+    has_passkey: {
+        type: Boolean,
+        default: false,
+    },
+});
+
+// Virtual for full name
+userSchema.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
+userSchema.set('toJSON', { virtuals: true });
+userSchema.set('toObject', { virtuals: true });
+
+// Additional compound indexes for better query performance
+userSchema.index({ first_name: 1, last_name: 1 });
+
+export default mongoose.model('_users', userSchema);

package/src/queues/index.ts

@@ -0,0 +1 @@
+export * from './mailer';

package/src/queues/mailer/index.ts

@@ -0,0 +1,80 @@
+import { Queue, Worker } from 'bullmq';
+import { Redis } from 'ioredis';
+import { sendPasswordResetEmail, sendPasswordChangedEmail, sendPasskeyRegisteredEmail } from '../../jobs/mailer';
+
+// Redis connection
+const redisConnection = new Redis({
+  host: process.env.REDIS_HOST || 'localhost',
+  port: Number(process.env.REDIS_PORT) || 6379,
+  password: process.env.REDIS_PASSWORD || (process.env.NODE_ENV === 'production' ? undefined : ''),
+  maxRetriesPerRequest: null, // Required for BullMQ
+  lazyConnect: true,
+});
+
+// Email queue - create only when needed to avoid connection issues
+let emailQueue: Queue | null = null;
+
+const getEmailQueue = () => {
+  if (!emailQueue) {
+    emailQueue = new Queue('email', {
+      connection: redisConnection,
+      defaultJobOptions: {
+        removeOnComplete: 50,
+        removeOnFail: 100,
+      },
+    });
+  }
+  return emailQueue;
+};
+
+// Worker will be created only when explicitly started
+let emailWorker: Worker | null = null;
+
+export const startEmailWorker = () => {
+  if (emailWorker) return emailWorker;
+
+  emailWorker = new Worker('email', async (job) => {
+    const { type, data } = job.data;
+
+    try {
+      switch (type) {
+        case 'password_reset':
+          await sendPasswordResetEmail(data.email, data.name, data.reset_token);
+          break;
+        case 'password_changed':
+          await sendPasswordChangedEmail(data.email, data.name);
+          break;
+        case 'passkey':
+          await sendPasskeyRegisteredEmail(data.email, data.name, data.device_name);
+          break;
+        default:
+          throw new Error(`Unknown email type: ${type}`);
+      }
+
+      console.log(`Email job ${job.id} processed successfully`);
+    } catch (error) {
+      console.error(`Email job ${job.id} failed:`, error);
+      throw error;
+    }
+  }, {
+    connection: redisConnection,
+    concurrency: 5, // Process up to 5 emails concurrently
+    limiter: {
+      max: 10, // Max 10 jobs per duration
+      duration: 1000, // Per 1 second
+    },
+  });
+
+  // Event listeners
+  emailWorker.on('completed', (job) => {
+    console.log(`Email job ${job.id} completed`);
+  });
+
+  emailWorker.on('failed', (job, err) => {
+    console.error(`Email job ${job?.id} failed:`, err);
+  });
+
+  return emailWorker;
+};
+
+export { getEmailQueue };

package/src/types/index.ts

@@ -0,0 +1,38 @@
+import { Request } from 'express'
+import multer from 'multer'
+
+export interface MulterRequest extends Request {
+  file?: Express.Multer.File
+}
+
+export interface User {
+  id: string;
+  username: string;
+  email: string;
+  first_name: string;
+  middle_name?: string;
+  last_name: string;
+  role: 'admin' | 'manager' | 'employee';
+  employee_id?: string;
+  is_active: boolean;
+}
+
+export interface Employee {
+  id: string;
+  first_name: string;
+  middle_name?: string;
+  last_name: string;
+  email?: string;
+  contact_number?: string;
+  position?: string;
+  department?: string;
+  address?: string;
+}
+
+export interface Module {
+  id: string;
+  name: string;
+  icon?: string;
+  path: string;
+  children?: Module[];
+}

package/src/utils/notifications.ts

@@ -0,0 +1,66 @@
+import axios from 'axios';
+
+const NOTIFICATIONS_SERVICE_URL = process.env.NOTIFICATIONS_SERVICE_URL || 'http://localhost:3003';
+
+export const sendNotification = async (
+  userIds: string | string[],
+  title: string,
+  body: string,
+  data: any = {},
+  type: string = 'general'
+) => {
+  try {
+    const payload = {
+      title,
+      body,
+      data,
+      type
+    };
+
+    const userIdsArray = Array.isArray(userIds) ? userIds : [userIds];
+
+    // Send notification to each user
+    for (const userId of userIdsArray) {
+      await axios.post(`${NOTIFICATIONS_SERVICE_URL}/send-notification`, 
+        { ...payload, userId },
+        {
+          headers: {
+            'Authorization': `Bearer ${process.env.NOTIFICATIONS_SERVICE_TOKEN || 'service-token'}`
+          }
+        }
+      );
+    }
+
+    console.log(`Notifications sent to users: ${userIdsArray.join(', ')}`);
+  } catch (error) {
+    console.error('Error sending notifications:', error);
+  }
+};
+
+export const sendMeetingInvitation = async (
+  meetingId: string,
+  participants: string[],
+  title: string,
+  description: string,
+  hostId: string
+) => {
+  try {
+    await axios.post(`${NOTIFICATIONS_SERVICE_URL}/meeting-invitation`,
+      {
+        meetingId,
+        participants,
+        title,
+        description
+      },
+      {
+        headers: {
+          'Authorization': `Bearer ${process.env.NOTIFICATIONS_SERVICE_TOKEN || 'service-token'}`
+        }
+      }
+    );
+
+    console.log(`Meeting invitations sent for meeting: ${meetingId}`);
+  } catch (error) {
+    console.error('Error sending meeting invitations:', error);
+  }
+};