General cleanup (#35)

* Format Code and improve formatting

- Formatted the code
- Fixed the `pyproject.toml` on the backend so that it actually reformats code when we run a command like `uv run ruff format`

* Updated package.json when running dev and preview

Updated package.json when running dev and preview. Now it explicitly runs it with a host and port. The main part of this was running it with host `127.0.0.1`, which aligns with our configurations of detecting when we're running something in Development server.'

* Removed remaining H2S script files

Had some remaining H2S related files that were related to how we tried to do client side
calculations for H2S. We've moved those calculations to the server side so we don't need these files anymore.

* Prevented archived users from being authenticated

- Fixed makefile as well

Author: Knguyen-dev

Makefile

@@ -11,6 +11,7 @@ TAG=latest
 up:
 	@echo "Building the project..."
 	@cd frontend && npm install && npm run build
+	@cd backend && uv run ruff format
 	@echo "Starting up the project with docker compose..."
 	docker compose -f $(COMPOSE_FILE) -p $(PROJECT_NAME) up --build -d
 
@@ -38,6 +39,7 @@ frontend:
 
 build:
 	@echo "Building the project..."
+	@cd backend && uv run ruff format
 	@cd frontend && npm install && npm run build
 	docker build -t $(IMAGE_NAME):$(TAG) .
 

README.md

@@ -16,6 +16,8 @@ make down # Shutsdown all of the Docker Compose containers
 make logs # Get the logs from the Docker Compose deployment
 ```
 
+**Note:** Building the project with `make up` or `make build` will format the frontend and backend. The backend is done through a command, whilst the frontend is done automatically since we're using RS as a build tool with `biome.json`.
+
 ### Simulating a prod environment
 This one is mainly useful locally if you're wanting to see if a healthcheck is failing or some other broader *deployment* issue is happening. You should be testing your application with this (w/ IU's VPN for the database connection) before making a PR.
 ```sh

backend/app/__init__.py

@@ -17,23 +17,24 @@
 
 # Setup middleware layer; for prod we should probably just let the only the client be the allowed origin
 app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
+  CORSMiddleware,
+  allow_origins=["*"],
+  allow_credentials=True,
+  allow_methods=["*"],
+  allow_headers=["*"],
 )
 
+
 # The motivation is to catch all HTTPExceptions and return a consistent JSON response.
 # NOTE: If changed, please reflect those changes on frontend as well. It's simple just go to the fetch
 # functions for each calc.
 @app.exception_handler(HTTPException)
 async def custom_http_exception_handler(request: Request, exc: HTTPException):
-    err_content = {"status_code": exc.status_code, "message": exc.detail}
-    return JSONResponse(
-        status_code=exc.status_code,
-        content=err_content,
-    )
+  err_content = {"status_code": exc.status_code, "message": exc.detail}
+  return JSONResponse(
+    status_code=exc.status_code,
+    content=err_content,
+  )
 
 
 app.include_router(minerals.router, tags=["minerals"])
@@ -48,10 +49,11 @@ async def custom_http_exception_handler(request: Request, exc: HTTPException):
 # Serve all static files (JS, CSS, images, etc.)
 app.mount("/static", StaticFiles(directory="/app/dist/static"), name="static")
 
+
 # Serve index.html for root and any unmatched frontend routes
 @app.get("/{full_path:path}", include_in_schema=False)
 async def serve_spa(full_path: str):
-    index_path = os.path.join("/app/dist", "index.html")
-    if os.path.exists(index_path):
-        return FileResponse(index_path)
-    return {"error": "index.html not found"}
+  index_path = os.path.join("/app/dist", "index.html")
+  if os.path.exists(index_path):
+    return FileResponse(index_path)
+  return {"error": "index.html not found"}

backend/app/config.py

@@ -4,38 +4,38 @@
 
 
 class Settings(BaseSettings):
-    """Application settings loaded from environment variables."""
-    
-    # Database settings
-    DB_HOST: str = os.getenv("DB_HOST", "")
-    DB_PORT: str = os.getenv("DB_PORT", "3306")
-    DB_NAME: str = os.getenv("DB_NAME", "")
-    DB_USER: str = os.getenv("DB_USER", "")
-    DB_PASS: str = os.getenv("DB_PASS", "")
-    
-    # Authentication settings
-    CILOGON_CLIENT_ID: str = os.getenv("CILOGON_CLIENT_ID", "")
-    CILOGON_CLIENT_SECRET: str = os.getenv("CILOGON_CLIENT_SECRET", "")
-    CILOGON_REDIRECT_URI: str = os.getenv("CILOGON_REDIRECT_URI", "")
-    
-    # Email settings - Mailtrap
-    SMTP_HOST: str = os.getenv("SMTP_HOST", "smtp.mailtrap.io")
-    SMTP_PORT: int = int(os.getenv("SMTP_PORT", "2525"))
-    SMTP_USER: str = os.getenv("SMTP_USER", "")
-    SMTP_PASSWORD: str = os.getenv("SMTP_PASSWORD", "")
-    EMAIL_FROM: str = os.getenv("EMAIL_FROM", "noreply@js2-gateway.example.com")
-    EMAIL_FROM_NAME: str = os.getenv("EMAIL_FROM_NAME", "JS2 Geochemical Gateway")
-    
-    # Admin notification email (temporary hardcoded value)
-    ADMIN_NOTIFICATION_EMAIL: str = "callsutt@iu.edu"
-    
-    # Secret key for JWT token generation
-    SECRET_KEY: str = os.getenv("SECRET_KEY", "supersecretkey123changemelater")
-    ALGORITHM: str = "HS256"
-    ACCESS_TOKEN_EXPIRE_MINUTES: int = 60 * 24 * 7  # 1 week
-    
-    # Frontend URL for email links
-    FRONTEND_URL: str = os.getenv("FRONTEND_URL", "http://localhost:4000")
-
-
-settings = Settings()
+  """Application settings loaded from environment variables."""
+
+  # Database settings
+  DB_HOST: str = os.getenv("DB_HOST", "")
+  DB_PORT: str = os.getenv("DB_PORT", "3306")
+  DB_NAME: str = os.getenv("DB_NAME", "")
+  DB_USER: str = os.getenv("DB_USER", "")
+  DB_PASS: str = os.getenv("DB_PASS", "")
+
+  # Authentication settings
+  CILOGON_CLIENT_ID: str = os.getenv("CILOGON_CLIENT_ID", "")
+  CILOGON_CLIENT_SECRET: str = os.getenv("CILOGON_CLIENT_SECRET", "")
+  CILOGON_REDIRECT_URI: str = os.getenv("CILOGON_REDIRECT_URI", "")
+
+  # Email settings - Mailtrap
+  SMTP_HOST: str = os.getenv("SMTP_HOST", "smtp.mailtrap.io")
+  SMTP_PORT: int = int(os.getenv("SMTP_PORT", "2525"))
+  SMTP_USER: str = os.getenv("SMTP_USER", "")
+  SMTP_PASSWORD: str = os.getenv("SMTP_PASSWORD", "")
+  EMAIL_FROM: str = os.getenv("EMAIL_FROM", "noreply@js2-gateway.example.com")
+  EMAIL_FROM_NAME: str = os.getenv("EMAIL_FROM_NAME", "JS2 Geochemical Gateway")
+
+  # Admin notification email (temporary hardcoded value)
+  ADMIN_NOTIFICATION_EMAIL: str = "callsutt@iu.edu"
+
+  # Secret key for JWT token generation
+  SECRET_KEY: str = os.getenv("SECRET_KEY", "supersecretkey123changemelater")
+  ALGORITHM: str = "HS256"
+  ACCESS_TOKEN_EXPIRE_MINUTES: int = 60 * 24 * 7  # 1 week
+
+  # Frontend URL for email links
+  FRONTEND_URL: str = os.getenv("FRONTEND_URL", "http://localhost:4000")
+
+
+settings = Settings()

backend/app/db/__init__.py

@@ -2,4 +2,4 @@
 from app.db.database import get_session, engine
 
 # This makes these imports available from the db package
-__all__ = ["User", "get_session", "engine"]
+__all__ = ["User", "get_session", "engine"]

backend/app/db/database.py

@@ -19,125 +19,128 @@
 
 
 def test_raw_connection():
-    """Test the raw MySQL connection without SQLAlchemy to diagnose issues."""
-    logger.info(
-        f"Testing direct MySQL connection to {DB_HOST}:{DB_PORT}/{DB_NAME} as {DB_USER}"
+  """Test the raw MySQL connection without SQLAlchemy to diagnose issues."""
+  logger.info(
+    f"Testing direct MySQL connection to {DB_HOST}:{DB_PORT}/{DB_NAME} as {DB_USER}"
+  )
+  try:
+    conn = pymysql.connect(
+      host=DB_HOST,
+      port=int(DB_PORT),
+      user=DB_USER,
+      password=DB_PASS,
+      database=DB_NAME,
+      connect_timeout=5,
     )
-    try:
-        conn = pymysql.connect(
-            host=DB_HOST,
-            port=int(DB_PORT),
-            user=DB_USER,
-            password=DB_PASS,
-            database=DB_NAME,
-            connect_timeout=5,
-        )
-        with conn.cursor() as cursor:
-            cursor.execute("SELECT 1")
-            result = cursor.fetchone()
-            logger.info(f"Direct MySQL connection successful: {result}")
-        conn.close()
-        return True
-    except pymysql.Error as e:
-        error_code = e.args[0] if len(e.args) > 0 else "unknown"
-        if error_code == 1045:  # Access denied error
-            logger.error(f"MySQL access denied. Check credentials for user {DB_USER}.")
-        else:
-            logger.error(f"MySQL connection error (code {error_code}): {e}")
-        return False
+    with conn.cursor() as cursor:
+      cursor.execute("SELECT 1")
+      result = cursor.fetchone()
+      logger.info(f"Direct MySQL connection successful: {result}")
+    conn.close()
+    return True
+  except pymysql.Error as e:
+    error_code = e.args[0] if len(e.args) > 0 else "unknown"
+    if error_code == 1045:  # Access denied error
+      logger.error(f"MySQL access denied. Check credentials for user {DB_USER}.")
+    else:
+      logger.error(f"MySQL connection error (code {error_code}): {e}")
+    return False
 
 
 # Log connection details for debugging (without password)
 logger.info(
-    f"Database connection info - Host: {DB_HOST}, Port: {DB_PORT}, DB: {DB_NAME}, User: {DB_USER}"
+  f"Database connection info - Host: {DB_HOST}, Port: {DB_PORT}, DB: {DB_NAME}, User: {DB_USER}"
 )
 
 # Initialize engine as None
 engine = None
 
 # Check if all required environment variables are set
 if not all([DB_HOST, DB_PORT, DB_NAME, DB_USER, DB_PASS]):
-    logger.warning(
-        "Missing database environment variables. Database features will be disabled."
-    )
+  logger.warning(
+    "Missing database environment variables. Database features will be disabled."
+  )
 else:
-    # Test raw connection first
-    raw_connection_ok = test_raw_connection()
-
-    if raw_connection_ok:
-        # If raw connection works, try SQLAlchemy
-        try:
-            # Create database connection URL with proper escaping and formatting
-            # Make sure we're properly URL encoding special characters in the password
-            encoded_password = urllib.parse.quote_plus(DB_PASS)
-
-            # Create the connection URL - use proper format to avoid the @ symbol issue
-            DATABASE_URL = f"mysql+pymysql://{DB_USER}:{encoded_password}@{DB_HOST}:{DB_PORT}/{DB_NAME}"
-
-            logger.info(
-                f"Creating SQLAlchemy engine with host: {DB_HOST}, port: {DB_PORT}, db: {DB_NAME}"
-            )
-
-            # Create SQLModel engine with minimal options
-            engine = create_engine(
-                DATABASE_URL,
-                echo=False,
-                pool_recycle=3600,  # Recycle connections after an hour
-                pool_pre_ping=False,  # Disable connection testing
-            )
-
-            # Basic connection test using proper SQLAlchemy 2.0 syntax
-            try:
-                with engine.connect() as conn:
-                    # Using text() to create a SQL expression
-                    result = conn.execute(text("SELECT 1"))
-                    logger.info(f"SQLAlchemy database connection test successful: {result.fetchone()}")
-            except Exception as e:
-                logger.error(f"SQLAlchemy database connection test failed: {e}")
-                # Keep the engine but mark the error
-                engine._connection_error = str(e)
-
-        except Exception as e:
-            logger.error(f"Error creating database engine: {e}")
-            engine = None
-    else:
-        logger.error("Skipping SQLAlchemy setup due to raw connection failure.")
+  # Test raw connection first
+  raw_connection_ok = test_raw_connection()
+
+  if raw_connection_ok:
+    # If raw connection works, try SQLAlchemy
+    try:
+      # Create database connection URL with proper escaping and formatting
+      # Make sure we're properly URL encoding special characters in the password
+      encoded_password = urllib.parse.quote_plus(DB_PASS)
+
+      # Create the connection URL - use proper format to avoid the @ symbol issue
+      DATABASE_URL = (
+        f"mysql+pymysql://{DB_USER}:{encoded_password}@{DB_HOST}:{DB_PORT}/{DB_NAME}"
+      )
+
+      logger.info(
+        f"Creating SQLAlchemy engine with host: {DB_HOST}, port: {DB_PORT}, db: {DB_NAME}"
+      )
+
+      # Create SQLModel engine with minimal options
+      engine = create_engine(
+        DATABASE_URL,
+        echo=False,
+        pool_recycle=3600,  # Recycle connections after an hour
+        pool_pre_ping=False,  # Disable connection testing
+      )
+
+      # Basic connection test using proper SQLAlchemy 2.0 syntax
+      try:
+        with engine.connect() as conn:
+          # Using text() to create a SQL expression
+          result = conn.execute(text("SELECT 1"))
+          logger.info(
+            f"SQLAlchemy database connection test successful: {result.fetchone()}"
+          )
+      except Exception as e:
+        logger.error(f"SQLAlchemy database connection test failed: {e}")
+        # Keep the engine but mark the error
+        engine._connection_error = str(e)
+
+    except Exception as e:
+      logger.error(f"Error creating database engine: {e}")
+      engine = None
+  else:
+    logger.error("Skipping SQLAlchemy setup due to raw connection failure.")
+
 
 # Context manager for database sessions with better error handling
 @contextmanager
 def get_session():
-    """Get a database session if possible, otherwise return None."""
-    if engine is None:
-        logger.warning("Database engine is not configured. Returning None session.")
-        yield None
-        return
-
-    # Check if we have a known connection error
-    if hasattr(engine, "_connection_error"):
-        logger.warning(
-            f"Skipping database session due to known connection error: {engine._connection_error}"
-        )
-        yield None
-        return
-
-    session = None
-    try:
-        session = Session(engine)
-        logger.debug("Database session created")
-        yield session
-    except pymysql.err.OperationalError as e:
-        error_code = e.args[0] if len(e.args) > 0 else "unknown"
-        if error_code == 1045:  # Access denied error
-            logger.error(
-                f"Database access denied. Check credentials for user {DB_USER}."
-            )
-        else:
-            logger.error(f"Database operational error: {e}")
-        yield None
-    except Exception as e:
-        logger.error(f"Database error: {e}")
-        yield None
-    finally:
-        if session:
-            logger.debug("Database session closed")
-            session.close()
+  """Get a database session if possible, otherwise return None."""
+  if engine is None:
+    logger.warning("Database engine is not configured. Returning None session.")
+    yield None
+    return
+
+  # Check if we have a known connection error
+  if hasattr(engine, "_connection_error"):
+    logger.warning(
+      f"Skipping database session due to known connection error: {engine._connection_error}"
+    )
+    yield None
+    return
+
+  session = None
+  try:
+    session = Session(engine)
+    logger.debug("Database session created")
+    yield session
+  except pymysql.err.OperationalError as e:
+    error_code = e.args[0] if len(e.args) > 0 else "unknown"
+    if error_code == 1045:  # Access denied error
+      logger.error(f"Database access denied. Check credentials for user {DB_USER}.")
+    else:
+      logger.error(f"Database operational error: {e}")
+    yield None
+  except Exception as e:
+    logger.error(f"Database error: {e}")
+    yield None
+  finally:
+    if session:
+      logger.debug("Database session closed")
+      session.close()