Debate the truth about with TypeScript vs Python and Monorepo vs Polyrepo

// packages/users-service/src/index.ts
// TypeScript 5.3.3, Node 20.11.0, Fastify 4.24.0, Turborepo 1.11.2
import Fastify, { FastifyRequest, FastifyReply } from 'fastify';
import { Type } from '@sinclair/typebox';
import { TypeBoxTypeProvider } from '@fastify/typebox-type-provider';
import { User, CreateUserInput, GetUserParams } from '@my-org/shared-types'; // Shared monorepo package
import { UserService } from './user.service';
import { logger } from './logger';

// Initialize Fastify with TypeBox type provider for runtime + compile-time type safety
const server = Fastify({
  logger: true,
}).withTypeProvider();

// Instantiate service layer (in monorepo, this could import from another local package)
const userService = new UserService();

// Define schemas for request validation (shared with frontend via @my-org/shared-types)
const createUserSchema = Type.Object({
  name: Type.String({ minLength: 2 }),
  email: Type.String({ format: 'email' }),
  role: Type.Union([Type.Literal('admin'), Type.Literal('editor'), Type.Literal('viewer')]),
});

const getUserSchema = Type.Object({
  id: Type.String({ pattern: '^[0-9a-fA-F]{24}$' }), // MongoDB ObjectId pattern
});

// Health check endpoint (no auth required)
server.get('/health', async (request: FastifyRequest, reply: FastifyReply) => {
  try {
    const isDbConnected = await userService.checkDbHealth();
    if (!isDbConnected) {
      reply.code(503).send({ status: 'unhealthy', details: 'Database connection failed' });
      return;
    }
    reply.code(200).send({ status: 'healthy', timestamp: new Date().toISOString() });
  } catch (error) {
    logger.error({ error }, 'Health check failed');
    reply.code(500).send({ error: 'Internal server error' });
  }
});

// Create user endpoint with compile-time and runtime type validation
server.post<{ Body: CreateUserInput }>(
  '/users',
  {
    schema: {
      body: createUserSchema,
      response: {
        201: Type.Object({
          id: Type.String(),
          name: Type.String(),
          email: Type.String(),
          role: Type.String(),
          createdAt: Type.String({ format: 'date-time' }),
        }),
        400: Type.Object({ error: Type.String() }),
        409: Type.Object({ error: Type.String() }),
      },
    },
  },
  async (request, reply) => {
    try {
      const userInput = request.body; // TypeScript knows this is CreateUserInput
      const existingUser = await userService.findByEmail(userInput.email);
      if (existingUser) {
        reply.code(409).send({ error: `User with email ${userInput.email} already exists` });
        return;
      }
      const newUser = await userService.create(userInput);
      reply.code(201).send(newUser);
    } catch (error) {
      logger.error({ error, body: request.body }, 'Failed to create user');
      reply.code(500).send({ error: 'Internal server error' });
    }
  }
);

// Get user by ID endpoint
server.get<{ Params: GetUserParams }>(
  '/users/:id',
  {
    schema: {
      params: getUserSchema,
      response: {
        200: Type.Object({
          id: Type.String(),
          name: Type.String(),
          email: Type.String(),
          role: Type.String(),
          createdAt: Type.String({ format: 'date-time' }),
        }),
        404: Type.Object({ error: Type.String() }),
      },
    },
  },
  async (request, reply) => {
    try {
      const { id } = request.params; // Typed as GetUserParams.id
      const user = await userService.findById(id);
      if (!user) {
        reply.code(404).send({ error: `User with ID ${id} not found` });
        return;
      }
      reply.code(200).send(user);
    } catch (error) {
      logger.error({ error, params: request.params }, 'Failed to get user');
      reply.code(500).send({ error: 'Internal server error' });
    }
  }
);

// Global error handler
server.setErrorHandler((error, request, reply) => {
  logger.error({ error }, 'Unhandled error');
  reply.code(500).send({ error: 'Internal server error' });
});

// Start server
const start = async () => {
  try {
    await server.listen({ port: 3000, host: '0.0.0.0' });
    logger.info('Users service listening on port 3000');
  } catch (error) {
    logger.error({ error }, 'Failed to start server');
    process.exit(1);
  }
};

start();

# users-service/main.py
# Python 3.12.1, FastAPI 0.109.0, Pydantic 2.5.3, Uvicorn 0.27.0
from fastapi import FastAPI, HTTPException, Depends, Request
from fastapi.responses import JSONResponse
from pydantic import BaseModel, EmailStr, constr, validator
from typing import Literal, Optional
import motor.motor_asyncio
import logging
from datetime import datetime
import os

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

# Initialize FastAPI app
app = FastAPI(
    title="Users Service",
    description="Polyrepo users service for Python backend",
    version="1.0.0"
)

# MongoDB connection (polyrepo: each service manages its own DB connection)
client = motor.motor_asyncio.AsyncIOMotorClient(
    os.getenv("MONGO_URI", "mongodb://localhost:27017")
)
db = client.users_db

# Pydantic models (no shared types across repos, so redefine here)
class CreateUserInput(BaseModel):
    name: constr(min_length=2)
    email: EmailStr
    role: Literal["admin", "editor", "viewer"]

    @validator('role')
    def role_must_be_valid(cls, v):
        if v not in ["admin", "editor", "viewer"]:
            raise ValueError("Role must be admin, editor, or viewer")
        return v

class UserResponse(BaseModel):
    id: str
    name: str
    email: str
    role: str
    created_at: datetime

class HealthResponse(BaseModel):
    status: str
    timestamp: datetime
    details: Optional[str] = None

# Service layer (no shared packages, so inline or separate file in same repo)
class UserService:
    def __init__(self, db):
        self.users = db.users

    async def check_db_health(self) -> bool:
        try:
            await self.users.database.command("ping")
            return True
        except Exception as e:
            logger.error(f"DB health check failed: {e}")
            return False

    async def find_by_email(self, email: str) -> Optional[dict]:
        return await self.users.find_one({"email": email})

    async def find_by_id(self, user_id: str) -> Optional[dict]:
        return await self.users.find_one({"_id": user_id})

    async def create(self, user_input: CreateUserInput) -> dict:
        user_dict = user_input.dict()
        user_dict["created_at"] = datetime.utcnow()
        result = await self.users.insert_one(user_dict)
        user_dict["id"] = str(result.inserted_id)
        return user_dict

user_service = UserService(db)

# Health check endpoint
@app.get("/health", response_model=HealthResponse)
async def health_check():
    try:
        is_healthy = await user_service.check_db_health()
        if not is_healthy:
            return JSONResponse(
                status_code=503,
                content=HealthResponse(
                    status="unhealthy",
                    timestamp=datetime.utcnow(),
                    details="Database connection failed"
                ).dict()
            )
        return HealthResponse(status="healthy", timestamp=datetime.utcnow())
    except Exception as e:
        logger.error(f"Health check failed: {e}")
        raise HTTPException(status_code=500, detail="Internal server error")

# Create user endpoint
@app.post("/users", response_model=UserResponse, status_code=201)
async def create_user(user_input: CreateUserInput):
    try:
        existing_user = await user_service.find_by_email(user_input.email)
        if existing_user:
            raise HTTPException(
                status_code=409,
                detail=f"User with email {user_input.email} already exists"
            )
        new_user = await user_service.create(user_input)
        return UserResponse(**new_user)
    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"Failed to create user: {e}", exc_info=True)
        raise HTTPException(status_code=500, detail="Internal server error")

# Get user by ID endpoint
@app.get("/users/{user_id}", response_model=UserResponse)
async def get_user(user_id: str):
    try:
        # Basic ObjectId validation (no shared type, so duplicate logic across services)
        if not len(user_id) == 24 or not all(c in "0123456789abcdefABCDEF" for c in user_id):
            raise HTTPException(status_code=400, detail="Invalid user ID format")
        user = await user_service.find_by_id(user_id)
        if not user:
            raise HTTPException(status_code=404, detail=f"User with ID {user_id} not found")
        return UserResponse(**user)
    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"Failed to get user: {e}", exc_info=True)
        raise HTTPException(status_code=500, detail="Internal server error")

# Global exception handler
@app.exception_handler(Exception)
async def global_exception_handler(request: Request, exc: Exception):
    logger.error(f"Unhandled exception: {exc}", exc_info=True)
    return JSONResponse(
        status_code=500,
        content={"error": "Internal server error"}
    )

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=3000)

// packages/order-service/src/validate-user.ts
// TypeScript Monorepo Example: Shared types catch breaking changes at compile time
import { User, CreateUserInput } from '@my-org/shared-types'; // Shared from monorepo root
import { fetchUser } from './user.client'; // Client to users service (also in monorepo)

// In monorepo, if @my-org/shared-types updates CreateUserInput to add `department`
// This file will fail to compile immediately, before any tests run
async function processOrder(userId: string, orderDetails: { total: number }) {
  try {
    // Fetch user from users service (same monorepo, types are shared)
    const user: User = await fetchUser(userId); // Type error if User type changes

    // Validate that user has permission to place order (type-safe check)
    if (user.role === 'viewer') {
      throw new Error('Viewers cannot place orders');
    }

    // Create audit log with user details (shared type ensures fields exist)
    const auditLog = {
      userId: user.id,
      userEmail: user.email, // Type error if email field is removed from User
      userName: user.name,
      orderTotal: orderDetails.total,
      timestamp: new Date().toISOString(),
    };

    // Send audit log to audit service (another monorepo package)
    await fetch('http://localhost:3002/audit', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(auditLog), // Audit service expects this shape, shared type
    });

    return { success: true, orderId: 'ord_123' };
  } catch (error) {
    console.error('Order processing failed:', error);
    // TypeScript catches if error is not Error type (with strict: true)
    if (error instanceof Error) {
      throw new Error(`Order failed: ${error.message}`);
    }
    throw new Error('Order failed: Unknown error');
  }
}

// Python Polyrepo Equivalent (no shared types, breaking changes caught at runtime)
// This would be in a separate order-service repo, no shared code with users-service
// import requests
// import json
// from pydantic import BaseModel, ValidationError
//
// class User(BaseModel):
//     id: str
//     email: str
//     name: str
//     role: str
//     created_at: str
//
// async def process_order(user_id: str, order_details: dict):
//     try:
//         # Fetch user from users service (separate repo, no shared types)
//         response = requests.get(f'http://localhost:3000/users/{user_id}')
//         response.raise_for_status()
//         user_data = response.json()
//
//         # No compile-time check: if users service removes email field, this fails at runtime
//         user = User(**user_data) # ValidationError thrown here if fields missing
//
//         if user.role == 'viewer':
//             raise ValueError('Viewers cannot place orders')
//
//         audit_log = {
//             'user_id': user.id,
//             'user_email': user.email, # If users service renames email to email_address, this is None
//             'user_name': user.name,
//             'order_total': order_details['total'],
//             'timestamp': datetime.utcnow().isoformat()
//         }
//
//         # No type check: if audit service expects user_email instead of userEmail, fails at runtime
//         requests.post('http://localhost:3002/audit', json=audit_log)
//
//         return {'success': True, 'order_id': 'ord_123'}
//     except ValidationError as e:
//         print(f'User data validation failed: {e}')
//         raise
//     except Exception as e:
//         print(f'Order processing failed: {e}')
//         raise

{
  "pipeline": {
    "build": {
      "dependsOn": ["^build"],
      "outputs": ["dist/**", "build/**", ".next/**"],
      "cache": true
    },
    "test": {
      "dependsOn": ["build"],
      "outputs": ["coverage/**"],
      "cache": true
    },
    "lint": {
      "cache": true
    },
    "dev": {
      "cache": false
    }
  }
}

import pytest
from pact import Consumer, Provider
from order_service.user_client import fetch_user

# Define consumer (order service) and provider (users service)
pact = Consumer('OrderService').has_pact_with(
    Provider('UserService'),
    pact_dir='./pacts'
)

def test_fetch_user_contract():
    # Define expected request and response
    expected_user = {
        'id': '507f1f77bcf86cd799439011',
        'email': 'test@example.com',
        'name': 'Test User',
        'role': 'editor'
    }

    pact.given('User with ID 507f1f77bcf86cd799439011 exists') \
        .upon_receiving('A request for user details') \
        .with_request('GET', f'/users/507f1f77bcf86cd799439011') \
        .will_respond_with(200, body=expected_user)

    with pact:
        # Run client code that calls the users service
        user = fetch_user('507f1f77bcf86cd799439011')
        assert user['email'] == expected_user['email']

{
  "files": [],
  "references": [
    { "path": "./packages/shared-types" },
    { "path": "./packages/users-service" },
    { "path": "./packages/order-service" },
    { "path": "./packages/frontend" }
  ],
  "compilerOptions": {
    "strict": true,
    "target": "ES2022",
    "module": "Node16",
    "moduleResolution": "Node16",
    "esModuleInterop": true,
    "skipLibCheck": true
  }
}