Code cleanup

.dockerignore.yaml

@@ -1,19 +0,0 @@
-# Ignore build artifacts
-target/
-pkg/
-
-# Ignore git directory
-.git/
-
-# Ignore environment files (configure via docker-compose instead)
-.env*
-
-# Ignore IDE/editor specific files
-.idea/
-.vscode/
-
-# Ignore OS specific files
-*.DS_Store
-
-# Add any other files/directories you don't need in the image
-# e.g., logs/, tmp/

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "icarus_auth"
-version = "0.3.2"
+version = "0.3.0"
 edition = "2024"
 rust-version = "1.86"
 

Dockerfile

@@ -1,75 +0,0 @@
-# Stage 1: Build the application
-# Use a specific Rust version for reproducibility. Choose one that matches your development environment.
-# Using slim variant for smaller base image
-FROM rust:1.86 as builder
-
-# Set the working directory inside the container
-WORKDIR /usr/src/app
-
-# Install build dependencies if needed (e.g., for certain crates like sqlx with native TLS)
-# RUN apt-get update && apt-get install -y pkg-config libssl-dev
-
-# Install build dependencies if needed (e.g., git for cloning)
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    pkg-config libssl3 \
-    ca-certificates \
-    openssh-client git \
-    && rm -rf /var/lib/apt/lists/*
-
-# << --- ADD HOST KEY HERE --- >>
-# Replace 'yourgithost.com' with the actual hostname (e.g., github.com)
-RUN mkdir -p -m 0700 ~/.ssh && \
-    ssh-keyscan git.kundeng.us >> ~/.ssh/known_hosts
-
-# Copy Cargo manifests
-COPY Cargo.toml Cargo.lock ./
-
-# Build *only* dependencies to leverage Docker cache
-# This dummy build caches dependencies as a separate layer
-RUN --mount=type=ssh mkdir src && \
-    echo "fn main() {println!(\"if you see this, the build broke\")}" > src/main.rs && \
-    cargo build --release --quiet && \
-    rm -rf src target/release/deps/icarus_auth* # Clean up dummy build artifacts (replace icarus_auth)
-
-# Copy the actual source code
-COPY src ./src
-# If you have other directories like `templates` or `static`, copy them too
-# COPY templates ./templates
-# COPY static ./static
-COPY .env ./.env
-COPY migrations ./migrations
-
-# << --- SSH MOUNT ADDED HERE --- >>
-# Build *only* dependencies to leverage Docker cache
-# This dummy build caches dependencies as a separate layer
-# Mount the SSH agent socket for this command
-RUN --mount=type=ssh \
-    cargo build --release --quiet
-
-# Stage 2: Create the final, smaller runtime image
-# Use a minimal base image like debian-slim or even distroless for security/size
-FROM ubuntu:24.04
-
-# Install runtime dependencies if needed (e.g., SSL certificates)
-RUN apt-get update && apt-get install -y ca-certificates libssl-dev libssl3 && rm -rf /var/lib/apt/lists/*
-
-# Set the working directory
-WORKDIR /usr/local/bin
-
-# Copy the compiled binary from the builder stage
-# Replace 'icarus_auth' with the actual name of your binary (usually the crate name)
-COPY --from=builder /usr/src/app/target/release/icarus_auth .
-
-# Copy other necessary files like .env (if used for runtime config) or static assets
-# It's generally better to configure via environment variables in Docker though
-COPY --from=builder /usr/src/app/.env .
-COPY --from=builder /usr/src/app/migrations ./migrations
-# COPY --from=builder /usr/src/app/templates ./templates
-# COPY --from=builder /usr/src/app/static ./static
-
-# Expose the port your Axum app listens on (e.g., 3000 or 8000)
-EXPOSE 3000
-
-# Set the command to run your application
-# Ensure this matches the binary name copied above
-CMD ["./icarus_auth"]

docker-compose.yaml

@@ -1,54 +0,0 @@
-version: '3.8' # Use a recent version
-
-services:
-  # Your Rust Application Service
-  app:
-    build: . # Tells docker-compose to build the Dockerfile in the current directory
-    container_name: icarus_auth # Optional: Give the container a specific name
-    ports:
-      # Map host port 8000 to container port 3000 (adjust as needed)
-      # Format: "HOST_PORT:CONTAINER_PORT"
-      - "8000:3000"
-    environment:
-      # Pass environment variables to your Rust application
-      # RUST_LOG: info # Example: Set log level
-      # IMPORTANT: Configure DATABASE_URL to connect to the 'db' service
-      # The hostname 'db' matches the service name defined below.
-      DATABASE_URL: postgresql://icarus_op:password@db:5432/icarus_auth
-      # Add any other environment variables your app needs
-      # APP_HOST: 0.0.0.0
-      # APP_PORT: 3000
-    depends_on:
-      db:
-        condition: service_healthy # Wait for the DB to be healthy before starting the app
-    restart: unless-stopped # Optional: Restart policy
-
-  # PostgreSQL Database Service
-  db:
-    image: postgres:17.4-alpine # Use an official Postgres image (Alpine variant is smaller)
-    container_name: icarus_auth_db # Optional: Give the container a specific name
-    environment:
-      # These MUST match the user, password, and database name in the DATABASE_URL above
-      POSTGRES_USER: icarus_op
-      POSTGRES_PASSWORD: password
-      POSTGRES_DB: icarus_auth
-    volumes:
-      # Persist database data using a named volume
-      - postgres_data:/var/lib/postgresql/data
-    ports: []
-      # Optional: Expose port 5432 ONLY if you need to connect directly from your host machine (e.g., for debugging)
-      # - "5432:5432"
-      # pass:
-    healthcheck:
-        # Checks if Postgres is ready to accept connections
-        test: ["CMD-SHELL", "pg_isready -U $$POSTGRES_USER -d $$POSTGRES_DB"]
-        interval: 10s
-        timeout: 5s
-        retries: 5
-        start_period: 10s
-    restart: always # Optional: Restart policy
-
-# Define the named volume for data persistence
-volumes:
-  postgres_data:
-    driver: local # Use the default local driver

docker_run.txt

@@ -1,13 +0,0 @@
-
-# Docker stuff
-#Build app
-docker-compose build --ssh default app
-
-# Rebuild and bring up
-docker-compose up -d --force-recreate app
-
-# Bring it down
-docker-compose down -v
-
-# Pruning
-docker system prune -a

src/callers/login.rs

@@ -51,16 +51,13 @@ pub mod endpoint {
                     let (token_literal, duration) = token_stuff::create_token(&key).unwrap();
 
                     if token_stuff::verify_token(&key, &token_literal) {
-                        let current_time = time::OffsetDateTime::now_utc();
-                        let _ = repo::user::update_last_login(&pool, &user, &current_time).await;
-
                         (
                             StatusCode::OK,
                             Json(response::Response {
                                 message: String::from("Successful"),
                                 data: vec![icarus_models::login_result::LoginResult {
                                     id: user.id,
-                                    username: user.username.clone(),
+                                    username: user.username,
                                     token: token_literal,
                                     token_type: String::from(token_stuff::TOKENTYPE),
                                     expiration: duration,

src/repo/mod.rs

@@ -42,39 +42,6 @@ pub mod user {
         }
     }
 
-    pub async fn update_last_login(
-        pool: &sqlx::PgPool,
-        user: &icarus_models::user::User,
-        time: &time::OffsetDateTime,
-    ) -> Result<time::OffsetDateTime, sqlx::Error> {
-        let result = sqlx::query(
-            r#"
-            UPDATE "user" SET last_login = $1 WHERE id = $2 RETURNING last_login
-            "#,
-        )
-        .bind(time)
-        .bind(user.id)
-        .fetch_optional(pool)
-        .await
-        .map_err(|e| {
-            eprintln!("Error updating time: {}", e);
-            e
-        });
-
-        match result {
-            Ok(row) => match row {
-                Some(r) => {
-                    let last_login: time::OffsetDateTime = r
-                        .try_get("last_login")
-                        .map_err(|_e| sqlx::Error::RowNotFound)?;
-                    Ok(last_login)
-                }
-                None => Err(sqlx::Error::RowNotFound),
-            },
-            Err(err) => Err(err),
-        }
-    }
-
     pub async fn exists(pool: &sqlx::PgPool, username: &String) -> Result<bool, sqlx::Error> {
         let result = sqlx::query(
             r#"