How to Set Up index.ts and app.ts for a Clean Node.js Server Start (TypeScript Best Practices)

When starting a Node.js project with TypeScript, structuring your entry files the right way makes your code cleaner and easier to scale. In this guide, we’ll set up index.ts and app.ts step by step, separating server configuration from application logic. By the end, you’ll have a production-ready server foundation following TypeScript best practices.

Project Structure Overview

/src → contains all source code

index.ts → server entry point

app.ts → app configuration (middlewares, routes)

routes/ → define your endpoints

controllers/ → handle request logic

utils/ or config/ → helper functions, constants

src\index.ts

        import app from './app';
        import { initPrisma } from '@config/database';
        import indexRoutes from '@routes/index.route';

        const PORT = process.env.PORT || 3000;

        app.get("/", (req, res) => {
        res.json({ message: "Index route working!" });
        });

        app.use("/api", indexRoutes);

        async function startServer() {
        await initPrisma();
        app.listen(PORT, () => {
            const host = process.env.HOST || 'localhost';
            console.log(`Server running at http://${host}:${PORT}`);
        });
        }

        startServer();
        <!-- //code -->

src\app.ts

   
      	  import { config } from 'dotenv';
          config();
          import express, { Express } from 'express';

          const app: Express = express();

          app.use(express.json());
          app.use(express.urlencoded({ extended: true }));

          // Serve static files from uploads
          app.use("/uploads", express.static("uploads"));

          // Example route
          // app.post("/upload", fileUpload, (req, res) => {
          //   return res.json({
          //     success: true,
          //     message: "Image uploaded successfully",
          //     url: (req as any).fileUrl,
          //   });
          // });


          export default app;

src\config\database.ts

      
      import { PrismaClient } from '@prisma/client';

      const prisma = new PrismaClient();

      export async function initPrisma() {
        try {
          await prisma.$connect();
          console.log('Connected to MySQL database');
        } catch (error) {
          console.error('Failed to connect to database:', error);
          process.exit(1);
        }
      }

      export default prisma;

src\config\multer.ts

        // src/config/multer.ts
        import multer from "multer";
        
        // Memory storage (files kept in memory as buffer)
        const upload = multer({ storage: multer.memoryStorage() });
        
        export default upload;

src\middlewares\auth.ts

        
      <pre><code class="language-json">
        import { Request, Response, NextFunction } from "express";
          import { verifyToken } from "@utils/jwt";
          import { ApiResponse } from "@utils/response";
          import { PrismaClient } from "@prisma/client";

          const prisma = new PrismaClient();

          export async function auth(req: Request, res: Response, next: NextFunction) {
              const authHeader = req.headers.authorization;
              console.log('authHeader', authHeader);

              if (!authHeader || !authHeader.startsWith("Bearer ")) {
                  console.log('unauthorized:::');
                  return ApiResponse.unauthorized(res, "Unauthorized");
              }
              

              const token = authHeader.split(" ")[1];

              //block
              const blacklisted = await prisma.blacklistToken.findUnique({
                  where: { token: token },
              });

              if (blacklisted) {
                  return res.status(401).json(ApiResponse.error(res,"Token blacklisted",null,401));
              }

              try {
                  // 1. Verify token
                  const payload = verifyToken(token) as { id: number };

                  // 2. Get user from DB
                  const user = await prisma.user.findUnique({ where: { id: payload.id } });
                  if (!user) {
                      console.log('user not found');
                      return res.status(401).json(ApiResponse.error(res,"user not found",null,401));
                  }

                  // 3. Attach to request
                  console.log('auth user', user);
                  
                  req.user = user as unknown as User;

                  next();
              } catch (err) {
                  console.log('invalid token',err);
                  return res.status(401).json(ApiResponse.error(res,"Invalid token",null,401));
              }
          }

        </code></pre>

src\middlewares\fileUpload.ts

        import multer from "multer";
        import path from "path";
        import { Request, Response, NextFunction } from "express";
        import { log } from "console";
        
        const storage = multer.diskStorage({
          destination: "uploads/",
          filename: (_req, file, cb) => {
            cb(null, Date.now() + "-" + file.fieldname + path.extname(file.originalname));
          },
        });
        
        const upload = multer({ storage }).any(); // .any() supports all cases
        
        export function fileUpload(req: Request, res: Response, next: NextFunction) {
          upload(req, res, (err) => {
            if (err) return res.status(400).json({ success: false, message: err.message });
        
            (req as any).filesStored = {};
        
            // Case 1: multiple files → req.files (array)
            if (req.files && Array.isArray(req.files)) {
              req.files.forEach((file: Express.Multer.File) => {
                (req as any).filesStored[file.fieldname] = file.filename;
              });
            }
        
            // Case 2: single file → req.file
            if (req.file) {
              (req as any).filesStored[req.file.fieldname] = req.file.filename;
            }
            
            next();
          });
        }

src\middlewares\validate.ts

   
        <pre><code class="language-json">
       
        import { Request, Response, NextFunction } from "express";
        import { ZodType } from "zod";
        import { ApiResponse } from "@utils/response";

        export const validate = (schema: ZodType<any>) => {
          return (req: Request, res: Response, next: NextFunction) => {
            console.log('req.body', req.body);
            const result = schema.safeParse(req.body);

            if (!result.success) {
              // Use the proper validationError formatter
              return ApiResponse.validationError(res, result.error);
            }

            // Attach parsed and typed data to req.body
            req.body = result.data;
            next();
          };
        };

        </code></pre>

src\routes\auth.route.ts

      
      
      	import { Router } from "express";
        import { AuthController } from "@controllers/auth.controller";
        import { validate } from "@middlewares/validate";
        import { registerSchema, loginSchema, profileSchema } from "@schemas/auth.schema";
        import { fileUpload } from "@middlewares/fileUpload";
        import { auth } from "@middlewares/auth"

        const router = Router();
        const authController = new AuthController();

        router.get("/", authController.index);
        router.post("/login", fileUpload, validate(loginSchema), authController.login);
        router.post("/register", fileUpload, validate(registerSchema), authController.register);

        //auth middleware
        router.get('/profile', auth, authController.profile);
        router.post('/profile/:id', auth,fileUpload, validate(profileSchema), authController.profileUpdate);

        export default router;

src\routes\index.route.ts

        import { Router } from "express";
        import authRoutes from "@routes/auth.route";
        import userRoutes from "@routes/user.route";

        const router = Router();

        router.get("/", (req, res) => {
        res.json({ message: "Index route working!" });
        });

        router.use("/auth", authRoutes);
        router.use("/user", userRoutes);

        export default router;

        
      	import { Router } from "express";
        import { UserController } from "@controllers/user.controller";
        const userController = new UserController();

        const router = Router();

        router.get("/", userController.index);
        router.post("/", userController.create);
        router.post("/", userController.update);
        router.get("/", userController.delete);

        export default router;

src\middlewares\validate.ts

        
      	import { z } from "zod";

        export const registerSchema = z.object({
          name: z.string({ message: "Name is required" }).min(2, "Name must be at least 2 characters"),
          email: z.string({ message: "Email is required" }).email("Invalid email address"),
          password: z.string({ message: "Password is required" }).min(6, "Password must be at least 6 characters"),
          image: z.string().url("Image must be a valid URL").optional(),
        });
        
        export const loginSchema = z.object({
          email: z.string({ message: "Email is required" }).email("Invalid email address"),
          password: z.string({ message: "Password is required" }).min(6, "Password must be at least 6 characters"),
        });
        
        //profileSchema
        export const profileSchema = z.object({
          name: z.string({ message: "Name is required" }).min(2, "Name must be at least 2 characters"),
          image: z.string().url("Image must be a valid URL").optional(),
          email: z.string({ message: "Email is required" }).email("Invalid email address"),
          password: z.string({ message: "Password is required" }).min(6, "Password must be at least 6 characters"),
        });

src\types\global.d.ts

        
      	import { Prisma } from "@prisma/client";

        // Extend Express Request
        declare module "express-serve-static-core" {
        interface Request {
            filesStored?: Record<string, string>;
            user?: User;          
        }
        }

        // Global types for Prisma models
        declare global {
        type User = Prisma.UserGetPayload<{ include: { _count: true,image: true } }>;
        // add more models as needed
        }


        // Prevent TS from complaining about "global" file
        export {};

src\utils\asset.ts

       
      	  export function assets(fileName: string | null | undefined) {
            if (!fileName) return null;
            return `${process.env.ASSET_URL}/${fileName}`;
          }

src\utils\jwt.ts

      
        <pre><code class="language-json">
        import jwt, { SignOptions } from "jsonwebtoken";
        import bcrypt from "bcryptjs";

        const JWT_SECRET = process.env.JWT_SECRET!;
        const JWT_EXPIRES_IN = process.env.JWT_EXPIRES_IN || "7d";

        if (!JWT_SECRET) {
        throw new Error("JWT_SECRET is not defined in .env");
        }

        export function signToken(payload: object) {
        const options: SignOptions = { expiresIn: JWT_EXPIRES_IN as unknown as number };
        return jwt.sign(payload, JWT_SECRET, options);
        }

        export function verifyToken(token: string) {
        return jwt.verify(token, JWT_SECRET);
        }

        //bcrypt.compare(password, user.password);
        export function compareToken(token: string, password: string) {
        return jwt.verify(token, JWT_SECRET, (err, decoded) => {
            if (err) {
            return false;
            }
            return bcrypt.compare(password, decoded?.password as string);
        });
        }
        </code></pre>

src\utils\response.ts

        // src/utils/response.ts
        import { Response } from "express";
        import { ZodError } from "zod";

        export class ApiResponse {
        static success(res: Response, data: any = {}, message = "Success", statusCode = 200) {
            return res.status(statusCode).json({
            status: true,
            message,
            data,
            });
        }

        static error(res: Response, message = "Something went wrong", errors: any = null, statusCode = 500) {
            return res.status(statusCode).json({
            status: false,
            message,
            errors : errors,
            });
        }

        
        static validationError(res: Response, zodError: ZodError, message = "Validation failed") {
            const formattedErrors: Record<string, string> = {};

            zodError.issues.forEach((err) => {
            const field = err.path[0] as string || "_global";
            // Only keep the first message per field
            if (!formattedErrors[field]) {
                formattedErrors[field] = err.message;
            }
            });

            return res.status(400).json({
            status: false,
            message,
            errors: formattedErrors,
            });
        }

        static unauthorized(res: Response, message = "Unauthorized") {
            return res.status(401).json({
            status: false,
            message,
            errors: null,
            });
        }
        }

src\resources\user.resource.ts

        import { assets } from "@utils/asset";

        export function UserResource(user: User) {
            if (!user) return null;

            return {
                id: user.id,
                name: user.name,
                email: user.email,
                image: assets(user.image as string),
                createdAt: user.createdAt,
            };
        }

        export function UsersResource(users:User[]) {
        return users.map(user => UserResource(user));
        }

src\controllers\auth.controller.ts

        import { Request, Response } from "express";
        import prisma from "@config/database";
        import bcrypt from "bcryptjs";
        import { UserResource } from "@resources/user.resource";
        import { ApiResponse } from "@utils/response";
        import { signToken } from "@utils/jwt";


        export class AuthController {
        public index = (req: Request, res: Response) => {
            res.json({ message: "Auth controller working!" });

        };

        public login = async (req: Request, res: Response): Promise<any> => {
            const { email, password } = req.body;

            const user = await prisma.user.findUnique({
            where: { email },
            });

            if (!user) {
            return ApiResponse.error(res, "User not found");
            }

            const isValid = await bcrypt.compare(password, user.password);
            console.log('isValid', isValid);
            
            if (!isValid) {
            return ApiResponse.error(res, "Invalid password");
            }

            // 3. Generate token
            const token = signToken({ id: user.id });

            return ApiResponse.success(res, {
            user: UserResource(user),
            token,
            });
        }

        public register = async (req: Request, res: Response): Promise<any> => {

            const { name, email, password } = req.body;
            const { image } = req.filesStored as any;

            // check if user already exists
            const userExists = await prisma.user.findUnique({
            where: { email },
            });

            if (userExists) {
            return ApiResponse.error(res, "User already exists");
            }

            const hashedPassword = await bcrypt.hash(password, 10);

            // Create user
            const user = await prisma.user.create({
            data: {
                name,
                email,
                password: hashedPassword,
                image,
            },
            });

            const token = signToken({ id: user.id });

            return ApiResponse.success(res, {
            user: UserResource(user),
            token,
            });
        }

        //profile
        public profileUpdate = async (req: Request, res: Response): User => {
            const { id } = req.params;
            console.log(id);

            const { name, email, password } = req.body;
            const { image } = req.filesStored as any;

            const user = await prisma.user.update({
            where: { id: parseInt(id) },
            data: { name, email, password, image },
            });

            return ApiResponse.success(res, { user: UserResource(user) });
        }

        //profile 
        public profile = async (req: Request, res: Response): User => {

            // get tockeg to id 
            const user = await prisma.user.findUnique({
            where: { id: req.user.id },
            });

            return ApiResponse.success(res, { user: UserResource(user) });

        }
        }

src\controllers\user.controller.ts

        import { Request, Response } from "express";

        export class UserController {
            public index = (req: Request, res: Response): void => {
                res.json({ message: "User controller working!" });
            };

            public create = (req: Request, res: Response): void => {
                res.json({ message: "User controller working!" });
            };

            public update = (req: Request, res: Response): void => {
                res.json({ message: "User controller working!" });
            };

            public delete = (req: Request, res: Response): void => {
                
                res.json({ message: "User controller working!" });
            };
        }

        // Export single instance
        export const userController = new UserController();

.env

        DATABASE_URL="mysql://admin:admin@localhost:3306/node"
        PORT=3000
        HOST=localhost
        APP_URL="http://localhost:3000"
        ASSET_URL="http://localhost:3000/uploads"
        
        JWT_SECRET="your_super_secret_key"
        JWT_EXPIRES_IN="7d"

prisma\schema.prisma


        generator client {
            provider = "prisma-client-js"
            //output   = "../node_modules/.prisma/client"
          }
          
          datasource db {
            provider = "mysql"
            url      = env("DATABASE_URL")
          }
          
          model user {
            id        Int      @id @default(autoincrement())
            email     String   @unique(map: "User_email_key")
            name      String?
            image     String?
            password  String
            createdAt DateTime @default(now())
            updatedAt DateTime @updatedAt
          }

githube code

web-beast.com

Search Suggest

How to Set Up index.ts and app.ts for a Clean Node.js Server Start (TypeScript Best Practices)

Project Structure Overview

/src → contains all source code

index.ts → server entry point

app.ts → app configuration (middlewares, routes)

routes/ → define your endpoints

controllers/ → handle request logic

utils/ or config/ → helper functions, constants

src\index.ts

Post a Comment

web-beast.com

Search Suggest

How to Set Up index.ts and app.ts for a Clean Node.js Server Start (TypeScript Best Practices)

Project Structure Overview

/src → contains all source code index.ts → server entry point app.ts → app configuration (middlewares, routes) routes/ → define your endpoints controllers/ → handle request logic utils/ or config/ → helper functions, constants src\index.ts

Post a Comment

/src → contains all source code

index.ts → server entry point

app.ts → app configuration (middlewares, routes)

routes/ → define your endpoints

controllers/ → handle request logic

utils/ or config/ → helper functions, constants

src\index.ts