Rewrite in go

Author: TheEdgeOfRage

.dockerignore

@@ -1,16 +1,7 @@
-docker-compose-prod.yml
-docker-compose.yml
 Dockerfile
 .dockerignore
-
 .git
 .github
 .gitignore
-
-public
-pyazo_api/.env
-pyazo_api/*.db
-__pycache__
-
 .vscode
 .editorconfig

.github/workflows/dockerbuild.yaml

@@ -16,16 +16,18 @@ jobs:
         uses: actions/checkout@v6
 
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
+        uses: docker/setup-buildx-action@v4
 
       - name: Login to Docker Hub
-        uses: docker/login-action@v3
+        uses: docker/login-action@v4
         with:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
 
       - name: Build and push API image
-        uses: docker/build-push-action@v6
+        uses: docker/build-push-action@v7
         with:
           push: true
           tags: pyazo/api:latest
+          cache-from: type=gha
+          cache-to: type=gha,mode=max

.gitignore

@@ -1,97 +1,12 @@
-# Byte-compiled / optimized / DLL files
-__pycache__/
-*.py[cod]
-*$py.class
+# Binary
+/api
 
-# C extensions
-*.so
-
-# Distribution / packaging
-.Python
-build/
-develop-eggs/
-dist/
-downloads/
-eggs/
-.eggs/
-lib/
-lib64/
-parts/
-sdist/
-var/
-wheels/
-pip-wheel-metadata/
-share/python-wheels/
-*.egg-info/
-.installed.cfg
-*.egg
-MANIFEST
-
-# PyInstaller
-#  Usually these files are written by a python script from a template
-#  before PyInstaller builds the exe, so as to inject date/other infos into it.
-*.manifest
-*.spec
-
-# Installer logs
-pip-log.txt
-pip-delete-this-directory.txt
-
-# Unit test / coverage reports
-htmlcov/
-.tox/
-.nox/
-.coverage
-.coverage.*
-.cache
-nosetests.xml
-coverage.xml
-*.cover
-*.py,cover
-.hypothesis/
-.pytest_cache/
-cover/
-
-# Translations
-*.mo
-*.pot
-
-# Sphinx documentation
-docs/_build/
-
-# PyBuilder
-.pybuilder/
-target/
-
-# IPython
-profile_default/
-ipython_config.py
-
-# Celery stuff
-celerybeat-schedule
-celerybeat.pid
-
-# Environments
+# Environment
 .env
-.venv
-env/
-venv/
-ENV/
-env.bak/
-venv.bak/
 
-# pytype static type analyzer
-.pytype/
-
-# Editor settings
+# Editor
 .idea
 .vscode/
 
-# Databases
-*.db
-
-# mypy cache
-.mypy_cache/
-
-#images
-bin/
+# OS
+.DS_Store

.mypy.ini

@@ -4,77 +4,48 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 ## Project Overview
 
-Pyazo API is a self-hosted screenshot and image upload service backend built with FastAPI. It provides REST endpoints for user authentication and image management with support for public image storage.
+Pyazo API is a self-hosted screenshot and image upload service backend built with Go (gin + pgx). It provides REST endpoints for user authentication and image management.
 
 ## Development Commands
 
 ```bash
-# Install dependencies (uses uv)
-uv sync
+# Build
+go build -o api ./cmd/
 
-# Run development server
-uvicorn pyazo_api.run:app --reload
+# Run (requires PostgreSQL)
+POSTGRES_PASSWORD=pyazo JWT_SECRET=secret BLOCK_REGISTER=false ./api
 
-# Run tests (requires PostgreSQL - see pytest.ini for test env config)
-pytest
-
-# Run single test
-pytest tests/test_images.py::test_name
-
-# Seed database with test data
-python -m pyazo_api.seed
+# Run tests (requires PostgreSQL)
+POSTGRES_PASSWORD=pyazo go test ./...
 
 # Start PostgreSQL for local development
 docker compose up -d db
 ```
 
 ## Architecture
 
-The codebase follows a layered domain-driven architecture:
+Flat package structure with protocol-layer separation:
 
 ```
-pyazo_api/
-├── application/          # FastAPI app setup and HTTP layer
-│   ├── __init__.py       # create_app() with lifespan, CORS, router registration
-│   ├── db.py             # Connection pool (psycopg_pool) with lifespan management
-│   └── routers/          # API route handlers (auth, images)
-├── domain/               # Business logic layer
-│   ├── auth/             # Authentication domain
-│   │   ├── actions/      # login_action.py, register_action.py
-│   │   ├── repository.py # UserRepository
-│   │   └── dto.py        # User DTOs (User, UserGet, UserCredentials, etc.)
-│   └── images/           # Images domain
-│       ├── actions/      # save_image.py, get_images.py, delete_image.py
-│       ├── repository.py # ImageRepository
-│       └── dto.py        # Image DTO
-├── config/               # Pydantic Settings configuration
-│   ├── __init__.py       # Exports `settings` singleton
-│   └── settings.py       # Settings class with env var loading
-└── util/                 # Shared utilities (pagination, auth helpers, http_exceptions)
+auth/           # JWT and argon2id password hashing (passlib-compatible)
+config/         # Config struct loaded from env vars
+db/             # pgx queries, User/Image structs
+http/           # gin handlers, middleware, server setup
+cmd/api/        # Entrypoint, embedded migrations
+migrations/     # SQL migration files (golang-migrate)
 ```
 
-**Key Patterns:**
-
-- **Actions**: Business logic encapsulated in action classes with FastAPI `Depends()` injection
-- **Repositories**: Data access layer using raw SQL with psycopg3 async connection pool
-- **DTOs**: Pydantic models for data transfer; `User.to_public()` converts to `UserGet`
-- **Database**: Async connection pool via `psycopg_pool.AsyncConnectionPool` managed by FastAPI lifespan
-- **Configuration**: `pydantic-settings` with automatic `.env` file loading
-
 ## Database
 
-- PostgreSQL with psycopg3 async + connection pooling
-- Migrations in `migrations/` (plain SQL files)
+- PostgreSQL with pgx + connection pooling
+- Migrations embedded in binary, run on startup via golang-migrate
 - Two tables: `users` (id, username, hashed_password) and `images` (id, owner_id, created_at)
 
 ## Configuration
 
-Uses `pydantic-settings` for type-safe configuration. Settings loaded from environment variables and `.env` file.
-
-Key settings (see `config/settings.py`):
+Environment variables (see `config/config.go`):
 
 - `ENV`: development/testing/production
 - `POSTGRES_USER`, `POSTGRES_PASSWORD`, `POSTGRES_DB`, `POSTGRES_HOST`
-- `JWT_SECRET`, `JWT_ALGORITHM`
-- `BLOCK_REGISTER`: Boolean to disable registration
-- `IMAGES_PATH`: Image storage directory
+- `JWT_SECRET`, `BLOCK_REGISTER`, `IMAGES_PATH`
+- `CORS_ORIGIN`, `PORT`

CLAUDE.md

@@ -1,28 +1,16 @@
-FROM ghcr.io/astral-sh/uv:python3.13-trixie-slim AS builder
+FROM golang:1.26-trixie AS builder
 
 WORKDIR /app
 
-COPY pyproject.toml uv.lock ./
-RUN uv sync --frozen --no-install-project --no-dev;
+COPY go.mod go.sum ./
+RUN go mod download
 
-COPY pyazo_api/ ./pyazo_api/
-RUN uv sync --frozen --no-dev;
+COPY . .
+RUN go build -o /pyazo ./cmd/
 
-FROM python:3.13-slim-trixie
+FROM debian:trixie-slim
 
 EXPOSE 8000
-WORKDIR /app
-ENTRYPOINT ["/entrypoint.sh"]
-ENV PYTHONUNBUFFERED=1
-VOLUME /images
-
-COPY --from=migrate/migrate /usr/local/bin/migrate /usr/bin/migrate
-
-RUN apt update \
-    && apt install -y postgresql-client \
-    && rm -rf /var/lib/apt/lists/* \
-    && apt clean;
 
-COPY migrations/ ./migrations/
-COPY entrypoint.sh /entrypoint.sh
-COPY --from=builder /app/ ./
+COPY --from=builder /pyazo /pyazo
+ENTRYPOINT ["/pyazo"]

Dockerfile

@@ -2,55 +2,55 @@
 
 Pyazo is a self-hosted screenshot and image upload utility. It allows you to take a screenshot of a part of your screen and automatically upload it to your own server. You can also directly upload an image from your computer.
 
-It is comprised of a cross-platform client written in Python which defers the actual taking of the screenshot to the built-in OS tools (macOS and Windows) or common utilities (Linux distributions). The server is written as a RESTful FastAPI app with support for basic user accounts and image sharing options.
+It is comprised of a cross-platform client written in Python which defers the actual taking of the screenshot to the built-in OS tools (macOS and Windows) or common utilities (Linux distributions). The server is a RESTful Go API with support for basic user accounts and image management.
 
-## Compatibility
+## Requirements
 
-### Server
+- Go >= 1.24
+- PostgreSQL
 
-- Python >= 3.13 (check with `python --version`)
+## Configuration
 
-## Installation
+Copy `.env-example` to `.env` and configure:
 
-The only official supported way to run the server is through docker-compose. First make a copy of the `.env-example` file, name it `.env` and change the settings inside accordingly.
+| Key               | Default                 | Description                        |
+| ----------------- | ----------------------- | ---------------------------------- |
+| ENV               | production              | Set to development for debug mode  |
+| POSTGRES_USER     | pyazo                   | PostgreSQL username                |
+| POSTGRES_PASSWORD |                         | PostgreSQL password                |
+| POSTGRES_DB       | pyazo                   | Database name                      |
+| POSTGRES_HOST     | localhost               | Database host                      |
+| JWT_SECRET        |                         | JWT signing secret                 |
+| BLOCK_REGISTER    | true                    | Disable user registration          |
+| IMAGES_PATH       | /images                 | Image storage directory            |
+| CORS_ORIGIN       | https://app.pyazo.com   | Allowed CORS origin                |
+| PORT              | 8000                    | HTTP listen port                   |
 
-| Key               | Default         | Description                                                 |
-| ----------------- | --------------- | ----------------------------------------------------------- |
-| ENV               | production      | FastAPI environment. Set to development to enable debugging |
-| POSTGRES_USER     | pyazo           | Username of the postgres user                               |
-| POSTGRES_PASSWORD | ' '             | Password of the postgres user                               |
-| POSTGRES_DB       | pyazo           | Database name                                               |
-| JWT_SECRET        | ' '             | JWT secret                                                  |
-| BLOCK_REGISTER    | 'False'         | Blocks registration if true                                 |
-| HOST_PUBLIC_MEDIA | /srv/http/pyazo | Host public media path (Docker only)                        |
-| IMAGE_PATH        | ./media/public/ | Public media storage path (non-Docker only)                 |
+## Development
 
-Make a copy of the `docker-compose-prod.yaml` file, name it `docker-compose.yaml` and change the settings inside if needed.
+```bash
+# Start PostgreSQL
+docker compose up -d db
 
-Build the container using:
+# Build
+go build -o api ./cmd/
 
-```shell
-docker compose build
+# Run
+POSTGRES_PASSWORD=pyazo JWT_SECRET=secret BLOCK_REGISTER=false ./api
+
+# Run tests
+POSTGRES_PASSWORD=pyazo go test ./...
 ```
 
-Then run it using:
+## Docker
 
-```shell
+```bash
+docker compose build
 docker compose up -d
 ```
 
-Place a copy of the nginx.conf-example to /etc/nginx/conf.d/pyazo.conf and change the settings inside if needed.
-
-Restart nginx.
-
-## Documentation
-
-https://pyazo.com/docs
+Images are stored at the `IMAGES_PATH` volume (`/images` by default) and should be served by a reverse proxy.
 
 ## License and Credits
 
 BSD 3-Clause
-
-[Python]: https://www.python.org/downloads/
-[Docker]: https://docs.docker.com/
-[Docker Compose]: https://docs.docker.com/compose/