The Ultimate Node.js TypeScript Project Setup: DevOps Essentials Included

📁 node-typescript-project-with-devops/
├── 📁 node_modules           # Node.js modules
├── 📄 .gitignore             # Specifies files and directories to be ignored by Git
├── 📄 .dockerignore          # Specifies files and directories to be ignored by Docker
├── 📄 .env                   # Environment variables file
├── 📄 example.env            # Example environment variables file
├── 📁 uploads                # Folder for uploaded files
│   └── ...
├── 📁 src
│   ├── 📄 server.ts          # Main entry point for the application
│   ├── 📁 bin                # Contains binaries or executable files
│   │   └── 📄 www            # Start script for the server
│   ├── 📁 config             # Configuration files
│   │   ├── 📄 redis.config   # Redis configuration
│   │   ├── 📄 mongo.config    # MongoDB configuration
│   │   ├── 📄 postgres.config # PostgreSQL configuration
│   │   └── 📄 nginx.conf     # Nginx configuration file
│   ├── 📁 controllers        # Controller files
│   │   ├── 📄 customer.ts    # Customer-related controller
│   │   ├── 📄 product.ts     # Product-related controller
│   │   └── ...
│   ├── 📁 middleware         # Middleware files
│   │   ├── 📄 auth.ts        # Authentication middleware
│   │   ├── 📄 logger.ts      # Logger middleware
│   │   └── ...
│   ├── 📁 models             # Model files
│   │   ├── 📄 customer.ts    # Customer model
│   │   ├── 📄 product.ts     # Product model
│   │   └── ...
│   ├── 📁 routes             # Route files
│   │   ├── 📄 api.ts         # API routes
│   │   ├── 📄 auth.ts        # Authentication routes
│   │   └── ...
│   ├── 📁 tests              # Test files
│   │   ├── 📁 unit           # Unit tests
│   │   ├── 📁 integration     # Integration tests
│   │   ├── 📁 e2e            # End-to-end tests
│   │   └── ...
│   └── 📁 utils              # Utility files
│       ├── 📄 validation.ts   # Validation utilities
│       ├── 📄 helpers.ts      # Helper functions
│       └── ...
├── 📄 Dockerfile              # Dockerfile for building the Node.js app image
├── 📄 docker-compose.yml       # Docker Compose configuration
├── 📄 nodemon.json            # Nodemon configuration for development
├── 📄 package.json            # Project dependencies and scripts
├── 📁 ansible                  # Ansible directory
│   ├── 📄 deploy.yml          # Ansible playbook for deployment
│   └── 📁 roles               # Ansible roles (if any)
│       └── ...
└── 📁 helm                     # Helm chart directory
    ├── 📁 your-helm-chart/
    │   ├── 📁 charts          # Charts for dependencies
    │   ├── 📁 templates       # Template files for Kubernetes resources
    │   │   ├── 📄 deployment.yaml   # Deployment configuration for Node.js app
    │   │   ├── 📄 service.yaml      # Service configuration for exposing the Node.js app
    │   │   ├── 📄 ingress.yaml      # Ingress configuration for Nginx
    │   │   └── 📄 configmap.yaml    # ConfigMap for environment variables
    │   ├── 📄 Chart.yaml            # Metadata for your Helm chart
    │   └── 📄 values.yaml           # Default values for your templates
├── 📁 jenkins                     # Jenkins directory for pipeline configuration
│   ├── 📄 Jenkinsfile             # Declarative pipeline for Jenkins
│   ├── 📄 jenkins-config.groovy    # Configuration script for Jenkins setup
│   └── 📁 jobs                    # Jenkins job configuration files
│       ├── 📄 build-node-app.xml  # Jenkins job for building Node.js app
│       └── 📄 deploy-node-app.xml  # Jenkins job for deploying Node.js app

node_modules/
dist/
.env
npm-debug.log
.DS_Store
uploads/

node_modules
npm-debug.log
.git
.gitignore
Dockerfile
docker-compose.yml

NODE_ENV=production
PORT=3000
MONGO_URI=mongodb://localhost:27017/mydatabase
REDIS_URL=redis://localhost:6379
POSTGRES_URI=postgresql://user:password@localhost:5432/mydatabase
JWT_SECRET=mysecret

NODE_ENV=development
PORT=3000
MONGO_URI=mongodb://localhost:27017/mydatabase
REDIS_URL=redis://localhost:6379
POSTGRES_URI=postgresql://user:password@localhost:5432/mydatabase
JWT_SECRET=mysecret

import express from 'express';
import mongoose from 'mongoose';
import { json } from 'body-parser';
import { routes } from './routes/api';
import { connectRedis } from './config/redis.config';
import { connectMongo } from './config/mongo.config';

const app = express();
const PORT = process.env.PORT || 3000;

app.use(json());
app.use('/api', routes);

// MongoDB and Redis connection
connectMongo();
connectRedis();

app.listen(PORT, () => {
    console.log(`Server is running on port ${PORT}`);
});

#!/usr/bin/env node

import app from '../server';

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

app.listen(PORT, () => {
    console.log(`Server started on port ${PORT}`);
});

import Redis from 'ioredis';

const redis = new Redis(process.env.REDIS_URL);

export const connectRedis = () => {
    redis.on('connect', () => {
        console.log('Connected to Redis');
    });

    redis.on('error', (err) => {
        console.error('Redis error:', err);
    });
};

import mongoose from 'mongoose';

export const connectMongo = async () => {
    try {
        await mongoose.connect(process.env.MONGO_URI);
        console.log('Connected to MongoDB');
    } catch (error) {
        console.error('MongoDB connection error:', error);
    }
};

// PostgreSQL configuration
// You can set up Sequelize or pg-promise here

server {
    listen 80;

    location / {
        proxy_pass http://localhost:3000;  # Adjust according to your Node.js server
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
    }
}

import { Request, Response } from 'express';

export const getCustomers = (req: Request, res: Response) => {
    // Logic to get customers
};

export const createCustomer = (req: Request, res: Response) => {
    // Logic to create a customer
};

import { Request, Response } from 'express';

export const getProducts = (req: Request, res: Response) => {
    // Logic to get products
};

export const createProduct = (req: Request, res: Response) => {
    // Logic to create a product
};

import { Request, Response, NextFunction } from 'express';

export const authMiddleware = (req: Request, res: Response, next: NextFunction) => {
    // Authentication logic
    next();
};

import { Request, Response, NextFunction } from 'express';

export const loggerMiddleware = (req: Request, res: Response, next: NextFunction) => {
    console.log(`${req.method} ${req.url}`);
    next();
};

import mongoose, { Schema, Document } from 'mongoose';

export interface ICustomer extends Document {
    name: string;
    email: string;
}

const CustomerSchema: Schema = new Schema({
    name: { type: String, required: true },
    email: { type: String, required: true },
});

export const Customer = mongoose

.model<ICustomer>('Customer', CustomerSchema);

import mongoose, { Schema, Document } from 'mongoose';

export interface IProduct extends Document {
    title: string;
    price: number;
}

const ProductSchema: Schema = new Schema({
    title: { type: String, required: true },
    price: { type: Number, required: true },
});

export const Product = mongoose.model<IProduct>('Product', ProductSchema);

import { Router } from 'express';
import { getCustomers, createCustomer } from '../controllers/customer';
import { getProducts, createProduct } from '../controllers/product';

const router = Router();

router.get('/customers', getCustomers);
router.post('/customers', createCustomer);
router.get('/products', getProducts);
router.post('/products', createProduct);

export const routes = router;

import { getCustomers } from '../../controllers/customer';
import { Request, Response } from 'express';

describe('Customer Controller', () => {
    it('should get customers', () => {
        const req = {} as Request;
        const res = {
            send: jest.fn(),
        } as unknown as Response;

        getCustomers(req, res);
        expect(res.send).toHaveBeenCalled();
    });
});

# Use an official Node.js runtime as a parent image
FROM node:14

# Set the working directory
WORKDIR /usr/src/app

# Copy package.json and package-lock.json
COPY package*.json ./

# Install dependencies
RUN npm install

# Copy the rest of the application code
COPY . .

# Expose the application port
EXPOSE 3000

# Command to run the application
CMD [ "npm", "start" ]

version: '3.8'

services:
  node-app:
    build: .
    ports:
      - '3000:3000'
    environment:
      NODE_ENV: development
      MONGO_URI: mongodb://mongo:27017/mydatabase
      REDIS_URL: redis://redis:6379
      POSTGRES_URI: postgresql://user:password@postgres:5432/mydatabase
    depends_on:
      - mongo
      - redis
      - postgres

  mongo:
    image: mongo
    restart: always
    ports:
      - '27017:27017'

  redis:
    image: redis
    restart: always
    ports:
      - '6379:6379'

  postgres:
    image: postgres
    restart: always
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
      POSTGRES_DB: mydatabase
    ports:
      - '5432:5432'

{
    "watch": ["src"],
    "ext": "ts",
    "exec": "ts-node src/server.ts"
}

{
    "name": "node-typescript-project-with-devops",
    "version": "1.0.0",
    "scripts": {
        "start": "ts-node src/server.ts",
        "dev": "nodemon",
        "test": "jest"
    },
    "dependencies": {
        "express": "^4.17.1",
        "mongoose": "^5.10.9",
        "ioredis": "^4.17.3",
        "dotenv": "^8.2.0",
        "pg": "^8.5.1"
    },
    "devDependencies": {
        "@types/express": "^4.17.11",
        "@types/jest": "^26.0.0",
        "jest": "^26.6.0",
        "ts-jest": "^26.4.0",
        "typescript": "^4.0.3",
        "nodemon": "^2.0.4",
        "ts-node": "^9.1.1"
    }
}

---
- hosts: all
  tasks:
    - name: Ensure Node.js is installed
      apt:
        name: nodejs
        state: present

    - name: Copy application files
      copy:
        src: /path/to/your/local/project/
        dest: /path/to/remote/server/

    - name: Install dependencies
      command: npm install
      args:
        chdir: /path/to/remote/server/

apiVersion: apps/v1
kind: Deployment
metadata:
  name: node-app
spec:
  replicas: 2
  selector:
    matchLabels:
      app: node-app
  template:
    metadata:
      labels:
        app: node-app
    spec:
      containers:
        - name: node-app
          image: your-node-app-image
          ports:
            - containerPort: 3000
          env:
            - name: NODE_ENV
              value: "production"
            - name: MONGO_URI
              value: "mongodb://mongo:27017/mydatabase"
            - name: REDIS_URL
              value: "redis://redis:6379"
            - name: POSTGRES_URI
              value: "postgresql://user:password@postgres:5432/mydatabase"

apiVersion: v1
kind: Service
metadata:
  name: node-app
spec:
  type: LoadBalancer
  ports:
    - port: 80
      targetPort: 3000
  selector:
    app: node-app

pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                script {
                    docker.build("your-node-app-image")
                }
            }
        }
        stage('Deploy') {
            steps {
                script {
                    sh 'docker-compose up -d'
                }
            }
        }
    }
}

// Jenkins configuration script for initial setup