feat: initialize user management service with core functionality

- add FastAPI application with health checks and security middleware
- implement MongoDB and Redis connectivity with health monitoring
- include environment validation and configuration settings
- set up Docker and Kubernetes deployment configurations
- add user router with basic health endpoint

.env.example

@@ -0,0 +1,9 @@
+ENVIRONMENT=development
+LOG_LEVEL=INFO
+MONGO_URI=mongodb+srv://user:password@cluster.example.mongodb.net/?retryWrites=true&w=majority
+MONGO_DB_NAME=insightfy-bloom
+CACHE_URL=redis://localhost:6379/0
+CACHE_URI=
+CACHE_K=
+CACHE_DB=0
+

.gitignore

@@ -0,0 +1,82 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Testing
+.pytest_cache/
+.hypothesis/
+.coverage
+htmlcov/
+.tox/
+.nox/
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.nyc_output
+
+# Environment
+.env
+.venv*
+venv*
+ENV/
+env.bak/
+venv.bak/
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Logs
+*.log
+logs/
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Temporary files
+*.tmp
+*.temp
+
+# API validation reports (generated files)
+*_report.json
+api_validation_report.json

Dockerfile

@@ -0,0 +1,13 @@
+FROM python:3.11-slim-bullseye AS base
+ENV PYTHONUNBUFFERED=1 PYTHONDONTWRITEBYTECODE=1 PATH="/home/user/.local/bin:$PATH"
+RUN apt-get update && apt-get install -y openssl ca-certificates && rm -rf /var/lib/apt/lists/*
+RUN useradd -m -u 1000 user
+USER user
+WORKDIR /app
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade pip && pip install --no-cache-dir --upgrade -r requirements.txt
+RUN python -m spacy download en_core_web_sm
+COPY --chown=user . /app
+EXPOSE 7861
+CMD ["uvicorn", "app.app:app", "--host", "0.0.0.0", "--port", "7861", "--workers", "4", "--log-level", "info"]
+

app/__init__.py

@@ -0,0 +1,2 @@
+__all__ = ["app"]
+

app/app.py

@@ -0,0 +1,184 @@
+from contextlib import asynccontextmanager
+from fastapi import FastAPI, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+from insightfy_utils.logging import setup_logging, get_logger
+from insightfy_utils.config import load_env
+from app.routers.user import router as user_router
+from app.middleware.security_middleware import create_security_middleware
+from app.config.validation import validate_environment_variables, validate_database_isolation
+import os
+import time
+import asyncio
+
+load_env()
+_env = os.getenv("ENVIRONMENT", "development")
+_log_level = os.getenv("LOG_LEVEL") or ("WARNING" if _env == "development" else "INFO")
+setup_logging(level=_log_level, format_type="json", app_name="insightfy-bms-ms-ums")
+logger = get_logger(__name__)
+startup_time = time.time()
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    s = time.time()
+    try:
+        config_result = validate_environment_variables()
+        isolation_valid = validate_database_isolation()
+        from app.nosql import connect_stores
+        await connect_stores()
+        startup_duration = time.time() - s
+        logger.info("startup_ok", extra={"startup_duration_seconds": round(startup_duration, 3), "service": "insightfy-bms-ms-ums", "config": config_result, "isolation_valid": isolation_valid})
+    except Exception as e:
+        logger.error("startup_failed", extra={"error": str(e), "service": "insightfy-bms-ms-ums"}, exc_info=True)
+        raise
+    yield
+    try:
+        from app.nosql import disconnect_stores
+        await disconnect_stores()
+    except Exception as e:
+        logger.error("shutdown_failed", extra={"error": str(e), "service": "insightfy-bms-ms-ums"}, exc_info=True)
+
+app = FastAPI(
+    title="Insightfy BMS - User Management Service",
+    version="1.0.0",
+    description="User Management Service API for Insightfy BMS platform",
+    lifespan=lifespan,
+    redirect_slashes=False
+)
+
+app.add_middleware(
+    create_security_middleware,
+    enable_security_headers=True
+)
+
+allowed_origins = [
+    "http://localhost:3000",
+    "http://localhost:3001",
+    "https://api.insightfybloom.com",
+    "https://insightfybloom.com",
+    "https://insightfybloom.in",
+]
+if os.getenv("ENVIRONMENT") == "development":
+    allowed_origins.extend([
+        "http://localhost:8000",
+        "http://127.0.0.1:3000",
+        "http://127.0.0.1:3001",
+    ])
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=allowed_origins,
+    allow_credentials=True,
+    allow_methods=["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"],
+    allow_headers=[
+        "Accept",
+        "Accept-Language",
+        "Content-Language",
+        "Content-Type",
+        "Authorization",
+        "X-Requested-With",
+        "Origin",
+        "Cache-Control",
+        "Pragma",
+        "X-CSRF-Token",
+        "X-Request-ID",
+    ],
+    expose_headers=["X-Request-ID", "X-Service"],
+)
+
+@app.middleware("http")
+async def add_service_headers(request: Request, call_next):
+    response = await call_next(request)
+    response.headers["X-Service"] = "insightfy-bms-ms-ums"
+    response.headers["X-Service-Version"] = "1.0.0"
+    response.headers["Referrer-Policy"] = "strict-origin-when-cross-origin"
+    response.headers["X-Powered-By"] = "Insightfy"
+    return response
+
+app.include_router(
+    user_router,
+    prefix="/ums/v1/users",
+    tags=["Users"],
+    responses={404: {"description": "Not found"}, 500: {"description": "Internal error"}},
+)
+
+@app.get("/", tags=["Health"])
+async def root():
+    return {
+        "service": "Insightfy BMS - User Management Service",
+        "version": "1.0.0",
+        "status": "running",
+        "description": "User Management Service API for Insightfy BMS platform",
+        "docs_url": "/docs",
+        "health_check": "/ums/health",
+    }
+
+@app.get("/ums/health", tags=["Health"])
+async def health_check():
+    return {"status": "healthy", "service": "insightfy-bms-ms-ums", "version": "1.0.0", "timestamp": time.time()}
+
+@app.get("/ums/health/detailed", tags=["Health"])
+async def detailed_health_check():
+    try:
+        health_status = await get_comprehensive_health_status()
+        return health_status
+    except Exception as e:
+        logger.error("detailed_health_failed", extra={"error": str(e), "service": "insightfy-bms-ms-ums"}, exc_info=True)
+        return {"status": "unhealthy", "service": "insightfy-bms-ms-ums", "version": "1.0.0", "error": "Health check failed", "timestamp": time.time()}
+
+@app.get("/ums/health/metrics", tags=["Health"])
+async def health_metrics():
+    try:
+        from app.nosql import get_connection_metrics
+        connection_metrics = await get_connection_metrics()
+        return {"service": "insightfy-bms-ms-ums", "version": "1.0.0", "connection_metrics": connection_metrics, "status": "healthy", "timestamp": time.time(), "environment": os.getenv("ENVIRONMENT", "development")}
+    except Exception as e:
+        logger.error("metrics_failed", extra={"error": str(e), "service": "insightfy-bms-ms-ums"}, exc_info=True)
+        return {"service": "insightfy-bms-ms-ums", "version": "1.0.0", "error": "Failed to retrieve metrics", "status": "unhealthy", "timestamp": time.time()}
+
+@app.get("/ums/health/readiness", tags=["Health"])
+async def readiness_check():
+    try:
+        from app.nosql import ping_mongo, ping_redis
+        mongo_ready = await ping_mongo()
+        redis_ready = await ping_redis()
+        if mongo_ready and redis_ready:
+            return {"status": "ready", "service": "insightfy-bms-ms-ums", "version": "1.0.0", "timestamp": time.time()}
+        else:
+            return JSONResponse(status_code=503, content={"status": "not_ready", "service": "insightfy-bms-ms-ums", "version": "1.0.0", "components": {"mongodb": "ready" if mongo_ready else "not_ready", "redis": "ready" if redis_ready else "not_ready"}, "timestamp": time.time()})
+    except Exception as e:
+        logger.error("readiness_failed", extra={"error": str(e), "service": "insightfy-bms-ms-ums"}, exc_info=True)
+        return JSONResponse(status_code=503, content={"status": "not_ready", "service": "insightfy-bms-ms-ums", "error": "Readiness check failed", "timestamp": time.time()})
+
+@app.get("/ums/health/liveness", tags=["Health"])
+async def liveness_check():
+    current_time = time.time()
+    return {"status": "alive", "service": "insightfy-bms-ms-ums", "version": "1.0.0", "timestamp": current_time, "uptime_seconds": round(current_time - startup_time, 2)}
+
+async def get_comprehensive_health_status():
+    from app.nosql import get_database_status
+    from app.config.validation import validate_environment_variables, validate_database_isolation
+    db_status = await get_database_status()
+    try:
+        config_status = validate_environment_variables()
+        config_valid = True
+    except Exception as e:
+        config_status = {"error": str(e)}
+        config_valid = False
+    isolation_valid = validate_database_isolation()
+    overall_healthy = (db_status["overall_status"] == "healthy" and config_valid and isolation_valid)
+    return {
+        "status": "healthy" if overall_healthy else "unhealthy",
+        "service": "insightfy-bms-ms-ums",
+        "version": "1.0.0",
+        "components": {
+            "mongodb": "healthy" if db_status["mongodb"]["connected"] else "unhealthy",
+            "redis": "healthy" if db_status["redis"]["connected"] else "unhealthy",
+            "configuration": "healthy" if config_valid else "unhealthy",
+            "database_isolation": "healthy" if isolation_valid else "unhealthy",
+        },
+        "database": {"name": db_status["mongodb"]["database"], "connected": db_status["mongodb"]["connected"], "isolation_valid": isolation_valid},
+        "configuration": config_status,
+        "metrics": {"check_duration_ms": db_status["check_duration_ms"], "timestamp": db_status["timestamp"]},
+        "environment": os.getenv("ENVIRONMENT", "development"),
+    }
+

app/config/__init__.py

@@ -0,0 +1,2 @@
+__all__ = ["validation"]
+

app/config/validation.py

@@ -0,0 +1,27 @@
+import os
+
+def validate_environment_variables():
+    env = os.getenv("ENVIRONMENT", "development")
+    log_level = os.getenv("LOG_LEVEL", "INFO")
+    mongo_uri = os.getenv("MONGO_URI")
+    mongo_db = os.getenv("MONGO_DB_NAME", "insightfy-bloom").strip()
+    cache_url = os.getenv("CACHE_URL") or os.getenv("REDIS_URL")
+    cache_uri = os.getenv("CACHE_URI")
+    ok_mongo = bool(mongo_uri and mongo_db)
+    ok_cache = bool(cache_url or cache_uri)
+    if not ok_mongo:
+        raise ValueError("Missing Mongo configuration")
+    if not ok_cache:
+        raise ValueError("Missing Redis configuration")
+    return {
+        "environment": env,
+        "log_level": log_level,
+        "mongo_db": mongo_db,
+        "cache_defined": ok_cache
+    }
+
+def validate_database_isolation():
+    expected = "insightfy-bloom"
+    mongo_db = os.getenv("MONGO_DB_NAME", "insightfy-bloom").strip()
+    return mongo_db == expected
+

app/middleware/__init__.py

@@ -0,0 +1,4 @@
+from .security_middleware import create_security_middleware
+
+__all__ = ["create_security_middleware"]
+

app/middleware/security_middleware.py

@@ -0,0 +1,20 @@
+from typing import Callable
+from fastapi import Request, Response
+from starlette.middleware.base import BaseHTTPMiddleware
+
+class InsightfySecurityMiddleware(BaseHTTPMiddleware):
+    def __init__(self, app, enable_security_headers: bool = True):
+        super().__init__(app)
+        self.enable_security_headers = enable_security_headers
+
+    async def dispatch(self, request: Request, call_next: Callable):
+        response: Response = await call_next(request)
+        if self.enable_security_headers:
+            response.headers["X-Content-Type-Options"] = "nosniff"
+            response.headers["X-Frame-Options"] = "DENY"
+            response.headers["X-XSS-Protection"] = "1; mode=block"
+        return response
+
+def create_security_middleware(app, **kwargs):
+    return InsightfySecurityMiddleware(app, enable_security_headers=kwargs.get("enable_security_headers", True))
+

app/nosql.py

@@ -0,0 +1,144 @@
+from __future__ import annotations
+from datetime import datetime, timezone
+from typing import Dict, Any
+from insightfy_utils.logging import get_logger
+from insightfy_utils.db.mongo_connector import create_mongo_connection
+from insightfy_utils.db.redis_connector import create_redis_connection
+from settings import (
+    MONGO_URI,
+    MONGO_DB_NAME,
+    CACHE_URL,
+    CACHE_URI,
+    CACHE_K,
+    CACHE_DB,
+)
+
+logger = get_logger(__name__)
+
+if not MONGO_URI or not MONGO_DB_NAME:
+    raise ValueError("MongoDB settings missing: ensure MONGO_URI and MONGO_DB_NAME are set.")
+
+if not CACHE_URL and not CACHE_URI:
+    raise ValueError("Cache settings missing: set CACHE_URL or CACHE_URI.")
+
+try:
+    mongo_client, mongo_db = create_mongo_connection(
+        MONGO_URI,
+        MONGO_DB_NAME,
+        server_selection_timeout_ms=60000,
+        socket_timeout_ms=60000,
+        connect_timeout_ms=60000,
+        maxPoolSize=20,
+        retryWrites=True,
+    )
+    logger.info("MongoDB client initialized", extra={"db_name": MONGO_DB_NAME, "service": "insightfy-bms-ms-ums"})
+except Exception as e:
+    logger.error("Failed to initialize MongoDB client", exc_info=e)
+    raise
+
+def _redis_from_settings():
+    if CACHE_URL:
+        import redis.asyncio as redis
+        return redis.from_url(
+            CACHE_URL,
+            decode_responses=True,
+            socket_timeout=5,
+            socket_connect_timeout=5,
+            retry_on_timeout=True,
+            health_check_interval=30,
+        )
+    host, port_str = CACHE_URI.split(":")
+    port = int(port_str)
+    return create_redis_connection(
+        host=host,
+        port=port,
+        password=CACHE_K or None,
+        db=CACHE_DB,
+        decode_responses=True,
+        socket_timeout=5,
+        socket_connect_timeout=5,
+        retry_on_timeout=True,
+        health_check_interval=30,
+    )
+
+try:
+    redis_client = _redis_from_settings()
+    logger.info("Redis client initialized", extra={"service": "insightfy-bms-ms-ums"})
+except Exception as e:
+    logger.error("Failed to initialize Redis client", exc_info=e)
+    raise
+
+async def ping_mongo() -> bool:
+    try:
+        await mongo_db.command("ping")
+        return True
+    except Exception:
+        return False
+
+async def ping_redis() -> bool:
+    try:
+        pong = await redis_client.ping()
+        return bool(pong)
+    except Exception:
+        return False
+
+async def get_database_status() -> Dict[str, Any]:
+    start_time = datetime.now(timezone.utc)
+    mongo_status = await ping_mongo()
+    redis_status = await ping_redis()
+    end_time = datetime.now(timezone.utc)
+    total_check_time = (end_time - start_time).total_seconds() * 1000
+    return {
+        "mongodb": {"connected": mongo_status, "database": MONGO_DB_NAME, "service": "insightfy-bms-ms-ums"},
+        "redis": {"connected": redis_status, "database": CACHE_DB, "service": "insightfy-bms-ms-ums"},
+        "overall_status": "healthy" if (mongo_status and redis_status) else "unhealthy",
+        "check_duration_ms": total_check_time,
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "service": "insightfy-bms-ms-ums",
+    }
+
+async def connect_stores() -> None:
+    ok_mongo = await ping_mongo()
+    ok_redis = await ping_redis()
+    if not (ok_mongo and ok_redis):
+        raise RuntimeError("Store connectivity check failed")
+
+async def disconnect_stores() -> None:
+    try:
+        mongo_client.close()
+    except Exception:
+        pass
+    try:
+        await redis_client.close()
+    except Exception:
+        pass
+
+async def get_connection_metrics() -> Dict[str, Any]:
+    try:
+        mongo_metrics = {"status": "connected"}
+        redis_metrics = {"status": "connected"}
+        try:
+            mongo_stats = await mongo_db.command("serverStatus")
+            mongo_metrics.update({
+                "connections": mongo_stats.get("connections", {}),
+                "network": mongo_stats.get("network", {}),
+                "opcounters": mongo_stats.get("opcounters", {}),
+            })
+        except Exception:
+            mongo_metrics["note"] = "Limited metrics"
+        try:
+            redis_info = await redis_client.info()
+            redis_metrics.update({
+                "connected_clients": redis_info.get("connected_clients", 0),
+                "used_memory": redis_info.get("used_memory", 0),
+                "keyspace_hits": redis_info.get("keyspace_hits", 0),
+                "keyspace_misses": redis_info.get("keyspace_misses", 0),
+            })
+        except Exception:
+            redis_metrics["note"] = "Limited metrics"
+        return {"mongodb": mongo_metrics, "redis": redis_metrics, "timestamp": datetime.now(timezone.utc).isoformat(), "service": "insightfy-bms-ms-ums"}
+    except Exception:
+        return {"error": "Failed to retrieve metrics", "timestamp": datetime.now(timezone.utc).isoformat(), "service": "insightfy-bms-ms-ums"}
+
+db = mongo_db
+

app/routers/__init__.py

@@ -0,0 +1,2 @@
+__all__ = ["user"]
+

app/routers/user.py

@@ -0,0 +1,9 @@
+from fastapi import APIRouter
+import time
+
+router = APIRouter()
+
+@router.get("/health")
+async def user_health():
+    return {"status": "healthy", "service": "insightfy-bms-ms-ums", "version": "1.0.0", "timestamp": time.time()}
+

deployment/docker-compose.yml

@@ -0,0 +1,20 @@
+version: "3.9"
+services:
+  ms-bms-ums:
+    build: .
+    image: insightfy/ms-bms-ums:latest
+    container_name: ms-bms-ums
+    ports:
+      - "7861:7861"
+    environment:
+      - SERVICE_NAME=insightfy-bms-ms-ums
+      - MONGO_URI=${MONGO_URI}
+      - MONGO_DB_NAME=${MONGO_DB_NAME}
+      - CACHE_URL=${CACHE_URL}
+      - CACHE_URI=${CACHE_URI}
+      - CACHE_K=${CACHE_K}
+      - CACHE_DB=${CACHE_DB}
+      - ENVIRONMENT=${ENVIRONMENT:-development}
+      - LOG_LEVEL=${LOG_LEVEL:-INFO}
+    restart: unless-stopped
+

deployment/kubernetes/bms-ums-deployment.yaml

@@ -0,0 +1,128 @@
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: ms-bms-ums
+  namespace: insightfy-app
+  labels:
+    app: ms-bms-ums
+    service: bms-ums
+    version: "1.0.0"
+    component: microservice
+spec:
+  replicas: 2
+  strategy:
+    type: RollingUpdate
+    rollingUpdate:
+      maxUnavailable: 1
+      maxSurge: 1
+  selector:
+    matchLabels:
+      app: ms-bms-ums
+  template:
+    metadata:
+      labels:
+        app: ms-bms-ums
+        service: bms-ums
+        version: "1.0.0"
+      annotations:
+        prometheus.io/scrape: "true"
+        prometheus.io/port: "7861"
+        prometheus.io/path: "/ums/health/metrics"
+    spec:
+      containers:
+        - name: bms-ums
+          image: insightfy/ms-bms-ums:latest
+          imagePullPolicy: IfNotPresent
+          ports:
+            - containerPort: 7861
+              name: http
+              protocol: TCP
+          envFrom:
+            - configMapRef:
+                name: shared-env
+            - secretRef:
+                name: app-secrets
+          env:
+            - name: SERVICE_NAME
+              value: "insightfy-bms-ms-ums"
+            - name: MONGO_DB_NAME
+              value: "insightfy-bloom"
+            - name: ENVIRONMENT
+              value: "production"
+            - name: LOG_LEVEL
+              value: "INFO"
+          readinessProbe:
+            httpGet:
+              path: /ums/health/readiness
+              port: 7861
+            initialDelaySeconds: 10
+            periodSeconds: 15
+          livenessProbe:
+            httpGet:
+              path: /ums/health/liveness
+              port: 7861
+            initialDelaySeconds: 20
+            periodSeconds: 30
+          resources:
+            requests:
+              cpu: "100m"
+              memory: "128Mi"
+            limits:
+              cpu: "500m"
+              memory: "512Mi"
+---
+apiVersion: policy/v1
+kind: PodDisruptionBudget
+metadata:
+  name: ms-bms-ums-pdb
+  namespace: insightfy-app
+  labels:
+    app: ms-bms-ums
+    service: bms-ums
+spec:
+  minAvailable: 1
+  selector:
+    matchLabels:
+      app: ms-bms-ums
+---
+apiVersion: networking.k8s.io/v1
+kind: NetworkPolicy
+metadata:
+  name: ms-bms-ums-netpol
+  namespace: insightfy-app
+  labels:
+    app: ms-bms-ums
+    service: bms-ums
+spec:
+  podSelector:
+    matchLabels:
+      app: ms-bms-ums
+  policyTypes:
+    - Ingress
+    - Egress
+  ingress:
+    - from:
+        - namespaceSelector:
+            matchLabels:
+              name: insightfy-app
+        - namespaceSelector:
+            matchLabels:
+              name: ingress-nginx
+      ports:
+        - protocol: TCP
+          port: 7861
+  egress:
+    - to: []
+      ports:
+        - protocol: TCP
+          port: 27017
+        - protocol: TCP
+          port: 6379
+        - protocol: TCP
+          port: 443
+        - protocol: TCP
+          port: 80
+        - protocol: UDP
+          port: 53
+

requirements.txt

@@ -0,0 +1,22 @@
+fastapi>=0.104.0
+uvicorn[standard]>=0.24.0
+pydantic>=2.0.0
+pydantic-settings>=2.0.0
+motor>=3.3.0
+redis>=5.0.0
+python-jose[cryptography]>=3.3.0
+passlib[bcrypt]>=1.7.4
+python-multipart>=0.0.6
+python-dotenv>=1.0.0
+insightfy-utils>=0.1.0
+pytest>=7.0.0
+pytest-asyncio>=0.21.0
+hypothesis>=6.0.0
+email-validator>=2.0.0
+httpx>=0.24.0
+databases>=0.8.0
+pandas>=1.5.0
+bleach>=6.0.0
+psutil>=5.9.0
+spacy>=3.5.0
+

settings.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+from urllib.parse import quote_plus, urlencode
+import os
+from insightfy_utils.config import load_env
+load_env()
+SECRET_KEY = os.getenv("SECRET_KEY")
+ALGORITHM = os.getenv("ALGORITHM", "HS256")
+MONGO_URI = os.getenv('MONGO_URI')
+MONGO_DB_NAME = os.getenv("MONGO_DB_NAME", "insightfy-bloom").strip()
+
+def _sanitize_mongo_uri(uri: str | None) -> str | None:
+    if not uri:
+        return uri
+    uri = uri.replace("??", "?")
+    if "?" in uri:
+        base_uri, options_part = uri.split("?", 1)
+        options = options_part.split("&")
+        valid_options = []
+        for opt in options:
+            if not opt:
+                continue
+            key = opt.split("=")[0] if "=" in opt else opt
+            if key in ["?ssl", "ssl_cert_reqs"]:
+                continue
+            valid_options.append(opt)
+        return f"{base_uri}?{'&'.join(valid_options)}"
+    return uri
+
+MONGO_URI = _sanitize_mongo_uri(os.getenv('MONGO_URI'))
+CACHE_URL = os.getenv("CACHE_URL") or os.getenv("REDIS_URL")
+CACHE_URI = os.getenv('CACHE_URI')
+CACHE_K = os.getenv('CACHE_K')
+CACHE_DB = int(os.getenv("CACHE_DB", "0"))
+