Code cleanup

.dockerignore.yaml

@@ -1,21 +0,0 @@
-# Ignore build artifacts
-target/
-pkg/
-
-# Ignore git directory
-.git/
-
-.gitea/
-
-# 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/

.env.sample

@@ -1,6 +1,2 @@
+DATABASE_URL=postgres://username:password@localhost/database_name
 SECRET_KEY=refero34o8rfhfjn983thf39fhc943rf923n3h
-POSTGRES_USER=icarus_op_test
-POSTGRES_PASSWORD=password
-POSTGRES_DB=icarus_auth_test_db
-POSTGRES_HOST=localhost
-DATABASE_URL=postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@${POSTGRES_HOST}:5432/${POSTGRES_DB}

.gitea/workflows/tag_release.yml

@@ -4,6 +4,8 @@ on:
   push:
     branches:
       - devel
+    tags:
+      - 'v*' # Trigger on tags matching v*
 
 jobs:
   release:
@@ -51,3 +53,5 @@ jobs:
            Release of version ${{ steps.version.outputs.project_tag_release }}
           # draft: false
           # prerelease: ${{ startsWith(github.ref, 'v') == false }} # prerelease if not a valid release tag
+
+

Cargo.toml

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

Dockerfile

@@ -1,71 +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 .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
-
-# 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"]

README.md

@@ -1,26 +0,0 @@
-
-
-# Getting Started
-Copy the `.env.sample` file to `.env` and ensure that the variables are populated. This project
-can be used with regular hosting or with docker. For the sake of getting up to speed quickly,
-Docker will be covered. Make sure docker is running and your ssh identity has been loaded.
-
-Build image
-```
-docker compose build
-```
-
-Start images
-```
-docker compose up -d --force-recreate
-```
-
-Bring it down
-```
-docker compose down -v
-```
-
-Pruning
-```
-docker system prune -a
-```

docker-compose.yaml

@@ -1,45 +0,0 @@
-version: '3.8' # Use a recent version
-
-services:
-  # Your Rust Application Service
-  auth_api:
-    build: # Tells docker-compose to build the Dockerfile in the current directory
-      context: .
-      ssh: ["default"]  # Uses host's SSH agent
-    container_name: icarus_auth # Optional: Give the container a specific name
-    ports:
-      # Map host port 8000 to container port 3000 (adjust as needed)
-      - "8000:3000"
-    env_file:
-      - .env
-    depends_on:
-      auth_db:
-        condition: service_healthy # Wait for the DB to be healthy before starting the app
-    restart: unless-stopped # Optional: Restart policy
-
-  # PostgreSQL Database Service
-  auth_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: ${POSTGRES_USER:-icarus_op}
-      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-password}
-      POSTGRES_DB: ${POSTGRES_DB:-icarus_auth}
-    volumes:
-      # Persist database data using a named volume
-      - postgres_data:/var/lib/postgresql/data
-    ports: []
-    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

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/lib.rs

@@ -36,6 +36,7 @@ pub mod db {
     async fn get_db_url() -> String {
         #[cfg(debug_assertions)] // Example: Only load .env in debug builds
         dotenvy::dotenv().ok();
+
         env::var(keys::DBURL).expect(keys::error::ERROR)
     }
 

src/main.rs

@@ -74,7 +74,6 @@ mod tests {
         pub const LIMIT: usize = 6;
 
         pub async fn get_pool() -> Result<sqlx::PgPool, sqlx::Error> {
-            dotenvy::dotenv().ok(); // Load .env file if it exists
             let tm_db_url = std::env::var(keys::DBURL).expect("DATABASE_URL must be present");
             let tm_options = sqlx::postgres::PgConnectOptions::from_str(&tm_db_url).unwrap();
             sqlx::PgPool::connect_with(tm_options).await

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#"