sk-test-node-deploy 1.0.0

package/template/src/models/user.model.ts

@@ -0,0 +1,47 @@
+import mongoose, { Document, Schema } from 'mongoose';
+
+export interface IUser extends Document {
+  name: string;
+  email: string;
+  password: string;
+  refreshToken?: string;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+const userSchema = new Schema<IUser>(
+  {
+    name: {
+      type: String,
+      required: [true, 'Name is required'],
+      trim: true,
+      minlength: [2, 'Name must be at least 2 characters'],
+      maxlength: [50, 'Name cannot exceed 50 characters']
+    },
+    email: {
+      type: String,
+      required: [true, 'Email is required'],
+      unique: true,
+      lowercase: true,
+      trim: true,
+      match: [/^\S+@\S+\.\S+$/, 'Please provide a valid email']
+    },
+    password: {
+      type: String,
+      required: [true, 'Password is required'],
+      minlength: [6, 'Password must be at least 6 characters'],
+      select: false
+    },
+    refreshToken: {
+      type: String,
+      select: false
+    }
+  },
+  {
+    timestamps: true
+  }
+);
+
+const User = mongoose.model<IUser>('User', userSchema);
+
+export default User;

package/template/src/routes/auth.routes.ts

@@ -0,0 +1,15 @@
+import { Router } from 'express';
+import { authController } from '../controllers/auth.controller';
+import { validate, registerSchema, loginSchema, refreshTokenSchema } from '../middlewares/validation.middleware';
+import { authenticate } from '../middlewares/auth.middleware';
+
+const authRoutes = Router();
+
+authRoutes.post('/refresh', validate(refreshTokenSchema), authController.refreshToken);
+authRoutes.post('/register', validate(registerSchema), authController.register);
+authRoutes.post('/login', validate(loginSchema), authController.login);
+
+authRoutes.post('/logout', authenticate, authController.logout);
+authRoutes.get('/profile', authenticate, authController.getProfile);
+
+export default authRoutes;

package/template/src/routes/file.routes.ts

@@ -0,0 +1,11 @@
+import { Router } from 'express';
+import { fileController } from '../controllers/file.controller';
+import { authenticate } from '../middlewares/auth.middleware';
+import { uploadMiddleware } from '../middlewares/upload.middleware';
+
+const fileRoutes = Router();
+
+fileRoutes.use(authenticate);
+fileRoutes.post('/upload', uploadMiddleware.single('file'), fileController.uploadFile);
+
+export default fileRoutes;

package/template/src/routes/user.routes.ts

@@ -0,0 +1,15 @@
+import { Router } from 'express';
+import { userController } from '../controllers/user.controller';
+import { authenticate } from '../middlewares/auth.middleware';
+import { validate, updateUserSchema } from '../middlewares/validation.middleware';
+
+const userRoutes = Router();
+
+userRoutes.use(authenticate);
+
+userRoutes.get('/', userController.getAllUsers);
+userRoutes.get('/:id', userController.getUserById);
+userRoutes.put('/:id', validate(updateUserSchema), userController.updateUser);
+userRoutes.delete('/:id', userController.deleteUser);
+
+export default userRoutes;

package/template/src/socket/socker.handler.ts

@@ -0,0 +1,103 @@
+import { Server, Socket } from 'socket.io';
+
+interface Message {
+  username: string;
+  message: string;
+  timestamp: Date;
+}
+
+// Store active users
+const activeUsers = new Map<string, string>();
+
+export const initializeSocket = (io: Server) => {
+
+  io.on('connection', (socket: Socket) => {
+    console.log(`User connected: ${socket.id}`);
+
+    // Handle user joining
+    socket.on('join', (username: string) => {
+      activeUsers.set(socket.id, username);
+      console.log(`${username} joined the chat`);
+
+      // Notify all users
+      io.emit('user_joined', {
+        username,
+        timestamp: new Date(),
+        activeUsers: activeUsers.size
+      });
+
+      // Send active users list to the new user
+      socket.emit('active_users', {
+        count: activeUsers.size,
+        users: Array.from(activeUsers.values())
+      });
+    });
+
+    // Handle incoming messages
+    socket.on('message', (data: { username: string; message: string }) => {
+      const messageData: Message = {
+        username: data.username,
+        message: data.message,
+        timestamp: new Date()
+      };
+
+      console.log(`Message from ${data.username}: ${data.message}`);
+
+      // Broadcast message to all users
+      io.emit('message', messageData);
+    });
+
+    // Handle typing indicator
+    socket.on('typing', (data: { username: string; isTyping: boolean }) => {
+      socket.broadcast.emit('user_typing', data);
+    });
+
+    // Handle private messages
+    socket.on('private_message', (data: { to: string; message: string; from: string }) => {
+      // Find recipient socket
+      const recipientSocketId = Array.from(activeUsers.entries())
+        .find(([_, username]) => username === data.to)?.[0];
+
+      if (recipientSocketId) {
+        io.to(recipientSocketId).emit('private_message', {
+          from: data.from,
+          message: data.message,
+          timestamp: new Date()
+        });
+
+        // Send confirmation to sender
+        socket.emit('message_sent', {
+          to: data.to,
+          status: 'delivered'
+        });
+      } else {
+        socket.emit('message_sent', {
+          to: data.to,
+          status: 'user_not_found'
+        });
+      }
+    });
+
+    // Handle disconnection
+    socket.on('disconnect', () => {
+      const username = activeUsers.get(socket.id);
+      activeUsers.delete(socket.id);
+
+      console.log(`User disconnected: ${socket.id}`);
+
+      if (username) {
+        io.emit('user_left', {
+          username,
+          timestamp: new Date(),
+          activeUsers: activeUsers.size
+        });
+      }
+    });
+
+    // Handle errors
+    socket.on('error', (error) => {
+      console.error('Socket error:', error);
+    });
+  });
+
+};

package/template/src/types/express.d.ts

@@ -0,0 +1,10 @@
+import { Request } from "express";
+
+declare module "express-serve-static-core" {
+  interface Request {
+    user?: {
+      userId: string;
+      email: string;
+    };
+  }
+}

package/template/src/utils/jwt.util.ts

@@ -0,0 +1,54 @@
+import jwt from 'jsonwebtoken';
+
+interface TokenPayload {
+  userId: string;
+  email: string;
+}
+
+export class JWTUtil {
+  private static secret = process.env.JWT_SECRET || 'JWT_SECRET';
+  private static expiresIn = (process.env.JWT_EXPIRE || '7d') as string;
+  private static refreshSecret = process.env.JWT_SECRET || 'JWT_SECRET';
+  private static refreshExpiresIn = (process.env.JWT_REFRESH_EXPIRE || '30d') as string;
+
+  // Generate access token
+  static generateToken(payload: TokenPayload): string {
+    return jwt.sign(payload, this.secret, {
+      expiresIn: this.expiresIn as jwt.SignOptions['expiresIn']
+    });
+  }
+
+  // Generate refresh token
+  static generateRefreshToken(payload: TokenPayload): string {
+    return jwt.sign(payload, this.refreshSecret, {
+      expiresIn: this.refreshExpiresIn as jwt.SignOptions['expiresIn']
+    });
+  }
+
+  // Verify access token
+  static verifyToken(token: string): TokenPayload | null {
+    try {
+      return jwt.verify(token, this.secret) as TokenPayload;
+    } catch (error) {
+      return null;
+    }
+  }
+
+  // Verify refresh token
+  static verifyRefreshToken(token: string): TokenPayload | null {
+    try {
+      return jwt.verify(token, this.refreshSecret) as TokenPayload;
+    } catch (error) {
+      return null;
+    }
+  }
+
+  // Decode token without verification
+  static decodeToken(token: string): any {
+    try {
+      return jwt.decode(token);
+    } catch (error) {
+      return null;
+    }
+  }
+}

package/template/src/validation/user.validation.ts

@@ -0,0 +1,27 @@
+import Joi from 'joi';
+
+export const registerSchema = Joi.object({
+  name: Joi.string().min(2).max(50).required().messages({
+    'string.empty': 'Name is required',
+    'string.min': 'Name must be at least 2 characters',
+    'string.max': 'Name cannot exceed 50 characters'
+  }),
+  email: Joi.string().email().required().messages({
+    'string.empty': 'Email is required',
+    'string.email': 'Please provide a valid email address'
+  }),
+  password: Joi.string().min(6).required().messages({
+    'string.empty': 'Password is required',
+    'string.min': 'Password must be at least 6 characters'
+  })
+});
+
+export const loginSchema = Joi.object({
+  email: Joi.string().email().required().messages({
+    'string.empty': 'Email is required',
+    'string.email': 'Please provide a valid email address'
+  }),
+  password: Joi.string().required().messages({
+    'string.empty': 'Password is required'
+  })
+});

package/template/tsconfig.json

@@ -0,0 +1,31 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": [
+      "ES2020"
+    ],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "moduleResolution": "node",
+    "typeRoots": [
+      "./node_modules/@types",
+      "./src/types",
+      "./types"
+    ]
+  },
+  "ts-node": {
+    "files": true
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}