Jassif Team Institution

# Windows Command Prompt
set NODE_ENV=production
node app.js

# Windows PowerShell
$env:NODE_ENV="production"
node app.js

# Linux/macOS
export NODE_ENV=production
node app.js

{
  "scripts": {
    "start": "NODE_ENV=production node app.js",
    "dev": "NODE_ENV=development nodemon app.js",
    "test": "NODE_ENV=test jest"
  }
}

npm install --save-dev cross-env

{
  "scripts": {
    "start": "cross-env NODE_ENV=production node app.js"
  }
}

// Simple environment check
const isProduction = process.env.NODE_ENV === 'production';
const isDevelopment = !isProduction;

// Environment-specific configuration
const config = {
  port: process.env.PORT || 3000,
  db: {
    host: isProduction ? 'prod-db.example.com' : 'localhost',
    name: isProduction ? 'myapp_prod' : 'myapp_dev'
  },
  logging: {
    level: isProduction ? 'warn' : 'debug',
    prettyPrint: !isProduction
  }
};

// Express.js example
const express = require('express');
const app = express();

// Install dotenv: npm install dotenv
require('dotenv').config(); // Loads .env file contents into process.env

// config.js
module.exports = {
  development: {
    port: 8080,
    database: 'mongodb://localhost:27017/myapp_dev',
    logLevel: 'debug',
    apiKeys: {
      thirdPartyService: process.env.DEV_API_KEY
    }
  },
  test: {
    port: 3001,
    database: 'mongodb://localhost:27017/myapp_test',
    logLevel: 'info',
    apiKeys: {
      thirdPartyService: process.env.TEST_API_KEY
    }
  },
  production: {
    port: process.env.PORT || 8080,
    database: process.env.DATABASE_URL,
    logLevel: 'error',
    apiKeys: {
      thirdPartyService: process.env.PROD_API_KEY
    }
  }
};

const env = process.env.NODE_ENV || 'development';
module.exports.current = module.exports[env];

const express = require('express');
const app = express();

app.get('/api/data', (req, res) => {
  try {
    // Some operation that might fail
    throw new Error('Something went wrong');
  } catch (error) {
    // Log the error internally (always do this)
    console.error('Error occurred:', error);

    // Provide different responses based on environment
    if (process.env.NODE_ENV === 'production') {
      // In production: generic error message
      return res.status(500).json({
        error: 'An unexpected error occurred'
      });
    } else {
      // In development: detailed error information
      return res.status(500).json({
        error: error.message,
        stack: error.stack,
        details: 'This detailed error is only shown in development'
      });
    }
  }
});

app.listen(8080);

const winston = require('winston');

// Define different logging configurations per environment
const logger = winston.createLogger({
  level: process.env.NODE_ENV === 'production' ? 'info' : 'debug',
  format: process.env.NODE_ENV === 'production'
    ? winston.format.json()
    : winston.format.combine(
        winston.format.colorize(),
        winston.format.simple()
      ),
  defaultMeta: { service: 'user-service' },
  transports: [
    // Always log errors to a file
    new winston.transports.File({
      filename: 'error.log',
      level: 'error'
    }),

    // In production, save all logs to a file
    ...(process.env.NODE_ENV === 'production'
      ? [new winston.transports.File({ filename: 'combined.log' })]
      : []),

    // In development, log to the console
    ...(process.env.NODE_ENV !== 'production'
      ? [new winston.transports.Console()]
      : [])
  ],
});

logger.info('Application started');
logger.debug('This debug message appears only in development');

const cluster = require('cluster');
const http = require('http');
const numCPUs = require('os').cpus().length;

if (process.env.NODE_ENV === 'production' && cluster.isMaster) {
  console.log(`Master ${process.pid} is running`);

  // Fork workers
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }

  cluster.on('exit', (worker, code, signal) => {
    console.log(`Worker ${worker.process.pid} died`);
    // Replace the dead worker
    cluster.fork();
  });
} else {
  // Workers can share a TCP connection
  http.createServer((req, res) => {
    res.writeHead(200);
    res.end('Hello World\n');
  }).listen(8000);

  console.log(`Worker ${process.pid} started`);
}

const express = require('express');
const helmet = require('helmet');
const rateLimit = require('express-rate-limit');
const app = express();

// Apply security middleware in production
if (process.env.NODE_ENV === 'production') {
  // Set security headers
  app.use(helmet());

  // Enable rate limiting
  const limiter = rateLimit({
    windowMs: 15 * 60 * 1000, // 15 minutes
    max: 100, // limit each IP to 100 requests per windowMs
    message: 'Too many requests from this IP, please try again later'
  });
  app.use('/api/', limiter);

  // Force HTTPS
  app.use((req, res, next) => {
    if (req.header('x-forwarded-proto') !== 'https') {
      res.redirect(`https://${req.header('host')}${req.url}`);
    } else {
      next();
    }
  });
}

app.get('/', (req, res) => {
  res.send('Hello World');
});

app.listen(8080);

const path = require('path');
const TerserPlugin = require('terser-webpack-plugin');

module.exports = (env, argv) => {
  const isProduction = argv.mode === 'production';

  return {
    entry: './src/index.js',
    output: {
      path: path.resolve(__dirname, 'dist'),
      filename: isProduction
        ? 'bundle.[contenthash].js'
        : 'bundle.js'
    },
    mode: isProduction ? 'production' : 'development',
    // Generate source maps in development but not production
    devtool: isProduction ? false : 'eval-source-map',
    optimization: {
      minimize: isProduction,
      minimizer: isProduction ? [
        new TerserPlugin({
          terserOptions: {
            compress: true,
            mangle: true
          }
        })
      ] : [],
    },
    // Add development server configuration for non-production
    ...(isProduction ? {} : {
      devServer: {
        contentBase: './dist',
        hot: true
      }
    })
  };
};

const featureFlags = {
  development: {
    newUserInterface: true,
    experimentalFeature: true,
    betaAnalytics: true
  },
  production: {
    newUserInterface: false,
    experimentalFeature: false,
    betaAnalytics: true
  }
};

const env = process.env.NODE_ENV || 'development';
const features = featureFlags[env];

if (features.newUserInterface) {
  // Enable the new UI
}