docs: materi + AI agent RAG (finding #6)

- ENV: AI_LLM_BASE_URL/API_KEY/MODEL, AI_EMBEDDING_MODEL (gemini-embedding-001), QDRANT_URL
- ai_agent module: chunking materi, embed_text + chat_completion (9router, SSE parse), Qdrant repo (dimentorin_materi collection, 3072d cosine)
- routes: POST /ai/chat (RAG answer + sources), POST /ai/materials/{id}/index, POST /ai/reindex
- e2e verified: reindex 3 chunks; chat 'ownership' -> materi Rust paling relevan 0.88; chat 'endpoint axum' -> materi Axum 0.82; jawaban gronding konteks

.cargo/config.toml

@@ -0,0 +1,2 @@
+[target.x86_64-pc-windows-msvc]
+linker = "rust-lld.exe"

.dockerignore

@@ -1,5 +1,5 @@
-target
-.dockerignore
-Dockerfile
-.git
-.gitignore
+target
+.dockerignore
+Dockerfile
+.git
+.gitignore

.env.example

@@ -1,8 +1,33 @@
-PORT=
-SURREALDB_URL=
-SURREALDB_USERNAME=
-SURREALDB_PASSWORD=
-SURREALDB_NAMESPACE=
-SURREALDB_DBNAME=
-ACCESS_TOKEN_SECRET=
-REFRESH_TOKEN_SECRET=
+RUST_ENV=development
+RUST_LOG=debug
+PORT=4099
+ACCESS_TOKEN_SECRET=your-access-token-secret-key-here
+REFRESH_TOKEN_SECRET=your-refresh-token-secret-key-here
+SMTP_EMAIL=your-email@example.com
+SMTP_PASSWORD=your-smtp-password
+SMTP_NAME="Your App Name"
+SMTP_HOST=smtp.gmail.com
+REDISDB_URL=localhost
+FE_URL=http://localhost
+MINIO_ENDPOINT=http://localhost:9000
+MINIO_BUCKET_NAME=default_bucket
+MINIO_ACCESS_KEY=minioadmin
+MINIO_SECRET_KEY=minioadmin
+MINIO_SECURE=false
+
+GOOGLE_CLIENT_ID="your_google_client_id"
+GOOGLE_CLIENT_SECRET="your_google_client_secret"
+POOL_SIZE=10
+CONNECT_TIMEOUT=30
+IDLE_TIMEOUT=60
+MAX_LIFETIME=1800
+STATEMENT_TIMEOUT=30000
+IDLE_IN_TRANSACTION_SESSION_TIMEOUT=60000
+SSLMODE=require
+RETRY_ATTEMPTS=3
+RETRY_DELAY=1
+GOOGLE_REDIRECT_URL=http://localhost:8000/api/v1/auth/google/callback
+
+CDN_URL=https://cdn.asepharyana.tech
+CORS_ALLOWED_ORIGINS=http://localhost:3000,https://gacha.imphnen.dev,https://imphnen.dev,https://dimentorin.imphnen.dev
+

.envrc.example

@@ -1 +1 @@
-use flake --impure
+use flake --impure

.github/workflows/deploy.yml

@@ -1,65 +0,0 @@
-name: Deploy
-
-on:
-  push:
-    branches:
-      - develop
-
-jobs:
-  build-and-deploy:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v2
-
-      - name: Set up Rust
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          override: true
-
-      - name: Build the project
-        run: cargo build --release
-
-      - name: Stop service on VPS before upload
-        uses: appleboy/ssh-action@v0.1.7
-        with:
-          host: ${{ secrets.VPS_IP }}
-          username: ${{ secrets.VPS_USER }}
-          key: ${{ secrets.VPS_SSH_KEY }}
-          port: ${{ secrets.VPS_PORT }}
-          script: |
-            set -e
-            echo "Stopping the service before uploading the binary"
-            sudo systemctl stop imphnen-backend-service
-
-      - name: Upload artifact to VPS
-        uses: appleboy/scp-action@v0.1.7
-        with:
-          host: ${{ secrets.VPS_IP }}
-          username: ${{ secrets.VPS_USER }}
-          key: ${{ secrets.VPS_SSH_KEY }}
-          port: ${{ secrets.VPS_PORT }}
-          source: ./target/release/*
-          target: /opt/imphnen-backend-service/imphnen-backend-service
-          rm: true
-          overwrite: true
-
-      - name: Deploy to server
-        uses: appleboy/ssh-action@v0.1.7
-        with:
-          host: ${{ secrets.VPS_IP }}
-          username: ${{ secrets.VPS_USER }}
-          key: ${{ secrets.VPS_SSH_KEY }}
-          port: ${{ secrets.VPS_PORT }}
-          script: |
-            set -e
-
-            echo "Restarting the service"
-
-            sudo systemctl daemon-reload
-
-            sudo systemctl restart imphnen-backend-service
-
-            echo "Deployment completed successfully"

.github/workflows/nix-build.yml

@@ -0,0 +1,78 @@
+name: Nix Build & Deploy
+
+on:
+  push:
+    branches: ['develop']
+  pull_request:
+    branches: ['develop']
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install Nix
+        uses: DeterminateSystems/nix-installer-action@main
+
+      - name: Setup Cachix
+        uses: cachix/cachix-action@v15
+        with:
+          name: msdqn
+          authToken: '${{ secrets.CACHIX_AUTH_TOKEN }}'
+
+      - name: Build
+        run: nix build .#default -o result
+
+      - name: Push to Cachix
+        if: github.event_name == 'push' && github.ref == 'refs/heads/develop'
+        run: cachix push msdqn result
+
+  deploy:
+    needs: build
+    if: (github.event_name == 'push' || github.event_name == 'workflow_dispatch') && github.ref == 'refs/heads/develop'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Install Nix
+        uses: DeterminateSystems/nix-installer-action@main
+
+      - name: Setup SSH
+        env:
+          INFRA_DEPLOY_KEY: ${{ secrets.INFRA_DEPLOY_KEY }}
+        run: |
+          mkdir -p ~/.ssh
+          echo "${INFRA_DEPLOY_KEY}" > ~/.ssh/deploy_key
+          chmod 600 ~/.ssh/deploy_key
+          ssh-keyscan github.com >> ~/.ssh/known_hosts 2>/dev/null
+          ssh-keyscan 167.235.70.37 >> ~/.ssh/known_hosts 2>/dev/null
+
+      - name: Update infra flake.lock
+        run: |
+          export GIT_SSH_COMMAND="ssh -i ~/.ssh/deploy_key -o IdentitiesOnly=yes"
+          git clone git@github.com:IMPHNEN/imphnen-infrastructure.git /tmp/infra
+          cd /tmp/infra
+          nix flake update imphnen-backend
+          if git diff --quiet flake.lock; then
+            echo "flake.lock unchanged, skipping"
+          else
+            git config user.name "github-actions[bot]"
+            git config user.email "github-actions[bot]@users.noreply.github.com"
+            git add flake.lock
+            git commit -m "chore: update imphnen-backend-service to ${GITHUB_SHA::7}"
+            git push
+          fi
+
+      - name: Deploy to server
+        run: |
+          ssh -i ~/.ssh/deploy_key \
+            -o ConnectTimeout=30 \
+            -o StrictHostKeyChecking=accept-new \
+            -o ServerAliveInterval=30 \
+            -o ServerAliveCountMax=40 \
+            root@167.235.70.37 \
+            'nixos-rebuild switch --flake github:IMPHNEN/imphnen-infrastructure#hetzner --refresh 2>&1 | tail -50'
+
+      - name: Cleanup
+        if: always()
+        run: rm -f ~/.ssh/deploy_key

.github/workflows/test-build.yml

@@ -1,19 +0,0 @@
-name: Rust
-
-on:
-  push:
-    branches: ["develop"]
-  pull_request:
-    branches: ["develop"]
-
-env:
-  CARGO_TERM_COLOR: always
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v4
-      - name: Build
-        run: cargo build --verbose

.gitignore

@@ -1,15 +1,16 @@
-# Build
-/target
-/resutl
-
-# Nix
-/.direnv
-/Cargo.nix
-
-# Environment
-.envrc
-.env
-.env.local
-.env.development
-.env.staging
-.env.production
+# Build
+/target
+/resutl
+
+# Nix
+/.direnv
+/Cargo.nix
+
+# Environment
+.envrc
+.env
+.env.local
+.env.development
+.env.staging
+.env.production
+**/**.log

.serena/.gitignore

@@ -0,0 +1 @@
+/cache

.serena/project.yml

@@ -0,0 +1,71 @@
+# language of the project (csharp, python, rust, java, typescript, go, cpp, or ruby)
+#  * For C, use cpp
+#  * For JavaScript, use typescript
+# Special requirements:
+#  * csharp: Requires the presence of a .sln file in the project folder.
+language: rust
+
+# the encoding used by text files in the project
+# For a list of possible encodings, see https://docs.python.org/3.11/library/codecs.html#standard-encodings
+encoding: "utf-8"
+
+# whether to use the project's gitignore file to ignore files
+# Added on 2025-04-07
+ignore_all_files_in_gitignore: true
+# list of additional paths to ignore
+# same syntax as gitignore, so you can use * and **
+# Was previously called `ignored_dirs`, please update your config if you are using that.
+# Added (renamed) on 2025-04-07
+ignored_paths: []
+
+# whether the project is in read-only mode
+# If set to true, all editing tools will be disabled and attempts to use them will result in an error
+# Added on 2025-04-18
+read_only: false
+
+# list of tool names to exclude. We recommend not excluding any tools, see the readme for more details.
+# Below is the complete list of tools for convenience.
+# To make sure you have the latest list of tools, and to view their descriptions, 
+# execute `uv run scripts/print_tool_overview.py`.
+#
+#  * `activate_project`: Activates a project by name.
+#  * `check_onboarding_performed`: Checks whether project onboarding was already performed.
+#  * `create_text_file`: Creates/overwrites a file in the project directory.
+#  * `delete_lines`: Deletes a range of lines within a file.
+#  * `delete_memory`: Deletes a memory from Serena's project-specific memory store.
+#  * `execute_shell_command`: Executes a shell command.
+#  * `find_referencing_code_snippets`: Finds code snippets in which the symbol at the given location is referenced.
+#  * `find_referencing_symbols`: Finds symbols that reference the symbol at the given location (optionally filtered by type).
+#  * `find_symbol`: Performs a global (or local) search for symbols with/containing a given name/substring (optionally filtered by type).
+#  * `get_current_config`: Prints the current configuration of the agent, including the active and available projects, tools, contexts, and modes.
+#  * `get_symbols_overview`: Gets an overview of the top-level symbols defined in a given file.
+#  * `initial_instructions`: Gets the initial instructions for the current project.
+#     Should only be used in settings where the system prompt cannot be set,
+#     e.g. in clients you have no control over, like Claude Desktop.
+#  * `insert_after_symbol`: Inserts content after the end of the definition of a given symbol.
+#  * `insert_at_line`: Inserts content at a given line in a file.
+#  * `insert_before_symbol`: Inserts content before the beginning of the definition of a given symbol.
+#  * `list_dir`: Lists files and directories in the given directory (optionally with recursion).
+#  * `list_memories`: Lists memories in Serena's project-specific memory store.
+#  * `onboarding`: Performs onboarding (identifying the project structure and essential tasks, e.g. for testing or building).
+#  * `prepare_for_new_conversation`: Provides instructions for preparing for a new conversation (in order to continue with the necessary context).
+#  * `read_file`: Reads a file within the project directory.
+#  * `read_memory`: Reads the memory with the given name from Serena's project-specific memory store.
+#  * `remove_project`: Removes a project from the Serena configuration.
+#  * `replace_lines`: Replaces a range of lines within a file with new content.
+#  * `replace_symbol_body`: Replaces the full definition of a symbol.
+#  * `restart_language_server`: Restarts the language server, may be necessary when edits not through Serena happen.
+#  * `search_for_pattern`: Performs a search for a pattern in the project.
+#  * `summarize_changes`: Provides instructions for summarizing the changes made to the codebase.
+#  * `switch_modes`: Activates modes by providing a list of their names
+#  * `think_about_collected_information`: Thinking tool for pondering the completeness of collected information.
+#  * `think_about_task_adherence`: Thinking tool for determining whether the agent is still on track with the current task.
+#  * `think_about_whether_you_are_done`: Thinking tool for determining whether the task is truly completed.
+#  * `write_memory`: Writes a named memory (for future reference) to Serena's project-specific memory store.
+excluded_tools: []
+
+# initial prompt for the project. It will always be given to the LLM upon activating the project
+# (contrary to the memories, which are loaded on demand).
+initial_prompt: ""
+
+project_name: "imphnen-backend-service"

Cargo.toml

@@ -1,47 +1,105 @@
 [workspace]
 resolver = "2"
-members = [ 
-  "tests",
-  "imphnen-iam",
+members = [
+  "imphnen-entities",
+  "imphnen-macros",
   "imphnen-libs",
+  "imphnen-storage",
+  "imphnen-email",
   "imphnen-utils",
+  "imphnen-middleware",
+  "imphnen-iam",
+  "imphnen-cms",
   "imphnen-gacha",
+  "imphnen-dimentorin",
+  "imphnen-hackathon",
   "imphnen-gateway",
   "imphnen-backend",
-  "imphnen-entities",
-  "imphnen-dimentorin",
-  "imphnen-middleware",
 ]
 
 
 [workspace.dependencies]
-axum = { version = "0.8.1", features = ["multipart"] }
-log = "0.4.25"
-serde = { version = "1.0.217", features = ["derive"] }
-serde_json = "1.0.138"
-tokio = { version = "1.43.0" }
+async-trait = "0.1.83"
+oauth2 = "5.0.0"
+reqwest = { version = "0.12.23", features = ["json"] }
+serde_json = "1.0.142"
+axum = { version = "0.8.4", features = ["multipart", "macros"] }
+log = "0.4.27"
+serde = { version = "1.0.219", features = ["derive"] }
+tokio = { version = "1.47.1", features = ["full"] }
 argon2 = { version = "0.5.3", features = ["password-hash"] }
 jsonwebtoken = "9.3.1"
-chrono = "0.4.39"
-utoipa = { version = "5.3.1", features = ["axum_extras"] }
-utoipa-swagger-ui = { version = "9.0.0", features = ["axum"] }
-lettre = { version = "0.11.12", features = ["tokio1-native-tls"] }
-surrealdb = { version = "2.2.1", features = ["kv-mem"] }
-thiserror = "2.0.11"
-anyhow = "1.0.97"
-rand = "0.9.0"
-tower-http = { version = "0.6.2", features = ["cors"] }
-validator = { version = "0.12", features = ["derive"] }
-lazy_static = "1.4.0"
+chrono = "0.4.41"
+utoipa = { version = "5.4.0", features = ["axum_extras", "uuid", "chrono"] }
+utoipa-swagger-ui = { version = "9.0.2", features = ["axum"] }
+lettre = { version = "0.11.18", features = ["tokio1-native-tls"] }
+thiserror = "2.0.14"
+anyhow = "1.0.99"
+rand = { version = "0.9.2", features = ["std", "alloc"] }
+rand_distr = "0.5.1"
+tower-http = { version = "0.6.6", features = ["cors", "trace"] }
+http-body-util = "0.1.3"
+zod-rs = { version = "0.4", features = ["macros"] }
+zod-rs-util = "0.4"
+paginator-rs = "0.2"
+paginator-utils = "0.2"
+paginator-sea-orm = { version = "0.2", features = ["sqlx-postgres", "runtime-tokio"] }
+paginator-axum = "0.2"
+lazy_static = "1.5.0"
 regex = "1.11.1"
-axum-test = "17.2.0"
-fancy-regex = "0.14.0"
+axum-test = "17.3.0"
+axum-extra = { version = "0.10.1", features = ["typed-header"] }
+fancy-regex = "0.16.1"
 futures = "0.3.31"
 tower = "0.5.2"
 env_logger = "0.11.8"
+tracing = "0.1.41"
+uuid = { version = "1.18.0", features = ["v4", "fast-rng", "serde"] }
+strum = { version = "0.27.2", features = ["derive"] }
+strum_macros = "0.27.2"
+base64 = "0.22.1"
+sha2 = "0.10.9"
+hmac = "0.12"
+hex = "0.4"
+urlencoding = "2.1"
+hyper = "1.6.0"
+hyper-util = "0.1.16"
+minio = "0.3.0"
+sea-orm = { version = "1.1", features = ["sqlx-postgres", "runtime-tokio-native-tls", "macros", "with-chrono", "uuid"] }
+sqlx = { version = "0.8", features = ["postgres", "runtime-tokio-native-tls", "uuid", "chrono", "json", "macros"] }
+num_cpus = "1.16.0"
+
+
+tokio-test = "0.4.4"
+mockall = "0.13.1"
+once_cell = "1.21.3"
+dotenvy = "0.15.7"
+tracing-subscriber = { version = "0.3.19", features = ["env-filter"] }
+tokio-tungstenite = "0.27"
+url = "2.5"
+futures-util = "0.3"
+http = "1.3"
+imphnen-iam = { path = "./imphnen-iam" }
+imphnen-cms = { path = "./imphnen-cms" }
+imphnen-libs = { path = "./imphnen-libs" }
+imphnen-utils = { path = "./imphnen-utils" }
+imphnen-gacha = { path = "./imphnen-gacha" }
+imphnen-gateway = { path = "./imphnen-gateway" }
+imphnen-backend = { path = "./imphnen-backend" }
+imphnen-entities = { path = "./imphnen-entities" }
+imphnen-dimentorin = { path = "./imphnen-dimentorin" }
+imphnen-middleware = { path = "./imphnen-middleware" }
+imphnen-macros = { path = "./imphnen-macros" }
+imphnen-hackathon = { path = "./imphnen-hackathon" }
+imphnen-storage = { path = "./imphnen-storage" }
+imphnen-email = { path = "./imphnen-email" }
+bcrypt = "0.15"
+image = { version = "0.25", features = ["png", "jpeg"] }
+qrcode = { version = "0.14", default-features = false, features = ["image"] }
 
 [profile.release]
 lto = "fat"
 codegen-units = 1
 panic = "abort"
 opt-level = "z"
+

Dockerfile

@@ -1,22 +1,55 @@
-FROM rust:1.83-slim-bullseye AS builder
+FROM rust:1.86-alpine AS builder
 
-RUN apt-get update && apt-get install -y \
-    build-essential \
-    libssl-dev \
-    pkg-config \
-    && rm -rf /var/lib/apt/lists/*
+RUN apk add --no-cache \
+    curl \
+    musl-dev \
+    openssl-dev \
+    openssl-libs-static \
+    pkgconfig
 
 WORKDIR /app
 
 COPY Cargo.toml Cargo.lock ./
-COPY ./src ./src
 
-RUN cargo build --release && strip /app/target/release/imphnen-backend-service
+RUN mkdir -p \
+    imphnen-backend/src \
+    imphnen-cms/src \
+    imphnen-dimentorin/src \
+    imphnen-email/src \
+    imphnen-entities/src \
+    imphnen-gacha/src \
+    imphnen-gateway/src \
+    imphnen-hackathon/src \
+    imphnen-iam/src \
+    imphnen-libs/src \
+    imphnen-macros/src \
+    imphnen-middleware/src \
+    imphnen-storage/src \
+    imphnen-utils/src && \
+    echo "fn main() {}" > imphnen-backend/src/main.rs && \
+    find . -name "src" -type d -exec sh -c 'touch "$1/lib.rs"' _ {} \;
 
-FROM gcr.io/distroless/cc AS runner
+COPY imphnen-backend ./imphnen-backend
+COPY imphnen-cms ./imphnen-cms
+COPY imphnen-dimentorin ./imphnen-dimentorin
+COPY imphnen-email ./imphnen-email
+COPY imphnen-entities ./imphnen-entities
+COPY imphnen-gacha ./imphnen-gacha
+COPY imphnen-gateway ./imphnen-gateway
+COPY imphnen-hackathon ./imphnen-hackathon
+COPY imphnen-iam ./imphnen-iam
+COPY imphnen-libs ./imphnen-libs
+COPY imphnen-macros ./imphnen-macros
+COPY imphnen-middleware ./imphnen-middleware
+COPY imphnen-storage ./imphnen-storage
+COPY imphnen-utils ./imphnen-utils
 
-WORKDIR /app
+RUN RUSTFLAGS="-C target-cpu=generic -C opt-level=s -C panic=abort -C codegen-units=1 -C strip=symbols" \
+    cargo build -p imphnen-backend --release && \
+    strip target/release/api && \
+    upx --best --lzma target/release/api 2>/dev/null || true
 
-COPY --from=builder /app/target/release/imphnen-backend-service .
-
-CMD ["/app/imphnen-backend-service"]
+FROM scratch AS runner
+COPY --from=builder /app/target/release/api /api
+COPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
+ENTRYPOINT ["/api"]

README.md

@@ -1,107 +1,130 @@
-# IMPHNEN Backend Service
-
-<p align="center">
-  <img src="docs/logo.svg" alt="IMPHNEN">
-</p>
-
-This repository serves as the **monorepo** for all backend services of IMPHNEN. It encompasses several main services:
-
-1. **Core Service** - Provides fundamental functionalities and shared resources for other services.
-2. **IAM Service** - Handles identity and access management across IMPHNEN applications.
-3. **CMS Service** - Supports the cms services by IMPHNEN [Landing Page website](https://imphnen.dev/).
-4. **Gacha Service** - Supports the gacha services by IMPHNEN [Gacha website](https://gacha.imphnen.dev/).
-5. **Dimentorin Service** - Supports the mentoring services by IMPHNEN [Dimentorin website](https://dimentorin.imphnen.dev/).
-6. **Gateway Service** - Acts as the API gateway, routing requests to appropriate services.
-
-## How to Install
-
-1. **Clone the repository**:
-
-   ```sh
-   git clone https://github.com/IMPHNEN/imphnen-backend-service.git
-   cd imphnen-backend-service
-   ```
-
-2. **Set up the environment**:
-
-   - Copy the example environment files:
-
-     ```sh
-     cp .env.example .env
-     ```
-
-     if you use windows based system
-
-     ```sh
-     ./apply-env.ps1
-     ```
-
-     if you use unix based system
-
-     ```sh
-     sh apply-env.sh
-     ```
-
-   - Modify the `.env` files with your specific configuration settings.
-
-3. **Install dependencies**:
-
-   Ensure you have [Rust](https://www.rust-lang.org/) installed. Then, run:
-
-   ```sh
-   cargo build
-   ```
-
-## How to Run
-
-### Development
-
-To run the services in development mode:
-
-1. **Start the database and other dependencies** using Docker Compose:
-
-   ```sh
-   docker-compose up -d
-   ```
-
-2. **Run the desired service**. For example, to run the Core Service:
-
-   ```sh
-   cargo run -p imphnen-core-service --bin api
-   ```
-
-### Production
-
-For production deployment:
-
-1. **Build the Docker image**:
-
-   ```sh
-   docker build -t imphnen-backend-service .
-   ```
-
-2. **Run the Docker container**:
-
-   ```sh
-   docker run -d --env-file .env -p 8080:8080 imphnen-backend-service
-   ```
-
-   Adjust the port and environment variables as needed.
-
-## How to Contribute
-
-1. **Fork the repository** and clone it locally.
-2. **Create a new branch** for your feature or fix:
-
-   ```sh
-   git checkout -b feat/your-feature-name
-   ```
-
-3. **Make your changes**, commit them, and push to your forked repository.
-4. **Create a pull request** to the `develop` branch of this repository.
-
-If you encounter any issues or have questions, feel free to create a new issue in the repository.
-
----
-
-_Note: For detailed API documentation, please refer to our [API Docs](https://api.imphnen.dev/docs)._
+# IMPHNEN Backend Service
+
+<p align="center">
+  <img src="docs/logo.svg" alt="IMPHNEN">
+</p>
+
+This repository serves as the **monorepo** for all backend services of IMPHNEN. It encompasses several main services:
+
+1. **IMPHNEN-Backend** - Provides fundamental functionalities and shared resources for other services.
+2. **IMPHNEN-IAM** - Handles identity and access management across IMPHNEN applications.
+3. **IMPHNEN-CMS** - Supports the cms services by IMPHNEN [Landing Page website](https://imphnen.dev/).
+4. **IMPHNEN-Gacha** - Supports the gacha services by IMPHNEN [Gacha website](https://gacha.imphnen.dev/).
+5. **IMPHNEN-Dimentorin** - Supports the mentoring services by IMPHNEN [Dimentorin website](https://dimentorin.imphnen.dev/).
+6. **IMPHNEN-Gateway** - Acts as the API gateway, routing requests to appropriate services.
+7. **IMPHNEN-Middleware** - Acts as the middleware for the API Gateway, providing authentication and authorization.
+
+## How to Install
+
+1. **Clone the repository**:
+
+   ```sh
+   git clone https://github.com/IMPHNEN/imphnen-backend-service.git
+   cd imphnen-backend-service
+   ```
+
+2. **Set up the environment**:
+
+   - Copy the example environment files:
+
+     ```sh
+     cp .env.example .env
+     ```
+
+     if you use windows based system
+
+     ```sh
+     ./apply-env.ps1
+     ```
+
+     if you use unix based system
+
+     ```sh
+     source ./apply-env.sh
+     ```
+
+   - Modify the `.env` files with your specific configuration settings.
+
+3. **Install dependencies**:
+
+   Ensure you have [Rust](https://www.rust-lang.org/) installed. Then, run:
+
+   ```sh
+   cargo fetch
+   ```
+
+4. **Run the seeders**:
+
+   to run the seeders, run:
+
+   ```sh
+   cargo run --bin seeder
+   ```
+
+## How to Run
+
+### Development
+
+To run the services in development mode:
+
+1. **Start the database and other dependencies** using Docker Compose:
+
+   ```sh
+   docker-compose up -d
+   ```
+
+2. **Run using cargo run**. For example, to run the Core Service:
+
+   ```sh
+   cargo run --bin api
+   ```
+
+3. **Run using cargo watch**. For example, to run the Core Service:
+
+   ```sh
+   cargo watch -x "run --bin api"
+   ```
+
+### Production
+
+For production deployment:
+
+1. **Build the Docker image**:
+
+   ```sh
+   docker build -t imphnen-backend .
+   ```
+
+2. **Run the Docker container**:
+
+   ```sh
+   docker run --name imphnen-backend -d --env-file .env -p 3000:3000 imphnen-backend
+   ```
+
+   Adjust the port and environment variables as needed.
+
+## How to Run the Tests
+
+1. **Run the tests**:
+
+   ```sh
+   cargo test -p tests
+   ```
+
+## How to Contribute
+
+1. **Fork the repository** and clone it locally.
+2. **Create a new branch** for your feature or fix:
+
+   ```sh
+   git checkout -b feat/your-feature-name
+   ```
+
+3. **Make your changes**, commit them, and push to your forked repository.
+4. **Create a pull request** to the `develop` branch of this repository.
+
+If you encounter any issues or have questions, feel free to create a new issue in the repository.
+
+---
+
+_Note: For detailed API documentation, please refer to our [API Docs](https://api.imphnen.dev/docs)._

apply-env.ps1

@@ -1,30 +0,0 @@
-function Set-TempEnvFromDotEnv {
-    param (
-        [string]$envFilePath
-    )
-
-    if (-Not (Test-Path $envFilePath)) {
-        Write-Error "The .env file at path '$envFilePath' does not exist."
-        return
-    }
-
-    $envContent = Get-Content $envFilePath
-
-    foreach ($line in $envContent) {
-        $trimmedLine = $line.Trim()
-
-        if (-Not [string]::IsNullOrWhiteSpace($trimmedLine) -and -Not $trimmedLine.StartsWith("#")) {
-            $keyValue = $trimmedLine -split "=", 2
-            if ($keyValue.Length -eq 2) {
-                $key = $keyValue[0].Trim()
-                $value = $keyValue[1].Trim()
-                [System.Environment]::SetEnvironmentVariable($key, $value, [System.EnvironmentVariableTarget]::Process)
-                Write-Host "Set temporary environment variable: $key=$value"
-            }
-        }
-    }
-
-    Write-Host "All environment variables from '$envFilePath' have been set temporarily."
-}
-
-Set-TempEnvFromDotEnv -envFilePath ".env"

apply-env.sh

@@ -1,25 +0,0 @@
-#!/bin/bash
-
-set_temp_env_from_dotenv() {
-    local env_file_path="$1"
-
-    if [[ ! -f "$env_file_path" ]]; then
-        echo "Error: The .env file at path '$env_file_path' does not exist."
-        return 1
-    fi
-
-    while IFS= read -r line || [[ -n "$line" ]]; do
-        trimmed_line=$(echo "$line" | xargs)
-
-        if [[ -n "$trimmed_line" && ! "$trimmed_line" =~ ^# ]]; then
-            key=$(echo "$trimmed_line" | cut -d '=' -f 1 | xargs)
-            value=$(echo "$trimmed_line" | cut -d '=' -f 2- | xargs)
-            export "$key=$value"
-            echo "Set temporary environment variable: $key=$value"
-        fi
-    done < "$env_file_path"
-
-    echo "All environment variables from '$env_file_path' have been set temporarily."
-}
-
-set_temp_env_from_dotenv ".env"

default.nix

@@ -1,15 +1,25 @@
-{pkgs ? import <nixpkgs> {}}: let
-  manifest = (pkgs.lib.importTOML ./Cargo.toml).package;
-  rustDeps = pkgs.callPackage ./Cargo.nix {};
-  packageEntry = rustDeps.workspaceMembers.${manifest.name};
-  deps = packageEntry.build.cargoDeps or null;
+{ pkgs ? import <nixpkgs> { } }:
+let
+  swaggerUi = pkgs.fetchurl {
+    url = "https://github.com/swagger-api/swagger-ui/archive/refs/tags/v5.17.14.zip";
+    hash = "sha256-SBJE0IEgl7Efuu73n3HZQrFxYX+cn5UU5jrL4T5xzNw=";
+  };
 in
-  pkgs.rustPlatform.buildRustPackage {
-    pname = manifest.name;
-    version = manifest.version;
-    cargoDeps = deps;
-    src = pkgs.lib.cleanSource ./.;
-    cargoLock.lockFile = ./Cargo.lock;
-    nativeBuildInputs = [pkgs.openssl pkgs.pkg-config];
-    buildInputs = [pkgs.openssl];
-  }
+pkgs.rustPlatform.buildRustPackage {
+  pname = "imphnen-backend";
+  version = (pkgs.lib.importTOML ./imphnen-backend/Cargo.toml).package.version;
+  src = pkgs.lib.cleanSource ./.;
+  cargoLock.lockFile = ./Cargo.lock;
+  cargoBuildFlags = [
+    "--package"
+    "imphnen-backend"
+    "--bin"
+    "api"
+  ];
+  nativeBuildInputs = [ pkgs.pkg-config ];
+  buildInputs = [ pkgs.openssl ];
+  preBuild = ''
+    export SWAGGER_UI_DOWNLOAD_URL="file://${swaggerUi}"
+  '';
+  doCheck = false;
+}

docker-compose.yml

@@ -1,16 +1,46 @@
-services:
-  api:
-    build:
-      context: .
-      dockerfile: Dockerfile
-    ports:
-      - "${PORT}:${PORT}"
-    env_file: ".env"
-    depends_on:
-      - surrealdb
-
-  surrealdb:
-    image: surrealdb/surrealdb:latest
-    command: start --log trace --user root --pass root
-    ports:
-      - "8000:8000"
+services:
+  api:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    ports:
+      - "${PORT}:${PORT}"
+    env_file: ".env"
+    depends_on:
+      - postgres
+
+  postgres:
+    image: postgres:15-alpine
+    container_name: imphnen_postgres
+    environment:
+      POSTGRES_DB: ${POSTGRES_DB:-imphnen}
+      POSTGRES_USER: ${POSTGRES_USER:-postgres}
+      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-postgres}
+    ports:
+      - "${POSTGRES_PORT:-5432}:5432"
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+      - ./init.sql:/docker-entrypoint-initdb.d/init.sql
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-postgres} -d ${POSTGRES_DB:-imphnen}"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+      start_period: 30s
+
+  minio:
+    image: minio/minio:latest
+    container_name: minio
+    ports:
+      - "9000:9000"
+      - "9001:9001"
+    environment:
+      MINIO_ROOT_USER: minioadmin
+      MINIO_ROOT_PASSWORD: minioadmin
+    command: server /data --console-address ":9001"
+    volumes:
+      - minio_data:/data
+
+volumes:
+  postgres_data:
+  minio_data:

docker.nix

@@ -1,42 +1,43 @@
-{pkgs, ...}: let
-  baseImage = pkgs.ociTools.pullImage {
-    imageName = "ubuntu";
-    tag = "latest";
-  };
-in
-  pkgs.dockerTools.buildImage {
-    name = "imphnen-cms-api";
-
-    fromImage = baseImage;
-
-    copyToRoot = pkgs.buildEnv {
-      name = "imphnen-cms-api";
-      paths = [
-        (pkgs.stdenv.mkDerivation {
-          name = "imphnen-cms-api";
-          src = ./src;
-
-          buildInputs = [
-            pkgs.rustc
-            pkgs.cargo
-            pkgs.openssl
-            pkgs.pkg-config
-          ];
-
-          buildPhase = ''
-            cargo build --release
-          '';
-
-          installPhase = ''
-            mkdir -p $out/bin
-            cp target/release/najm-course-api $out/bin/
-          '';
-        })
-      ];
-    };
-
-    config = {
-      Cmd = ["/bin/imphnen-cms-api"];
-      WorkingDir = "/bin";
-    };
-  }
+{ pkgs, ... }:
+let
+  baseImage = pkgs.ociTools.pullImage {
+    imageName = "ubuntu";
+    tag = "latest";
+  };
+in
+pkgs.dockerTools.buildImage {
+  name = "imphnen-backend-service";
+
+  fromImage = baseImage;
+
+  copyToRoot = pkgs.buildEnv {
+    name = "imphnen-backend-service";
+    paths = [
+      (pkgs.stdenv.mkDerivation {
+        name = "imphnen-backend-service";
+        src = ./src;
+
+        buildInputs = [
+          pkgs.rustc
+          pkgs.cargo
+          pkgs.openssl
+          pkgs.pkg-config
+        ];
+
+        buildPhase = ''
+          cargo build --release
+        '';
+
+        installPhase = ''
+          mkdir -p $out/bin
+          cp target/release/imphnen-backend-service $out/bin/
+        '';
+      })
+    ];
+  };
+
+  config = {
+    Cmd = [ "/bin/imphnen-backend-service" ];
+    WorkingDir = "/bin";
+  };
+}

docs/dev-audit-findings.md

@@ -0,0 +1,74 @@
+# Dimentorin — Catatan Temuan Infra (Dev Audit, 2026-08-04)
+
+Dokumen ini mencatat temuan yang membutuhkan perhatian tim sebelum produksi.
+Semua diuji lokal (Postgres `dimentorin`, backend :4099).
+
+## 1. SMTP email verification broken (blocker aktivasi user baru) — ✅ FIXED (2026-08-05, Google App Password)
+
+- Endpoint `POST /v1/iam/auth/send-otp` gagal: `SMTP transport error (535): Username and Password not accepted` — kredensial `.env` (`SMTP_EMAIL=dev@example.com`, `SMTP_PASSWORD=dev`) ditolak Google SMTP.
+- `POST /v1/iam/auth/verify-email` tetap butuh OTP untuk memanggil, tapi lihat poin 2.
+- **Dampak**: mentee/mentor baru tak bisa menerima OTP lewat email → tak bisa aktivasi → tak bisa login, kecuali via verify-email langsung.
+- **Diperlukan**: SMTP credential institution yang valid (Gmail App Password atau SMTP relay), sebaiknya dari BWS secret management, bukan hardcode.
+
+## 2. ✅ FIXED — verify-email TIDAK memverifikasi OTP (security issue)
+
+**Status: FIXED di branch feat/dimentorin-postgres (2026-08-04).**
+
+`imphnen-iam/src/auth/application/mod.rs` → `verify_email()`:
+
+- OTP sekarang dipersist ke tabel **`app_otp_cache`** (entity baru `imphnen-entities/src/seaorm/common/otp_cache.rs`, resource `app_otp_cache` sudah direncanakan di `ResourceEnum::OtpCache`).
+- `register()` & `resend_otp()` menyimpan `otp_hash` + `expires_at` setelah email terkirim (kalau email gagal, tidak ada OTP yatim / OTP lama tidak di-overwrite).
+- `verify_email()` memanggil `OtpManager::validate_otp_hash(stored_hash, expires_at, payload.otp)` sebelum set `is_active`. `validate_otp_hash` ditambahkan ke `OtpManager` (pure hash+expiry tanpa perlu plaintext code).
+- OTP **single-use**: di-delete setelah verifikasi sukses. Reuse / OTP tanpa cache / OTP expired semua ditolak (400).
+- Uji lokal (Postgres, :4099): OTP salah → 400 "Invalid or expired OTP", user tetap inactive; OTP benar → 200 "Email verified successfully", user aktif, OTP dihapus; verify ulang → 400 "User already active"; email tanpa OTP → 400 "No OTP issued".
+- Tabel dibuat via SQL manual (`create_schema.rs` ditambah `otp_cache` untuk bootstrap penuh).
+
+## 3. (OK, sudah benar) Register mentor + booking
+
+- `POST /v1/dimentorin/mentors/create` → 200, user + mentor profile dibuat, status `pending`, user tak tampil di list public sampai verified.
+- `POST /v1/dimentorin/mentors/{id}/sessions/create` → 200, session pending.
+- Kedua endpoint fungsional setelah fix UUID (commit 9b5efef).
+
+## Rekomendasi
+
+Tangani #1 dan #2 sebelum go-live. #2 adalah kelas bug "OTP di-generate tapi tak dipakai" — sisi verifikasi email saat ini tidak lebih dari form "set is_active=true tanpa autentikasi".
+
+## 4. ✅ DONE — Payment flow (alur bisnis menjual)
+
+**Status: DONE di feat/dimentorin-postgres (2026-08-05).**
+
+- Tabel `app_payments`: amount (dari `mentoring_rate` mentor) + service_fee 2000 + total; method `va`/`qris`/`manual`; provider `manual` default (swap Midtrans/Xendit nanti — cukup ganti nilai `provider` dan implementasi `generate_external_ref`/notifikasi webhook).
+- Routes protected: `POST /payments/sessions/{id}/create`, `GET /payments/me`, `GET /payments/{id}`, `POST /payments/{id}/confirm`.
+- Guard: mentee hanya bisa akses payment miliknya (403 kalau bukan); confirm hanya Admin / Admin Pembayaran.
+- `confirm_payment` otomatis mengubah session terkait `pending` -> `confirmed` (loop bisnis lengkap: book -> bayar -> sesi terkonfirmasi -> feedback).
+- FE: PaymentStep pilih VA/QRIS, rate real dari `mentoring_rate`; modal appointment: book -> create payment -> tampil VA/QR dengan `external_ref` + total + expiry -> success. Service lib: `postCreatePayment/getMyPayments/getPaymentById/postConfirmPayment`.
+- E2E verified (lokal :4099): create VA dan QRIS, confirm 200, re-confirm 409, non-admin 403, akses payment orang lain 403, session auto-confirmed.
+- TODO produksi: isi kredensial payment gateway (Midtrans/Xendit) + webhook callback; SMTP masih blocker (#1).
+
+## 5. Payment lifecycle complete: auto-paid refresh + dashboards (2026-08-05)
+- POST /payments/{id}/refresh: polls Midtrans v2/{order_id}/status; settlement/capture -> payment paid + session confirmed automatically (e2e verified via sandbox simulator: VA paid -> refresh -> paid + confirmed)
+- GET /payments/session/{id}: payments for one session, accessible by that session's mentee or mentor (powers both dashboards)
+- Session mentor may confirm their own payments (previously admins only) — verified e2e
+- FE: /mentoring/my-sessions (mentee) + /mentoring/mentor-dashboard (mentor), both with live payment status and refresh/confirm actions; QRIS step renders real QR from qr_string
+
+
+## 6. Materi + AI Agent RAG (2026-08-05, commit 164c186 BE / 7294040 FE)
+
+Fitur yang "harusnya ada" menurut user (Figma hanya berisi Design System, halaman Materi/AI Agent tidak ada di file) — dibangun dari pemahaman alur bisnis mentoring.
+
+**Backend — modul materials** (`imphnen-dimentorin/src/materials/`):
+- `app_materials` table: mentor_id, title, slug, category, description, content, cover_url, is_published
+- Pola articles: domain/repository/service + postgres repo + DTO ZodValidate
+- Routes: GET /materials (public, published), /materials/{id|slug|categories}, POST/PUT/DELETE (auth, author-only)
+- ENV baru: AI_LLM_BASE_URL/API_KEY/MODEL, AI_EMBEDDING_MODEL, QDRANT_URL
+
+**Backend — AI agent RAG** (`imphnen-dimentorin/src/ai_agent/`):
+- Chunking materi (700 chars, overlap 80) -> embed via 9router `gemini/gemini-embedding-001` (3072 dim!)
+- Qdrant collection `dimentorin_materi` (3072d cosine, point id = u64 dari uuid xor index — Qdrant TOLAK string non-UUID)
+- Chat: embed question -> search top-4 -> LLM (`text` -> gemini-3.1-flash-lite) jawab dengan konteks + sources
+- Routes: POST /ai/chat, POST /ai/materials/{id}/index, POST /ai/reindex
+- 9router chat SELALU SSE-streaming walau tanpa stream:true — parser harus agregate `data:` lines
+
+**Verified e2e**: reindex 3 chunks; chat 'ownership' -> source materi Rust 0.88; chat 'endpoint axum' -> Axum 0.82; browser: list materi, detail, chatbox jawab + sources 84/64/61%.
+
+**Pitfall**: embedding Gemini = 3072 dim (bukan 768); Qdrant point id harus u64/UUID; model embedding yang berfungsi di 9router = `gemini/gemini-embedding-001` (llama-nemotron -> 'No credentials for provider: openai').

flake.lock

@@ -2,11 +2,11 @@
   "nodes": {
     "nixpkgs": {
       "locked": {
-        "lastModified": 1739020877,
-        "narHash": "sha256-mIvECo/NNdJJ/bXjNqIh8yeoSjVLAuDuTUzAo7dzs8Y=",
+        "lastModified": 1775036866,
+        "narHash": "sha256-ZojAnPuCdy657PbTq5V0Y+AHKhZAIwSIT2cb8UgAz/U=",
         "owner": "nixos",
         "repo": "nixpkgs",
-        "rev": "a79cfe0ebd24952b580b1cf08cd906354996d547",
+        "rev": "6201e203d09599479a3b3450ed24fa81537ebc4e",
         "type": "github"
       },
       "original": {

flake.nix

@@ -5,28 +5,43 @@
     nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
   };
 
-  outputs = {
-    self,
-    nixpkgs,
-  }: let
-    supportedSystems = ["x86_64-linux" "x86_64-darwin" "aarch64-darwin" "aarch64-linux"];
-    pkgsFor = system:
-      import nixpkgs {
-        inherit system;
-        config = {
-          allowUnfree = true;
+  outputs =
+    {
+      self,
+      nixpkgs,
+    }:
+    let
+      supportedSystems = [
+        "x86_64-linux"
+        "x86_64-darwin"
+        "aarch64-darwin"
+        "aarch64-linux"
+      ];
+      pkgsFor =
+        system:
+        import nixpkgs {
+          inherit system;
+          config.allowUnfree = true;
         };
+      forAllSystems = nixpkgs.lib.genAttrs supportedSystems;
+    in
+    {
+      packages = forAllSystems (system: {
+        default = (pkgsFor system).callPackage ./default.nix { };
+      });
+
+      overlays.default = final: _prev: {
+        imphnen-backend = final.callPackage ./default.nix { };
       };
-    forAllSystems = nixpkgs.lib.genAttrs supportedSystems;
-  in {
-    packages = forAllSystems (system: {
-      default = (pkgsFor system).callPackage ./default.nix {};
-    });
-    devShells = forAllSystems (system: {
-      default = (pkgsFor system).callPackage ./shell.nix {};
-    });
-    dockerImages = forAllSystems (system: {
-      tryOutApi = (pkgsFor system).callPackage ./docker.nix {};
-    });
-  };
+
+      nixosModules.backend = ./nixos-module.nix;
+
+      devShells = forAllSystems (system: {
+        default = (pkgsFor system).callPackage ./shell.nix { };
+      });
+
+      dockerImages = forAllSystems (system: {
+        tryOutApi = (pkgsFor system).callPackage ./docker.nix { };
+      });
+    };
 }

imphnen-backend/Cargo.toml

@@ -1,23 +1,69 @@
 [package]
 name = "imphnen-backend"
-version = "0.1.0"
+version = "0.3.0"
 edition = "2021"
 
+[[bin]]
+name = "api"
+path = "src/main.rs"
+
+[[bin]]
+name = "create_schema"
+path = "src/bin/create_schema.rs"
+
+[[bin]]
+name = "seeder"
+path = "src/bin/seeder.rs"
+
+[[bin]]
+name = "seed_events"
+path = "src/bin/seed_events.rs"
+
+[[bin]]
+name = "seed_gacha_rolls"
+path = "src/bin/seed_gacha_rolls.rs"
+
+[[bin]]
+name = "seed_mentor_user"
+path = "src/bin/seed_mentor_user.rs"
+
+[[bin]]
+name = "seed_permissions"
+path = "src/bin/seed_permissions.rs"
+
+[[bin]]
+name = "seed_roles"
+path = "src/bin/seed_roles.rs"
+
+[[bin]]
+name = "seed_roles_permissions"
+path = "src/bin/seed_roles_permissions.rs"
+
+[[bin]]
+name = "seed_test_data"
+path = "src/bin/seed_test_data.rs"
+
+[[bin]]
+name = "test_postgres"
+path = "src/bin/test_postgres.rs"
+
 [dependencies]
-imphnen-libs = { version = "0.1.0", path = "../imphnen-libs" }
-imphnen-utils = { version = "0.1.0", path = "../imphnen-utils" }
-imphnen-gateway = { version = "0.1.0", path = "../imphnen-gateway" }
-imphnen-entities = { version = "0.1.0", path = "../imphnen-entities" }
-imphnen-iam = { version = "0.1.0", path = "../imphnen-iam" }
+sea-orm.workspace = true
+imphnen-libs.workspace = true
+imphnen-utils.workspace = true
+imphnen-gateway.workspace = true
+imphnen-entities.workspace = true
+imphnen-iam.workspace = true
+imphnen-cms.workspace = true
+imphnen-gacha.workspace = true
+imphnen-dimentorin.workspace = true
 axum.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 utoipa.workspace = true
 lazy_static.workspace = true
 regex.workspace = true
-validator.workspace = true
 axum-test.workspace = true
-surrealdb.workspace = true
 rand.workspace = true
 tokio.workspace = true
 chrono.workspace = true
@@ -25,3 +71,6 @@ anyhow.workspace = true
 tower-http.workspace = true
 utoipa-swagger-ui.workspace = true
 env_logger.workspace = true
+tracing.workspace = true
+tracing-subscriber.workspace = true
+uuid.workspace=true

imphnen-backend/src/bin/api.rs

@@ -1,12 +1,10 @@
-use env_logger;
 use imphnen_gateway::gateway_service;
 use imphnen_libs::axum_init;
 
 #[tokio::main]
 async fn main() {
-	env_logger::init();
-	axum_init(|surrealdb_ws, surrealdb_mem| async {
-		gateway_service(surrealdb_ws, surrealdb_mem).await
+	axum_init(|postgres_db| async {
+		gateway_service(postgres_db).await
 	})
 	.await;
 }

imphnen-backend/src/bin/clear_db.rs

@@ -0,0 +1,91 @@
+#![allow(clippy::all)]
+
+use imphnen_libs::postgres::{PostgresConfig, PostgresConnection};
+use sea_orm::{ConnectionTrait, Statement};
+use std::env;
+use std::error::Error;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn Error>> {
+	let args: Vec<String> = env::args().collect();
+	let dry_run = args
+		.iter()
+		.any(|s| s == "--dry-run" || s == "--no-exec" || s == "--dry");
+	let force = args.iter().any(|s| s == "--force" || s == "-f");
+
+	println!("🔎 Clear DB script - WARNING: This will remove data from tables\n");
+	println!("Note: script now runs by default (no --yes required). To preview without executing, use --dry-run.\n");
+
+	let tables = vec![
+		"gacha_claims",
+		"gacha_rolls",
+		"gacha_items",
+		"gacha_credits",
+		"audit_logs",
+		"rate_limits",
+		"testimonials",
+		"events",
+		"app_mentors",
+		"app_sessions",
+		"app_roles_permissions",
+		"app_permissions",
+		"app_roles",
+		"app_users",
+	];
+
+	let postgres_config = PostgresConfig::from_env()?;
+	let pg_conn = PostgresConnection::new(postgres_config).await?;
+	let db = &pg_conn.conn;
+
+	let mut existing_tables: Vec<&str> = vec![];
+	for t in tables.iter() {
+		let check_sql = format!(
+            "SELECT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_schema = 'public' AND table_name = '{}') as exists;",
+            t
+        );
+		let stmt = Statement::from_string(db.get_database_backend(), check_sql);
+		if let Ok(Some(row)) = pg_conn.query_one(stmt).await {
+			let exists_val: Option<bool> = row.try_get("", "exists").ok();
+			if exists_val.unwrap_or(false) {
+				existing_tables.push(t);
+			}
+		}
+	}
+
+	if existing_tables.is_empty() {
+		println!("No configured tables found to clear - nothing to do.");
+		return Ok(());
+	}
+
+	let truncate_sql = format!(
+		"TRUNCATE TABLE {} RESTART IDENTITY CASCADE;",
+		existing_tables.join(", ")
+	);
+
+	println!("The script will run the following SQL (on the DB configured by env vars):\n\n{}", truncate_sql);
+
+	let env_name = imphnen_libs::ENV.rust_env.clone();
+	if env_name == "production" && !force {
+		println!("Security: RUST_ENV=production; the script will NOT run without --force. Use --force to override.");
+		return Ok(());
+	}
+
+	if dry_run {
+		println!("Dry run enabled. No changes applied. To execute, re-run without --dry-run or use --force (in production).");
+		return Ok(());
+	}
+
+	println!("Executing truncate...\n");
+
+	let postgres_config = PostgresConfig::from_env()?;
+	let pg_conn = PostgresConnection::new(postgres_config).await?;
+	let db = &pg_conn.conn;
+
+	let stmt = Statement::from_string(db.get_database_backend(), truncate_sql);
+	match pg_conn.execute(stmt).await {
+		Ok(_) => println!("✅ Successfully cleared DB tables"),
+		Err(e) => println!("❌ Failed to clear DB tables: {}", e),
+	}
+
+	Ok(())
+}

imphnen-backend/src/bin/create_schema.rs

@@ -0,0 +1,81 @@
+#![allow(clippy::all)]
+
+use imphnen_entities::seaorm::{auth, common, gacha};
+use imphnen_libs::postgres::PostgresConfig;
+use sea_orm::sea_query::Table;
+use sea_orm::{ConnectionTrait, Database, DbBackend, EntityTrait, Schema};
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+	println!("🛠️  Creating database schema...");
+
+	let config = PostgresConfig::from_env()?;
+	let db = Database::connect(&config.database_url).await?;
+	let builder = db.get_database_backend();
+
+	println!("   Database connected. Creating/updating tables...");
+
+	drop_and_create_table(&db, builder, "app_roles", auth::roles::Entity).await?;
+	drop_and_create_table(&db, builder, "app_permissions", auth::permissions::Entity)
+		.await?;
+	drop_and_create_table(&db, builder, "app_users", auth::users::Entity).await?;
+	drop_and_create_table(
+		&db,
+		builder,
+		"app_roles_permissions",
+		auth::roles_permissions::Entity,
+	)
+	.await?;
+	drop_and_create_table(&db, builder, "app_mentors", auth::mentors::Entity).await?;
+	drop_and_create_table(&db, builder, "app_sessions", auth::sessions::Entity)
+		.await?;
+	drop_and_create_table(&db, builder, "app_articles", common::articles::Entity)
+		.await?;
+
+	drop_and_create_table(&db, builder, "events", common::events::Entity).await?;
+	drop_and_create_table(&db, builder, "testimonials", common::testimonials::Entity)
+		.await?;
+	drop_and_create_table(&db, builder, "audit_logs", common::audit_log::Entity)
+		.await?;
+	drop_and_create_table(&db, builder, "rate_limits", common::rate_limit::Entity)
+		.await?;
+	drop_and_create_table(&db, builder, "otp_cache", common::otp_cache::Entity).await?;
+	drop_and_create_table(&db, builder, "payments", common::payments::Entity)
+		.await?;
+
+	drop_and_create_table(&db, builder, "gacha_credits", gacha::gacha_credits::Entity)
+		.await?;
+	drop_and_create_table(&db, builder, "gacha_items", gacha::gacha_items::Entity)
+		.await?;
+	drop_and_create_table(&db, builder, "gacha_rolls", gacha::gacha_rolls::Entity)
+		.await?;
+	drop_and_create_table(&db, builder, "gacha_claims", gacha::gacha_claims::Entity)
+		.await?;
+
+	println!("✅ Schema creation completed.");
+	Ok(())
+}
+
+async fn drop_and_create_table<E>(
+	db: &sea_orm::DatabaseConnection,
+	builder: DbBackend,
+	name: &str,
+	entity: E,
+) -> Result<(), Box<dyn std::error::Error>>
+where
+	E: EntityTrait,
+{
+	let schema = Schema::new(builder);
+
+	let drop_stmt = Table::drop().table(entity).if_exists().cascade().to_owned();
+	db.execute(builder.build(&drop_stmt)).await?;
+	println!("   Dropped table if exists: {}", name);
+
+	let mut create_stmt = schema.create_table_from_entity(entity);
+	create_stmt.if_not_exists();
+
+	db.execute(builder.build(&create_stmt)).await?;
+	println!("   ✅ Created table: {}", name);
+
+	Ok(())
+}

imphnen-backend/src/bin/mk_token.rs

@@ -0,0 +1,20 @@
+#![allow(clippy::all)]
+
+use imphnen_libs::jsonwebtoken::encode_access_token;
+use std::env;
+
+fn main() {
+	let args: Vec<String> = env::args().collect();
+	if args.len() < 2 {
+		eprintln!("Usage: mk_token <email_or_sub>");
+		std::process::exit(1);
+	}
+	let sub = args[1].clone();
+	match encode_access_token(sub.clone(), sub.clone()) {
+		Ok(token) => println!("{}", token),
+		Err(e) => {
+			eprintln!("Failed to generate token: {:?}", e);
+			std::process::exit(2);
+		}
+	}
+}

imphnen-backend/src/bin/seed_articles.rs

@@ -0,0 +1,40 @@
+#![allow(clippy::all)]
+use chrono::Utc;
+use imphnen_entities::seaorm::common::articles::{
+    ActiveModel as ArticleActiveModel, Entity as ArticlesEntity,
+};
+use imphnen_libs::postgres::PostgresConfig;
+use sea_orm::{ActiveModelTrait, ActiveValue, Database};
+use uuid::Uuid;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let config = PostgresConfig::from_env()?;
+    let db = Database::connect(&config.database_url).await?;
+
+    let articles = vec![
+        ("Cara Memulai Karier di UI/UX Design", "cara-memulai-karier-ui-ux-design", "UI/UX & Design", "Panduan lengkap untuk masuk ke dunia UI/UX design, dari skill yang dibutuhkan hingga portofolio.", "Lorem ipsum dolor sit amet, consectetur adipiscing elit. UI/UX design adalah bidang yang menjanjikan. Artikel ini membahas langkah awal memulai karier sebagai UI/UX designer, tools yang wajib dikuasai seperti Figma, serta cara membangun portofolio yang menarik bagi perekrut."),
+        ("Belajar Rust: Panduan Pemula 2026", "belajar-rust-panduan-pemula-2026", "Software/Web Dev", "Bahasa pemrograman Rust sedang naik daun. Pelajari konsep ownership dan borrow checker.", "Rust adalah bahasa pemrograman yang fokus pada performa dan keamanan memori. Dalam artikel ini kita membahas ownership, borrowing, dan cara setup environment Rust di Linux dan Windows, serta contoh project sederhana."),
+        ("Mengenal Machine Learning untuk Data Analyst", "mengenal-machine-learning-data-analyst", "Data & AI", "Peran Data Analyst berevolusi dengan hadirnya machine learning. Simak panduannya.", "Machine learning membuka peluang besar bagi data analyst. Artikel ini menjelaskan perbedaan data analysis dan machine learning, serta roadmap belajar dari Python, pandas, sampai scikit-learn."),
+    ];
+
+    for (title, slug, category, excerpt, content) in articles {
+        let am = ArticleActiveModel {
+            id: ActiveValue::Set(Uuid::new_v4()),
+            title: ActiveValue::Set(title.to_string()),
+            slug: ActiveValue::Set(slug.to_string()),
+            category: ActiveValue::Set(category.to_string()),
+            excerpt: ActiveValue::Set(excerpt.to_string()),
+            content: ActiveValue::Set(content.to_string()),
+            cover_url: ActiveValue::Set(None),
+            author_name: ActiveValue::Set(Some("IMPHNEN Editorial".to_string())),
+            is_published: ActiveValue::Set(true),
+            created_at: ActiveValue::Set(Utc::now()),
+            updated_at: ActiveValue::Set(Utc::now()),
+        };
+        am.insert(&db).await?;
+        println!("✅ Inserted article: {}", slug);
+    }
+    println!("🟢 All articles seeded");
+    Ok(())
+}

imphnen-backend/src/bin/seed_events.rs

@@ -0,0 +1,205 @@
+#![allow(clippy::all)]
+
+use chrono::Utc;
+use imphnen_entities::seaorm::common::events::{
+	ActiveModel as EventsActiveModel, Entity as EventEntity,
+};
+use imphnen_libs::postgres::{PostgresConfig, PostgresConnection};
+use sea_orm::{
+	ActiveModelTrait, ActiveValue::Set, ColumnTrait, EntityTrait, QueryFilter,
+};
+use std::error::Error;
+use uuid::Uuid;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn Error>> {
+	let postgres_config = PostgresConfig::from_env()?;
+	let pg_conn = PostgresConnection::new(postgres_config).await?;
+	let db = &pg_conn.conn;
+
+	let events = vec![
+		(
+			"Tech Conference 2025",
+			"Annual technology conference featuring the latest innovations in software development, AI, and cloud computing.",
+			"https://techconf2025.example.com",
+			150.0,
+			Some("Jakarta Convention Center".to_string()),
+			false,
+			"2025-06-15T09:00:00Z",
+			"2025-06-17T18:00:00Z",
+		),
+		(
+			"Online Web Development Workshop",
+			"Comprehensive workshop covering modern web development frameworks including React, Vue, and Angular.",
+			"https://webdev-workshop.example.com",
+			75.0,
+			None,
+			true,
+			"2025-07-10T14:00:00Z",
+			"2025-07-10T17:00:00Z",
+		),
+		(
+			"Startup Pitch Competition",
+			"Exciting competition where emerging startups present their innovative ideas to a panel of expert judges and investors.",
+			"https://startup-pitch.example.com",
+			25.0,
+			Some("Innovation Hub Surabaya".to_string()),
+			false,
+			"2025-08-05T10:00:00Z",
+			"2025-08-05T16:00:00Z",
+		),
+		(
+			"Digital Marketing Masterclass",
+			"Learn advanced digital marketing strategies, social media optimization, and data-driven marketing techniques.",
+			"https://digital-marketing.example.com",
+			100.0,
+			None,
+			true,
+			"2025-09-20T13:00:00Z",
+			"2025-09-22T15:00:00Z",
+		),
+        (
+            "Rust Programming Bootcamp",
+            "Intensive 3-day bootcamp to master Rust fundamentals and advanced concepts.",
+            "https://rust-bootcamp.example.com",
+            200.0,
+            Some("Bandung Digital Valley".to_string()),
+            false,
+            "2025-10-01T09:00:00Z",
+            "2025-10-03T17:00:00Z",
+        ),
+        (
+            "AI & Machine Learning Summit",
+            "Global summit discussing the future of AI and its impact on industries.",
+            "https://ai-summit.example.com",
+            300.0,
+            Some("Bali Nusa Dua Convention Center".to_string()),
+            false,
+            "2025-11-15T08:00:00Z",
+            "2025-11-17T18:00:00Z",
+        ),
+        (
+            "Cybersecurity Awareness Webinar",
+            "Free webinar on best practices for personal and corporate cybersecurity.",
+            "https://cybersecurity-webinar.example.com",
+            0.0,
+            None,
+            true,
+            "2025-12-05T14:00:00Z",
+            "2025-12-05T16:00:00Z",
+        ),
+        (
+            "Cloud Computing Workshop",
+            "Hands-on workshop on deploying scalable applications using AWS and Azure.",
+            "https://cloud-workshop.example.com",
+            120.0,
+            None,
+            true,
+            "2026-01-20T10:00:00Z",
+            "2026-01-22T15:00:00Z",
+        ),
+        (
+            "Blockchain for Finance",
+            "Exploring the applications of blockchain technology in the financial sector.",
+            "https://blockchain-finance.example.com",
+            180.0,
+            Some("Jakarta Ritz-Carlton".to_string()),
+            false,
+            "2026-02-10T09:00:00Z",
+            "2026-02-11T17:00:00Z",
+        ),
+        (
+            "Game Development Jam",
+            "48-hour game development marathon for indie developers.",
+            "https://game-jam.example.com",
+            50.0,
+            Some("Yogyakarta Creative Hub".to_string()),
+            false,
+            "2026-03-15T18:00:00Z",
+            "2026-03-17T18:00:00Z",
+        ),
+        (
+            "UX/UI Design Principles",
+            "Masterclass on creating intuitive and user-friendly interfaces.",
+            "https://uxui-design.example.com",
+            90.0,
+            None,
+            true,
+            "2026-04-05T13:00:00Z",
+            "2026-04-07T16:00:00Z",
+        ),
+        (
+            "Data Science Fundamentals",
+            "Introduction to data analysis, visualization, and statistical modeling.",
+            "https://data-science.example.com",
+            110.0,
+            None,
+            true,
+            "2026-05-12T10:00:00Z",
+            "2026-05-14T15:00:00Z",
+        ),
+        (
+            "IoT Innovation Expo",
+            "Showcase of the latest Internet of Things devices and solutions.",
+            "https://iot-expo.example.com",
+            50.0,
+            Some("Surabaya Expo Center".to_string()),
+            false,
+            "2026-06-20T09:00:00Z",
+            "2026-06-22T18:00:00Z",
+        ),
+	];
+
+	for (
+		name,
+		description,
+		detail_link,
+		price,
+		location,
+		is_online,
+		start_date_str,
+		end_date_str,
+	) in events
+	{
+		let existing = EventEntity::find()
+			.filter(<EventEntity as EntityTrait>::Column::Name.eq(name))
+			.one(db)
+			.await?;
+		if existing.is_some() {
+			println!("ℹ️  Skipping (already exists): {name}");
+			continue;
+		}
+
+		let uuid = Uuid::new_v4();
+		let mut event_model: EventsActiveModel = Default::default();
+		event_model.id = Set(uuid);
+		event_model.name = Set(name.to_string());
+		event_model.description = Set(description.to_string());
+		event_model.detail_link = Set(detail_link.to_string());
+		event_model.price = Set(price);
+		event_model.is_online = Set(is_online);
+		event_model.location = Set(location.clone());
+		event_model.start_date = Set(
+			chrono::DateTime::parse_from_rfc3339(start_date_str)?
+				.with_timezone(&chrono::Utc),
+		);
+		event_model.end_date = Set(
+			chrono::DateTime::parse_from_rfc3339(end_date_str)?
+				.with_timezone(&chrono::Utc),
+		);
+		event_model.is_deleted = Set(false);
+		event_model.created_at = Set(Utc::now());
+		event_model.updated_at = Set(Utc::now());
+
+		event_model.insert(db).await?;
+
+		println!(
+			"✅ Inserted event: {} ({})",
+			name,
+			if is_online { "Online" } else { "In-person" }
+		);
+	}
+
+	println!("✅ All Events seeded");
+	Ok(())
+}

imphnen-backend/src/bin/seed_gacha_rolls.rs

@@ -0,0 +1,84 @@
+#![allow(clippy::all)]
+
+use imphnen_entities::seaorm::gacha::gacha_items::ActiveModel as GachaItemActiveModel;
+use imphnen_entities::seaorm::gacha::gacha_rolls::ActiveModel as GachaRollActiveModel;
+use imphnen_libs::postgres::{PostgresConfig, PostgresConnection};
+use sea_orm::ActiveModelTrait;
+use sea_orm::ActiveValue::Set;
+use sea_orm::ConnectionTrait;
+use std::error::Error;
+use uuid::Uuid;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn Error>> {
+	let config = PostgresConfig::from_env()?;
+	let pg_conn = PostgresConnection::new(config).await?;
+	let db = &pg_conn.conn;
+
+	let check_item_sql =
+		"SELECT id FROM app_gacha_items WHERE item_code = 'ITEM_TEST_1' LIMIT 1";
+	let item_result = pg_conn
+		.query_one(sea_orm::Statement::from_string(
+			db.get_database_backend(),
+			check_item_sql,
+		))
+		.await?;
+	let gacha_item_uuid = if let Some(ref row) = item_result {
+		row.try_get("", "id")?
+	} else {
+		let _ = pg_conn
+			.execute(sea_orm::Statement::from_string(
+				db.get_database_backend(),
+				"DELETE FROM app_gacha_items WHERE item_code = 'ITEM_TEST_1'".to_string(),
+			))
+			.await
+			.ok();
+
+		let new_uuid = Uuid::new_v4();
+		let mut item_model: GachaItemActiveModel = Default::default();
+		item_model.id = Set(new_uuid);
+		item_model.item_code = Set("ITEM_TEST_1".to_string());
+		item_model.name = Set("Test Gacha Item".to_string());
+		item_model.description = Set("Test item for gacha".to_string());
+		item_model.rarity = Set("common".to_string());
+		item_model.type_ = Set("item".to_string());
+		item_model.category = Set("test".to_string());
+		item_model.value = Set(1);
+		item_model.weight = Set(1.0);
+		item_model.stock = Set(10);
+		item_model.is_limited = Set(false);
+		item_model.created_at = Set(chrono::Utc::now());
+		item_model.updated_at = Set(chrono::Utc::now());
+		item_model.insert(db).await?;
+		println!("Gacha Item seeded successfully!");
+		new_uuid
+	};
+
+	let gacha_roll_id = Uuid::new_v4();
+	let mut roll_model: GachaRollActiveModel = Default::default();
+	roll_model.id = Set(gacha_roll_id);
+	roll_model.user_id = Set(Uuid::parse_str("c3b1d6a8-8d4f-4b36-b789-2e532ec7a7b2")?);
+	roll_model.gacha_id = Set(Uuid::new_v4().to_string());
+	roll_model.item_id = Set(gacha_item_uuid);
+	roll_model.weight = Set(1.0);
+	roll_model.quantity = Set(10);
+	roll_model.is_deleted = Set(false);
+	roll_model.created_at = Set(Some(chrono::Utc::now().naive_utc()));
+	roll_model.updated_at = Set(Some(chrono::Utc::now().naive_utc()));
+	roll_model.insert(db).await?;
+	println!("Gacha Roll seeded successfully!");
+	let gacha_roll_id = Uuid::new_v4();
+	let mut roll_model: GachaRollActiveModel = Default::default();
+	roll_model.id = Set(gacha_roll_id);
+	roll_model.user_id = Set(Uuid::parse_str("c3b1d6a8-8d4f-4b36-b789-2e532ec7a7b2")?);
+	roll_model.gacha_id = Set(Uuid::new_v4().to_string());
+	roll_model.item_id = Set(gacha_item_uuid);
+	roll_model.weight = Set(1.0);
+	roll_model.quantity = Set(10);
+	roll_model.is_deleted = Set(false);
+	roll_model.created_at = Set(Some(chrono::Utc::now().naive_utc()));
+	roll_model.updated_at = Set(Some(chrono::Utc::now().naive_utc()));
+	roll_model.insert(db).await?;
+	println!("✅ Gacha items and rolls seeded.");
+	Ok(())
+}

imphnen-backend/src/bin/seed_mentor_user.rs

@@ -0,0 +1,90 @@
+#![allow(clippy::all)]
+
+use imphnen_entities::seaorm::auth::mentors::ActiveModel as MentorsActiveModel;
+use imphnen_entities::seaorm::auth::roles::{
+	Column as RoleColumn, Entity as RoleEntity,
+};
+use imphnen_entities::seaorm::auth::users::ActiveModel as UsersActiveModel;
+use imphnen_libs::hash_password;
+use imphnen_libs::postgres::{PostgresConfig, PostgresConnection};
+use sea_orm::{
+	ActiveModelTrait, ActiveValue::Set, ColumnTrait, ConnectionTrait, EntityTrait,
+	QueryFilter,
+};
+use serde_json::json;
+use std::error::Error;
+use uuid::Uuid;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn Error>> {
+	let config = PostgresConfig::from_env()?;
+	let pg_conn = PostgresConnection::new(config).await?;
+	let db = &pg_conn.conn;
+
+	let _ = pg_conn
+		.execute(sea_orm::Statement::from_string(
+			db.get_database_backend(),
+			"DELETE FROM app_mentors WHERE id = 'e6f78d23-83bf-5c2b-bcd4-001345678901'"
+				.to_string(),
+		))
+		.await
+		.ok();
+	let _ = pg_conn
+		.execute(sea_orm::Statement::from_string(
+			db.get_database_backend(),
+			"DELETE FROM app_users WHERE email = 'mentor@example.com'".to_string(),
+		))
+		.await
+		.ok();
+
+	let role = RoleEntity::find()
+		.filter(RoleColumn::Name.eq("Mentor"))
+		.one(db)
+		.await?
+		.ok_or("Role 'Mentor' not found")?;
+
+	let user_id = Uuid::new_v4();
+	let mut user_model: UsersActiveModel = Default::default();
+	user_model.id = Set(user_id);
+	user_model.email = Set("mentor@example.com".to_string());
+	user_model.password_hash = Set(hash_password("password").unwrap());
+	user_model.username = Set("mentor@example.com".to_string());
+	user_model.first_name = Set(Some("Mentor".to_string()));
+	user_model.last_name = Set(Some("User".to_string()));
+	user_model.avatar_url = Set(Some("https://example.com/avatar.jpg".to_string()));
+	user_model.is_active = Set(true);
+	user_model.is_verified = Set(true);
+	user_model.role_id = Set(Some(role.id));
+	user_model.created_at = Set(chrono::Utc::now());
+	user_model.updated_at = Set(chrono::Utc::now());
+	user_model.insert(db).await?;
+
+	let mentor_id = Uuid::new_v4();
+	let mut mentor_model: MentorsActiveModel = Default::default();
+	mentor_model.id = Set(mentor_id);
+	mentor_model.user_id = Set(user_id);
+	mentor_model.industries = Set(Some(json!(["Software", "Education"])));
+	mentor_model.expertise = Set(Some(json!(["Rust", "Microservices"])));
+	mentor_model.languages = Set(Some(json!(["Indonesian", "English"])));
+	mentor_model.current_company = Set(Some("PT Contoh".to_string()));
+	mentor_model.current_role = Set(Some("Senior Backend Engineer".to_string()));
+	mentor_model.years_of_experience = Set(Some(5));
+	mentor_model.topics_of_interest =
+		Set(Some(json!(["Rust Programming", "Backend Development"])));
+	mentor_model.preferred_mentee_level = Set(Some("beginner".to_string()));
+	mentor_model.preferred_mentoring_formats = Set(Some(json!(["online", "offline"])));
+	mentor_model.availability_commitment = Set(Some(
+		"2 jam per minggu untuk mentoring online dan offline".to_string(),
+	));
+	mentor_model.mentoring_rate = Set(Some(100000.0));
+	mentor_model.status = Set(Some("verified".to_string()));
+	mentor_model.is_deleted = Set(false);
+	mentor_model.created_at = Set(chrono::Utc::now());
+	mentor_model.updated_at = Set(chrono::Utc::now());
+	mentor_model.insert(db).await?;
+	println!("Mentor created successfully!");
+
+	println!("✅ Inserted mentor user: mentor@example.com");
+	println!("✅ Mentor user seeded");
+	Ok(())
+}

imphnen-backend/src/bin/seed_permissions.rs

@@ -1,145 +1,79 @@
-use imphnen_utils::{get_iso_date, Env};
-use serde_json::json;
+#![allow(clippy::all)]
+
+use chrono::Utc;
+use imphnen_entities::seaorm::auth::permissions::ActiveModel as PermissionActiveModel;
+use imphnen_entities::seaorm::auth::permissions::Entity as PermissionEntity;
+use imphnen_iam::PermissionsEnum;
+use imphnen_libs::postgres::{PostgresConfig, PostgresConnection};
+use sea_orm::ActiveModelTrait;
+use sea_orm::ActiveValue::Set;
 use std::error::Error;
-use surrealdb::{engine::remote::ws::Ws, opt::auth::Root, Surreal};
+use uuid::Uuid;
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn Error>> {
-	let env = Env::new();
-	let db = Surreal::new::<Ws>(env.surrealdb_url).await?;
-	db.signin(Root {
-		username: &env.surrealdb_username,
-		password: &env.surrealdb_password,
-	})
-	.await?;
-	db.use_ns(env.surrealdb_namespace)
-		.use_db(env.surrealdb_dbname)
-		.await?;
-	let permissions = vec![
-		(
-			"023e2dfe-93c3-4008-94a8-b5dff403f73b",
-			"Create Users",
-			Some("2025-01-29T06:08:23.838311+00"),
-			Some("2025-01-29T06:08:23.838312+00"),
-		),
-		(
-			"0269ed71-0ae0-4c43-ad29-e3d861d8f9a0",
-			"Create Permissions",
-			Some("2025-01-29T05:11:01.265+00"),
-			Some("2025-01-29T05:11:01.265001+00"),
-		),
-		(
-			"299cb4d5-6556-4cc9-b6c1-32e6d31e0f9b",
-			"Update Permissions",
-			Some("2025-01-29T05:11:01.265+00"),
-			Some("2025-01-29T05:11:01.265001+00"),
-		),
-		(
-			"319ee593-ff0a-4f29-bbaf-9feb3174a3a2",
-			"Create Roles",
-			Some("2025-01-29T05:11:01.265+00"),
-			Some("2025-01-29T05:11:01.265001+00"),
-		),
-		(
-			"319ee593-ff0a-4f29-bbaf-9feb3174a3a6",
-			"Read Detail Users",
-			Some("2025-01-29T05:11:01.265+00"),
-			Some("2025-01-29T05:11:01.265001+00"),
-		),
-		(
-			"35b0d992-65c8-4b62-b030-e6e0320e4048",
-			"Delete Roles",
-			Some("2025-01-29T05:34:40.621554+00"),
-			Some("2025-01-29T05:34:40.621555+00"),
-		),
-		(
-			"4da8b434-89f9-4d91-85ae-eebd63cdbeda",
-			"Update Activate Users",
-			Some("2025-02-01T12:38:09.741726+00"),
-			Some("2025-02-01T12:38:09.741727+00"),
-		),
-		(
-			"73888d18-b3e9-4f62-95a5-ba2c0d69fccb",
-			"Read Detail Roles",
-			Some("2025-01-29T05:13:06.445925+00"),
-			Some("2025-01-29T10:31:46.408564+00"),
-		),
-		(
-			"7c15e31d-36e2-49f9-97db-138c03fb0cf6",
-			"Read List Users",
-			Some("2025-01-28T15:02:41.772931+00"),
-			Some("2025-01-28T15:02:41.772933+00"),
-		),
-		(
-			"7d4b1379-4960-416a-b045-98cd82c0cac9",
-			"Read Detail Sessions",
-			Some("2025-02-24T16:52:26.886664+00"),
-			Some("2025-02-24T16:52:26.886673+00"),
-		),
-		(
-			"8195eeb8-e64f-4172-aa57-596492c84a72",
-			"Read List Permissions",
-			Some("2025-01-28T15:05:28.6299+00"),
-			Some("2025-01-28T15:05:28.629901+00"),
-		),
-		(
-			"81eba91d-b8ab-44b9-bbfe-4e6da2f98952",
-			"Read List Tests",
-			Some("2025-02-24T16:52:27.179542+00"),
-			Some("2025-02-24T16:52:27.179551+00"),
-		),
-		(
-			"9164ca6e-c7e3-4238-a15f-f36ab9577e7e",
-			"Read List Roles",
-			Some("2025-01-29T05:34:40.621554+00"),
-			Some("2025-01-29T05:34:40.621555+00"),
-		),
-		(
-			"96df0689-2ae9-4894-bf00-837c19415e5c",
-			"Delete Users",
-			Some("2025-02-02T06:52:05.195565+00"),
-			Some("2025-02-02T06:52:05.195565+00"),
-		),
-		(
-			"98b3dc4c-0124-461f-afcd-166637c5e6e8",
-			"Update Users",
-			Some("2025-01-29T05:34:40.621554+00"),
-			Some("2025-01-29T05:34:40.621555+00"),
-		),
-		(
-			"a00d5608-4c48-4542-845c-dfe004687022",
-			"Update Roles",
-			Some("2025-01-29T05:34:40.621554+00"),
-			Some("2025-01-29T05:34:40.621555+00"),
-		),
-		(
-			"b2dc3928-86ba-4c59-a03d-0b57d5183ebc",
-			"Delete Permissions",
-			Some("2025-01-29T05:14:22.511084+00"),
-			Some("2025-01-29T05:14:22.511085+00"),
-		),
-		(
-			"dad435cf-042c-41bd-a946-cea61ed2ffbc",
-			"Read Detail Permissions",
-			Some("2025-01-28T15:07:10.990214+00"),
-			Some("2025-01-28T15:07:10.990214+00"),
-		),
-	];
-	for (id, name, _created_at, _updated_at) in permissions {
-		db.query("CREATE type::thing('app_permissions', $id) CONTENT $data")
-			.bind(("id", id))
-			.bind((
-				"data",
-				json!({
-						"name": name,
-						"is_deleted": false,
-						"created_at": get_iso_date(),
-						"updated_at": get_iso_date()
-				}),
-			))
-			.await?;
-		println!("✅ Inserted: {}", name);
+	let config = PostgresConfig::from_env()?;
+	let pg_conn = PostgresConnection::new(config).await?;
+	let db = &pg_conn.conn;
+
+	for permission in [
+		PermissionsEnum::ReadListUsers,
+		PermissionsEnum::ReadDetailUsers,
+		PermissionsEnum::CreateUsers,
+		PermissionsEnum::DeleteUsers,
+		PermissionsEnum::UpdateUsers,
+		PermissionsEnum::ActivateUsers,
+		PermissionsEnum::ReadListRoles,
+		PermissionsEnum::ReadDetailRoles,
+		PermissionsEnum::CreateRoles,
+		PermissionsEnum::DeleteRoles,
+		PermissionsEnum::UpdateRoles,
+		PermissionsEnum::ReadListPermissions,
+		PermissionsEnum::ReadDetailPermissions,
+		PermissionsEnum::CreatePermissions,
+		PermissionsEnum::DeletePermissions,
+		PermissionsEnum::UpdatePermissions,
+		PermissionsEnum::CreateGachaClaims,
+		PermissionsEnum::ReadDetailGachaClaims,
+		PermissionsEnum::ReadListGachaItems,
+		PermissionsEnum::ReadDetailGachaItems,
+		PermissionsEnum::CreateGachaItems,
+		PermissionsEnum::DeleteGachaItems,
+		PermissionsEnum::UpdateGachaItems,
+		PermissionsEnum::ReadDetailGachaRolls,
+		PermissionsEnum::CreateGachaRolls,
+		PermissionsEnum::ExecuteGachaRolls,
+		PermissionsEnum::ReadListMentors,
+		PermissionsEnum::ReadDetailMentors,
+		PermissionsEnum::RegisterMentors,
+		PermissionsEnum::ReadOwnMentorProfile,
+		PermissionsEnum::UpdateOwnMentorProfile,
+		PermissionsEnum::ReadOwnMentorStatus,
+		PermissionsEnum::UpdateMentors,
+		PermissionsEnum::VerifyMentors,
+		PermissionsEnum::DeleteMentors,
+		PermissionsEnum::Administrator,
+	] {
+		let parsed_id =
+			Uuid::parse_str(&permission.id()).unwrap_or_else(|_| Uuid::new_v4());
+
+		let existing = PermissionEntity::find_by_id(parsed_id).one(db).await?;
+		if existing.is_some() {
+			println!("ℹ️  Skipping (already exists): {permission}");
+			continue;
+		}
+
+		let mut perm_model: PermissionActiveModel = Default::default();
+		perm_model.id = Set(parsed_id);
+		perm_model.name = Set(permission.to_string());
+		perm_model.is_deleted = Set(false);
+		perm_model.created_at = Set(Utc::now());
+		perm_model.updated_at = Set(Utc::now());
+		perm_model.insert(db).await?;
+		println!("✅ Inserted: {permission}");
 	}
+
 	println!("✅ All Permissions seeded");
+
 	Ok(())
 }

imphnen-backend/src/bin/seed_roles.rs

@@ -1,20 +1,15 @@
-use imphnen_utils::{get_iso_date, Env};
-use serde_json::json;
+use chrono::Utc;
+use imphnen_entities::seaorm::auth::roles::{Entity as RoleEntity, RoleBuilder};
+use imphnen_libs::postgres::{PostgresConfig, PostgresConnection};
+use sea_orm::{ActiveModelTrait, ActiveValue::Set, EntityTrait};
 use std::error::Error;
-use surrealdb::{engine::remote::ws::Ws, opt::auth::Root, Surreal};
+use uuid::Uuid;
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn Error>> {
-	let env = Env::new();
-	let db = Surreal::new::<Ws>(env.surrealdb_url).await?;
-	db.signin(Root {
-		username: &env.surrealdb_username,
-		password: &env.surrealdb_password,
-	})
-	.await?;
-	db.use_ns(env.surrealdb_namespace)
-		.use_db(env.surrealdb_dbname)
-		.await?;
+	let config = PostgresConfig::from_env()?;
+	let pg_conn = PostgresConnection::new(config).await?;
+	let db = &pg_conn.conn;
 
 	let roles = vec![
 		(
@@ -26,7 +21,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
 		(
 			"5713cb37-dc02-4e87-8048-d7a41d352059",
 			"User",
-			None,
+			Some("2025-02-28T14:53:58.576688+00"),
 			Some("2025-02-28T14:53:58.576688+00"),
 		),
 		(
@@ -44,26 +39,40 @@ async fn main() -> Result<(), Box<dyn Error>> {
 		(
 			"f6b03f25-e416-4893-ac88-caaa690afb07",
 			"Admin",
-			None,
 			Some("2025-02-22T15:38:39.868306+00"),
+			Some("2025-02-22T15:38:39.868306+00"),
+		),
+		(
+			"3b9f8c4e-6a2d-4f8a-9a12-2d6f8b3c4e5a",
+			"Mentor",
+			Some("2025-07-06T10:00:00.000000+00"),
+			Some("2025-07-06T10:00:00.000000+00"),
 		),
 	];
 
-	for (id, name, _created_at, _updated_at) in roles {
-		db.query("CREATE type::thing('app_roles', $id) CONTENT $data")
-			.bind(("id", id))
-			.bind((
-				"data",
-				json!({
-						"name": name,
-						"permissions": [],
-						"is_deleted": false,
-						"created_at": get_iso_date(),
-						"updated_at": get_iso_date(),
-				}),
-			))
-			.await?;
-		println!("✅ Inserted role: {}", name);
+	for (id, name, _created_at_str, _updated_at_str) in roles {
+		let uuid = Uuid::parse_str(id).unwrap_or_else(|_| Uuid::new_v4());
+
+		let existing = RoleEntity::find_by_id(uuid).one(db).await?;
+		if existing.is_some() {
+			println!("ℹ️  Skipping (already exists): {name}");
+			continue;
+		}
+
+		let role_model = RoleBuilder::new()
+			.name(name.to_string())
+			.description("System generated role".to_string())
+			.permissions(vec![])
+			.is_default(false)
+			.build()?;
+		let mut role_model = role_model;
+		role_model.id = Set(uuid);
+		role_model.is_system_role = Set(true);
+		role_model.created_at = Set(Utc::now());
+		role_model.updated_at = Set(Utc::now());
+
+		role_model.insert(db).await?;
+		println!("✅ Inserted role: {name}");
 	}
 	println!("✅ All Roles seeded");
 	Ok(())

imphnen-backend/src/bin/seed_roles_permissions.rs

@@ -1,57 +1,109 @@
-use imphnen_iam::{get_iso_date, make_thing, Env};
+use imphnen_entities::seaorm::auth::roles::ActiveModel as RoleActiveModel;
+use imphnen_entities::seaorm::auth::roles::Entity as RolesEntity;
+use imphnen_iam::PermissionsEnum;
+use imphnen_libs::postgres::{PostgresConfig, PostgresConnection};
+use sea_orm::ActiveModelTrait;
+use sea_orm::ActiveValue::Set;
+use sea_orm::EntityTrait;
+use serde_json::Value as JsonValue;
 use std::error::Error;
-use surrealdb::{engine::remote::ws::Ws, opt::auth::Root, Surreal};
+use uuid::Uuid;
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn Error>> {
-	let env = Env::new();
-	let db = Surreal::new::<Ws>(env.surrealdb_url).await?;
+	let config = PostgresConfig::from_env()?;
+	let pg_conn = PostgresConnection::new(config).await?;
+	let db = &pg_conn.conn;
+	println!(
+		"✅ Index 'user_email_index' defined on table 'users' for column 'email'."
+	);
 
-	db.signin(Root {
-		username: &env.surrealdb_username,
-		password: &env.surrealdb_password,
-	})
-	.await?;
-
-	db.use_ns(env.surrealdb_namespace)
-		.use_db(env.surrealdb_dbname)
-		.await?;
-
-	let admin_permissions = vec![
-		"023e2dfe-93c3-4008-94a8-b5dff403f73b",
-		"0269ed71-0ae0-4c43-ad29-e3d861d8f9a0",
-		"299cb4d5-6556-4cc9-b6c1-32e6d31e0f9b",
-		"319ee593-ff0a-4f29-bbaf-9feb3174a3a2",
-		"319ee593-ff0a-4f29-bbaf-9feb3174a3a6",
-		"35b0d992-65c8-4b62-b030-e6e0320e4048",
-		"4da8b434-89f9-4d91-85ae-eebd63cdbeda",
-		"73888d18-b3e9-4f62-95a5-ba2c0d69fccb",
-		"7c15e31d-36e2-49f9-97db-138c03fb0cf6",
-		"7d4b1379-4960-416a-b045-98cd82c0cac9",
-		"8195eeb8-e64f-4172-aa57-596492c84a72",
-		"81eba91d-b8ab-44b9-bbfe-4e6da2f98952",
-		"9164ca6e-c7e3-4238-a15f-f36ab9577e7e",
-		"96df0689-2ae9-4894-bf00-837c19415e5c",
-		"98b3dc4c-0124-461f-afcd-166637c5e6e8",
-		"a00d5608-4c48-4542-845c-dfe004687022",
-		"b2dc3928-86ba-4c59-a03d-0b57d5183ebc",
-		"dad435cf-042c-41bd-a946-cea61ed2ffbc",
+	let roles_permissions = vec![
+		(
+			"f6b03f25-e416-4893-ac88-caaa690afb07",
+			vec![PermissionsEnum::Administrator],
+		),
+		(
+			"3b9f8c4e-6a2d-4f8a-9a12-2d6f8b3c4e5a",
+			vec![
+				PermissionsEnum::ReadListUsers,
+				PermissionsEnum::ReadOwnMentorProfile,
+				PermissionsEnum::UpdateOwnMentorProfile,
+				PermissionsEnum::ReadOwnMentorStatus,
+				PermissionsEnum::ReadListMentors,
+				PermissionsEnum::ReadDetailMentors,
+				PermissionsEnum::ReadListGachaItems,
+				PermissionsEnum::ReadDetailGachaItems,
+				PermissionsEnum::ReadDetailGachaRolls,
+				PermissionsEnum::CreateGachaRolls,
+				PermissionsEnum::ExecuteGachaRolls,
+			],
+		),
+		(
+			"5713cb37-dc02-4e87-8048-d7a41d352059",
+			vec![
+				PermissionsEnum::ReadListGachaItems,
+				PermissionsEnum::ReadDetailGachaItems,
+				PermissionsEnum::ReadListUsers,
+				PermissionsEnum::ReadDetailUsers,
+				PermissionsEnum::CreateGachaClaims,
+				PermissionsEnum::ReadDetailGachaClaims,
+				PermissionsEnum::ReadDetailGachaRolls,
+				PermissionsEnum::CreateGachaRolls,
+				PermissionsEnum::ExecuteGachaRolls,
+				PermissionsEnum::RegisterMentors,
+				PermissionsEnum::ReadListMentors,
+				PermissionsEnum::ReadDetailMentors,
+				PermissionsEnum::ReadOwnMentorProfile,
+				PermissionsEnum::ReadOwnMentorStatus,
+			],
+		),
+		(
+			"50133429-f4b1-4249-9f97-7b86e6ee9d86",
+			vec![
+				PermissionsEnum::ReadListRoles,
+				PermissionsEnum::ReadListPermissions,
+				PermissionsEnum::ReadListUsers,
+				PermissionsEnum::ReadListMentors,
+				PermissionsEnum::ReadDetailUsers,
+				PermissionsEnum::ActivateUsers,
+				PermissionsEnum::ReadDetailRoles,
+				PermissionsEnum::ReadDetailPermissions,
+				PermissionsEnum::ReadListGachaItems,
+				PermissionsEnum::ReadDetailGachaItems,
+				PermissionsEnum::ReadListMentors,
+				PermissionsEnum::ReadDetailMentors,
+				PermissionsEnum::ReadDetailGachaRolls,
+				PermissionsEnum::CreateGachaRolls,
+				PermissionsEnum::ExecuteGachaRolls,
+			],
+		),
+		(
+			"60f1aeb7-dad2-4e06-bcb5-be1ba510c906",
+			vec![PermissionsEnum::ActivateUsers],
+		),
+		("6d4fea5d-4a08-4b8a-9782-f2ab2183dcf0", vec![]),
 	];
 
-	let admin_role_id = "f6b03f25-e416-4893-ac88-caaa690afb07";
+	for (role_id, permissions) in roles_permissions {
+		let role_uuid = Uuid::parse_str(role_id).unwrap_or_else(|_| Uuid::new_v4());
+		let json_permissions = JsonValue::Array(
+			permissions
+				.iter()
+				.map(|p| JsonValue::String(p.id()))
+				.collect(),
+		);
 
-	let permission_refs_admin: Vec<_> = admin_permissions
-		.into_iter()
-		.map(|perm_id| make_thing("app_permissions", perm_id))
-		.collect();
-
-	db.query("UPDATE type::thing('app_roles', $role_id) SET permissions = $permissions, updated_at = $updated_at WHERE is_deleted = false")
-		.bind(("role_id", admin_role_id))
-		.bind(("permissions", permission_refs_admin))
-		.bind(("updated_at", get_iso_date()))
-		.await?;
-
-	println!("✅ All permissions successfully added to each role");
+		if let Some(role_model) = RolesEntity::find_by_id(role_uuid).one(db).await? {
+			let mut am: RoleActiveModel = role_model.into();
+			am.permissions = Set(Some(json_permissions));
+			am.update(db).await?;
+			println!("✅ Permissions updated for role: {role_id}");
+		} else {
+			println!("⚠️ Role with id {role_id} not found, skipping permissions update");
+		}
+	}
 
+	println!("✅ All roles permissions updated!");
 	Ok(())
 }

imphnen-backend/src/bin/seed_test_data.rs

@@ -0,0 +1,79 @@
+#![allow(clippy::all)]
+
+use chrono::Utc;
+use imphnen_entities::seaorm::auth::mentors::ActiveModel as MentorsActiveModel;
+use imphnen_entities::seaorm::common::events::ActiveModel as EventsActiveModel;
+use imphnen_entities::seaorm::common::testimonials::ActiveModel as TestimonialsActiveModel;
+use imphnen_libs::postgres::{PostgresConfig, PostgresConnection};
+use sea_orm::ActiveModelTrait;
+use sea_orm::ActiveValue::Set;
+use serde_json::json;
+use std::error::Error;
+use uuid::Uuid;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn Error>> {
+	let config = PostgresConfig::from_env()?;
+	let pg_conn = PostgresConnection::new(config).await?;
+	let db = &pg_conn.conn;
+
+	let uuid = Uuid::new_v4().to_string();
+	let mut event_model: EventsActiveModel = Default::default();
+	event_model.id = Set(Uuid::parse_str(&uuid)?);
+	event_model.name = Set("Test Event".to_string());
+	event_model.description = Set("Test event description".to_string());
+	event_model.detail_link = Set("https://example.com/event".to_string());
+	event_model.price = Set(50.0);
+	event_model.is_online = Set(true);
+	event_model.start_date = Set(Utc::now());
+	event_model.end_date = Set(Utc::now() + chrono::Duration::days(1));
+	event_model.location = Set(None);
+	event_model.is_deleted = Set(false);
+	match event_model.insert(db).await {
+		Ok(_) => println!("✅ Inserted test event"),
+		Err(_) => {
+			println!("⚠️  Test event already exists or could not be inserted, skipping")
+		}
+	};
+
+	let mut testimonial_model: TestimonialsActiveModel = Default::default();
+	testimonial_model.id =
+		Set(Uuid::parse_str("00000000-0000-0000-0000-000000000001")?);
+	testimonial_model.user_id =
+		Set(Uuid::parse_str("c3b1d6a8-8d4f-4b36-b789-2e532ec7a7b2")?);
+	testimonial_model.role = Set("Student".to_string());
+	testimonial_model.content = Set("This is a great platform!".to_string());
+	testimonial_model.is_deleted = Set(false);
+	match testimonial_model.insert(db).await {
+		Ok(_) => println!("✅ Inserted test testimonial"),
+		Err(_) => println!(
+			"⚠️  Test testimonial already exists or could not be inserted, skipping"
+		),
+	};
+
+	let mentor_id = Uuid::new_v4();
+	let mut mentor_model: MentorsActiveModel = Default::default();
+	mentor_model.id = Set(mentor_id);
+	mentor_model.user_id =
+		Set(Uuid::parse_str("c3b1d6a8-8d4f-4b36-b789-2e532ec7a7b2")?);
+	mentor_model.industries = Set(Some(json!(["Technology", "Education"])));
+	mentor_model.expertise = Set(Some(json!(["Software Development"])));
+	mentor_model.languages = Set(Some(json!(["English", "Indonesian"])));
+	mentor_model.current_company = Set(Some("Tech Corp".to_string()));
+	mentor_model.current_role = Set(Some("Senior Engineer".to_string()));
+	mentor_model.years_of_experience = Set(Some(5));
+	mentor_model.topics_of_interest = Set(Some(json!(["Rust", "Web Development"])));
+	mentor_model.preferred_mentee_level = Set(Some("Beginner".to_string()));
+	mentor_model.preferred_mentoring_formats = Set(Some(json!(["1:1", "Group"])));
+	mentor_model.availability_commitment = Set(Some("Weekly".to_string()));
+	mentor_model.mentoring_rate = Set(Some(100.0));
+	mentor_model.status = Set(Some("active".to_string()));
+	mentor_model.is_deleted = Set(false);
+	mentor_model.created_at = Set(chrono::Utc::now());
+	mentor_model.updated_at = Set(chrono::Utc::now());
+	mentor_model.insert(db).await?;
+	println!("✅ Inserted test mentor via SeaORM");
+
+	println!("✅ All test data seeded successfully");
+	Ok(())
+}

imphnen-backend/src/bin/seed_users.rs

@@ -1,20 +1,20 @@
-use imphnen_iam::UsersSchema;
-use imphnen_utils::{get_iso_date, hash_password, Env};
+#![allow(clippy::all)]
+
+use imphnen_entities::seaorm::auth::users::ActiveModel as UsersActiveModel;
+use imphnen_entities::seaorm::auth::users::Entity as UserEntity;
+use imphnen_libs::hash_password;
+use imphnen_libs::postgres::{PostgresConfig, PostgresConnection};
+
+use chrono::Utc;
+use sea_orm::{ActiveModelTrait, ActiveValue::Set, EntityTrait, IntoActiveModel};
 use std::error::Error;
-use surrealdb::{engine::remote::ws::Ws, opt::auth::Root, sql::Thing, Surreal};
+use uuid::Uuid;
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn Error>> {
-	let env = Env::new();
-	let db = Surreal::new::<Ws>(env.surrealdb_url).await?;
-	db.signin(Root {
-		username: &env.surrealdb_username,
-		password: &env.surrealdb_password,
-	})
-	.await?;
-	db.use_ns(env.surrealdb_namespace)
-		.use_db(env.surrealdb_dbname)
-		.await?;
+	let postgres_config = PostgresConfig::from_env()?;
+	let pg_conn = PostgresConnection::new(postgres_config).await?;
+	let db = &pg_conn.conn;
 
 	let users = vec![
 		(
@@ -35,32 +35,130 @@ async fn main() -> Result<(), Box<dyn Error>> {
 			"User",
 			"5713cb37-dc02-4e87-8048-d7a41d352059",
 		),
+		(
+			"665a3cfc-ea5f-4bcd-8769-4a6d8d1451d4",
+			"testuser1@example.com",
+			"Test User 1",
+			"5713cb37-dc02-4e87-8048-d7a41d352059",
+		),
+		(
+			"3972c139-a450-416c-93b0-c42539dc780f",
+			"testuser2@example.com",
+			"Test User 2",
+			"5713cb37-dc02-4e87-8048-d7a41d352059",
+		),
+		(
+			"b426c0a9-0efb-4e26-b078-4f18767255f3",
+			"testuser3@example.com",
+			"Test User 3",
+			"5713cb37-dc02-4e87-8048-d7a41d352059",
+		),
+		(
+			"11111111-1111-1111-1111-111111111111",
+			"user4@example.com",
+			"User Four",
+			"5713cb37-dc02-4e87-8048-d7a41d352059",
+		),
+		(
+			"22222222-2222-2222-2222-222222222222",
+			"user5@example.com",
+			"User Five",
+			"5713cb37-dc02-4e87-8048-d7a41d352059",
+		),
+		(
+			"33333333-3333-3333-3333-333333333333",
+			"mentor2@example.com",
+			"Mentor Two",
+			"3b9f8c4e-6a2d-4f8a-9a12-2d6f8b3c4e5a",
+		),
+		(
+			"44444444-4444-4444-4444-444444444444",
+			"staff2@example.com",
+			"Staff Two",
+			"50133429-f4b1-4249-9f97-7b86e6ee9d86",
+		),
+		(
+			"55555555-5555-5555-5555-555555555555",
+			"user6@example.com",
+			"User Six",
+			"5713cb37-dc02-4e87-8048-d7a41d352059",
+		),
+		(
+			"66666666-6666-6666-6666-666666666666",
+			"user7@example.com",
+			"User Seven",
+			"5713cb37-dc02-4e87-8048-d7a41d352059",
+		),
+		(
+			"77777777-7777-7777-7777-777777777777",
+			"user8@example.com",
+			"User Eight",
+			"5713cb37-dc02-4e87-8048-d7a41d352059",
+		),
+		(
+			"88888888-8888-8888-8888-888888888888",
+			"user9@example.com",
+			"User Nine",
+			"5713cb37-dc02-4e87-8048-d7a41d352059",
+		),
+		(
+			"99999999-9999-9999-9999-999999999999",
+			"user10@example.com",
+			"User Ten",
+			"5713cb37-dc02-4e87-8048-d7a41d352059",
+		),
 	];
 
-	for (id, email, fullname, role_id) in users {
-		let user = UsersSchema {
-			id: Thing::from(("app_users", id)),
-			fullname: fullname.into(),
-			email: email.into(),
-			password: hash_password("password").unwrap(),
-			avatar: None,
-			phone_number: "081234567890".into(),
-			is_active: true,
-			is_deleted: false,
-			gender: None,
-			birthdate: None,
-			role: Thing::from(("app_roles", role_id)),
-			created_at: get_iso_date(),
-			updated_at: get_iso_date(),
+	for (id, email, fullname, role_id_str) in users {
+		let role_uuid = Some(
+			Uuid::parse_str(role_id_str)
+				.map_err(|e| format!("Invalid UUID for role: {role_id_str} - {e}"))?,
+		);
+
+		let uid = Uuid::parse_str(id)?;
+
+		let names: Vec<&str> = fullname.split_whitespace().collect();
+		let first_name = names.first().map(|s| s.to_string());
+		let last_name = if names.len() > 1 {
+			Some(names[1..].join(" "))
+		} else {
+			None
 		};
 
-		db.create::<Option<UsersSchema>>(("app_users", id))
-			.content(user)
-			.await?;
+		let password = "password";
+		let hashed = hash_password(password).unwrap();
 
-		println!("✅ Inserted user: {} ({})", fullname, email);
+		let existing_user = UserEntity::find_by_id(uid).one(db).await?;
+		let is_update = existing_user.is_some();
+
+		let mut user_model: UsersActiveModel = if let Some(existing) = existing_user {
+			println!("🔄 Updating user: {fullname} ({email})");
+			existing.into_active_model()
+		} else {
+			println!("✅ Inserting user: {fullname} ({email})");
+			let mut active: UsersActiveModel = Default::default();
+			active.id = Set(uid);
+			active.created_at = Set(Utc::now());
+			active
+		};
+
+		user_model.email = Set(email.to_string());
+		user_model.password_hash = Set(hashed);
+		user_model.username = Set(email.to_string());
+		user_model.first_name = Set(first_name);
+		user_model.last_name = Set(last_name);
+		user_model.avatar_url = Set(Some("https://example.com/avatar.jpg".to_string()));
+		user_model.is_verified = Set(true);
+		user_model.is_active = Set(true);
+		user_model.role_id = Set(role_uuid);
+		user_model.updated_at = Set(Utc::now());
+
+		if is_update {
+			user_model.update(db).await?;
+		} else {
+			user_model.insert(db).await?;
+		}
 	}
-
 	println!("✅ All Users seeded");
 	Ok(())
 }

imphnen-backend/src/bin/seeder.rs

@@ -0,0 +1,33 @@
+#![allow(clippy::all)]
+
+use std::error::Error;
+use std::process::Command;
+
+fn run_seed(bin: &str) -> Result<(), Box<dyn Error>> {
+	println!("🔧 Seeding: {bin}");
+	#[cfg(target_os = "windows")]
+	let status = Command::new(format!("./target/release/{}.exe", bin)).status()?;
+	#[cfg(not(target_os = "windows"))]
+	let status = Command::new(format!("./target/release/{}", bin)).status()?;
+
+	if !status.success() {
+		Err(format!("❌ Failed to run seed: {bin}").into())
+	} else {
+		Ok(())
+	}
+}
+
+fn main() -> Result<(), Box<dyn Error>> {
+	println!("🚀 Running all seeders...\n");
+
+	run_seed("seed_permissions")?;
+	run_seed("seed_roles")?;
+	run_seed("seed_roles_permissions")?;
+	run_seed("seed_users")?;
+	run_seed("seed_events")?;
+	run_seed("seed_gacha_rolls")?;
+	run_seed("seed_mentor_user")?;
+	run_seed("seed_test_data")?;
+	println!("\n✅ All seeding completed successfully.");
+	Ok(())
+}

imphnen-backend/src/bin/test_postgres.rs

@@ -0,0 +1,395 @@
+use chrono::Utc;
+use imphnen_entities::seaorm::auth::roles::{
+	Entity as RolesEntity, Model as RoleModel,
+};
+use imphnen_entities::seaorm::auth::users::{
+	Entity as UsersEntity, Model as UserModel,
+};
+use imphnen_libs::postgres::{PostgresConfig, PostgresConnection, PostgresError};
+use sea_orm::{
+	ActiveModelTrait, DbErr, EntityTrait, PaginatorTrait, Set, TransactionTrait,
+};
+use std::sync::Arc;
+use uuid::Uuid;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+	println!("🚀 Starting PostgreSQL Connection Test");
+	println!("=====================================");
+
+	let config = PostgresConfig::from_env()?;
+	println!("✅ Configuration loaded successfully");
+	println!(
+		"   Database URL: {}",
+		config
+			.database_url
+			.replace("postgres://", "postgres://****:****@")
+	);
+	println!("   Pool size: {}", config.pool_size);
+	println!("   Connect timeout: {}s", config.connect_timeout);
+	println!("   Retry attempts: {}", config.retry_attempts);
+
+	println!("\n🔌 Testing PostgreSQL connection...");
+	match test_connection(config).await {
+		Ok(()) => {
+			println!("✅ All PostgreSQL tests passed successfully!");
+			Ok(())
+		}
+		Err(e) => {
+			println!("❌ PostgreSQL test failed: {}", e);
+			Err(e.into())
+		}
+	}
+}
+
+async fn test_connection(config: PostgresConfig) -> Result<(), PostgresError> {
+	println!("   Creating PostgreSQL connection...");
+	let postgres_conn = PostgresConnection::new(config).await?;
+	let connection = Arc::new(postgres_conn);
+	println!("   ✅ Connection established successfully");
+
+	println!("   Testing basic connectivity...");
+	test_basic_connectivity(&connection).await?;
+	println!("   ✅ Basic connectivity test passed");
+
+	println!("   Testing table existence...");
+	test_table_existence(&connection).await?;
+	println!("   ✅ Table existence test passed");
+
+	println!("   Testing CRUD operations...");
+	test_crud_operations(&connection).await?;
+	println!("   ✅ CRUD operations test passed");
+
+	println!("   Testing transaction support...");
+	test_transactions(&connection).await?;
+	println!("   ✅ Transaction support test passed");
+
+	println!("   Testing error handling...");
+	test_error_handling(&connection).await?;
+	println!("   ✅ Error handling test passed");
+
+	Ok(())
+}
+
+async fn test_basic_connectivity(
+	connection: &Arc<PostgresConnection>,
+) -> Result<(), PostgresError> {
+	let statement = sea_orm::Statement::from_string(
+		connection.get_database_backend(),
+		"SELECT 1 as test_value, current_timestamp as current_time".to_string(),
+	);
+
+	let result = connection.query_one(statement).await?.ok_or_else(|| {
+		PostgresError::ConnectionError(sea_orm::DbErr::Custom(
+			"No results returned".to_string(),
+		))
+	})?;
+
+	let test_value: Option<i32> = result.try_get("", "test_value").ok();
+	let current_time: Option<String> = result.try_get("", "current_time").ok();
+
+	if test_value != Some(1) {
+		return Err(PostgresError::ConnectionError(sea_orm::DbErr::Custom(
+			format!("Expected test_value=1, got {:?}", test_value),
+		)));
+	}
+
+	if current_time.is_none() {
+		return Err(PostgresError::ConnectionError(sea_orm::DbErr::Custom(
+			"Expected current_time to be set".to_string(),
+		)));
+	}
+
+	println!(
+		"      📝 Query result: test_value={:?}, current_time={:?}",
+		test_value, current_time
+	);
+	Ok(())
+}
+
+async fn test_table_existence(
+	connection: &Arc<PostgresConnection>,
+) -> Result<(), PostgresError> {
+	use sea_orm::EntityTrait;
+
+	println!("      📋 Checking users table...");
+	let user_count = UsersEntity::find()
+		.count(&connection.conn)
+		.await
+		.map_err(PostgresError::ConnectionError)?;
+	println!(
+		"      📊 Users table accessible, current count: {}",
+		user_count
+	);
+
+	println!("      📋 Checking roles table...");
+	let role_count = RolesEntity::find()
+		.count(&connection.conn)
+		.await
+		.map_err(PostgresError::ConnectionError)?;
+	println!(
+		"      📊 Roles table accessible, current count: {}",
+		role_count
+	);
+
+	Ok(())
+}
+
+async fn test_crud_operations(
+	connection: &Arc<PostgresConnection>,
+) -> Result<(), PostgresError> {
+	use sea_orm::{ActiveModelTrait, Set};
+
+	println!("      ➕ Creating test user...");
+	let test_user_id = Uuid::new_v4();
+	let now = Utc::now();
+
+	let user_model = imphnen_entities::seaorm::auth::users::ActiveModel {
+		id: Set(test_user_id),
+		email: Set(format!("test_user_{}@example.com", test_user_id)),
+		password_hash: Set("test_password_hash".to_string()),
+		username: Set(format!("testuser_{}", test_user_id)),
+		first_name: Set(Some("Test".to_string())),
+		last_name: Set(Some("User".to_string())),
+		avatar_url: Set(None),
+		is_verified: Set(false),
+		is_active: Set(true),
+		metadata: Set(None),
+		role_id: Set(None),
+		created_at: Set(now),
+		updated_at: Set(now),
+		deleted_at: Set(None),
+	};
+
+	let created_user = user_model
+		.insert(&connection.conn)
+		.await
+		.map_err(PostgresError::ConnectionError)?;
+
+	println!("      ✅ Created user with ID: {}", created_user.id);
+
+	println!("      🔍 Reading test user...");
+	let found_user = UsersEntity::find_by_id(test_user_id)
+		.one(&connection.conn)
+		.await
+		.map_err(PostgresError::ConnectionError)?
+		.ok_or_else(|| {
+			PostgresError::ConnectionError(sea_orm::DbErr::Custom(
+				"User not found after creation".to_string(),
+			))
+		})?;
+
+	println!(
+		"      ✅ Found user: {} ({})",
+		found_user.username, found_user.email
+	);
+
+	println!("      ✏️  Updating test user...");
+	let mut update_model: imphnen_entities::seaorm::auth::users::ActiveModel =
+		found_user.into();
+	update_model.first_name = Set(Some("Updated".to_string()));
+	update_model.updated_at = Set(Utc::now());
+
+	let updated_user = update_model
+		.update(&connection.conn)
+		.await
+		.map_err(PostgresError::ConnectionError)?;
+
+	println!(
+		"      ✅ Updated user first name to: {:?}",
+		updated_user.first_name
+	);
+
+	println!("      🗑️  Deleting test user...");
+	UsersEntity::delete_by_id(updated_user.id)
+		.exec(&connection.conn)
+		.await
+		.map_err(PostgresError::ConnectionError)?;
+
+	println!("      ✅ Test user deleted successfully");
+
+	Ok(())
+}
+
+async fn test_transactions(
+	connection: &Arc<PostgresConnection>,
+) -> Result<(), PostgresError> {
+	println!("      💰 Testing transaction support...");
+
+	let transaction_result = connection
+		.conn
+		.transaction(|txn| {
+			Box::pin(async move {
+				let test_user_id = Uuid::new_v4();
+				let now = Utc::now();
+
+				let user_model = imphnen_entities::seaorm::auth::users::ActiveModel {
+					id: Set(test_user_id),
+					email: Set(format!("transaction_test_{}@example.com", test_user_id)),
+					password_hash: Set("transaction_password_hash".to_string()),
+					username: Set(format!("transaction_user_{}", test_user_id)),
+					first_name: Set(Some("Transaction".to_string())),
+					last_name: Set(Some("Test".to_string())),
+					avatar_url: Set(None),
+					is_verified: Set(false),
+					is_active: Set(true),
+					metadata: Set(None),
+					role_id: Set(None),
+					created_at: Set(now),
+					updated_at: Set(now),
+					deleted_at: Set(None),
+				};
+
+				let _created_user = user_model.insert(txn).await?;
+
+				Err::<(), DbErr>(DbErr::Custom("Simulated transaction failure".to_string()))
+			})
+		})
+		.await;
+
+	match transaction_result {
+		Err(e) => {
+			let e_text = format!("{:?}", e);
+			if e_text.contains("Simulated transaction failure") {
+				println!("      ✅ Transaction failed as expected, rollback successful");
+			} else {
+				return Err(PostgresError::OperationFailed(format!(
+					"Unexpected transaction result: {}",
+					e_text
+				)));
+			}
+		}
+		Ok(_) => {
+			return Err(PostgresError::OperationFailed(
+				"Unexpected transaction result: transaction unexpectedly succeeded"
+					.to_string(),
+			));
+		}
+	}
+
+	let user_exists = UsersEntity::find_by_id(Uuid::nil())
+		.one(&connection.conn)
+		.await
+		.map_err(PostgresError::ConnectionError)?
+		.is_some();
+
+	if user_exists {
+		println!("      ⚠️  User found despite rollback - this might indicate an issue");
+	} else {
+		println!("      ✅ Transaction rollback verified - user not found");
+	}
+
+	Ok(())
+}
+
+async fn test_error_handling(
+	connection: &Arc<PostgresConnection>,
+) -> Result<(), PostgresError> {
+	println!("      ⚠️  Testing error handling...");
+
+	println!("      🔍 Testing invalid UUID handling...");
+	let invalid_uuid = Uuid::nil();
+
+	match UsersEntity::find_by_id(invalid_uuid)
+		.one(&connection.conn)
+		.await
+		.map_err(PostgresError::ConnectionError)?
+	{
+		Some(_) => {
+			println!("      ✅ Found user with nil UUID (expected in some cases)")
+		}
+		None => println!("      ✅ No user found with nil UUID (expected)"),
+	}
+
+	println!("      🔍 Testing invalid query handling...");
+	let invalid_statement = sea_orm::Statement::from_string(
+		connection.get_database_backend(),
+		"SELECT * FROM non_existent_table".to_string(),
+	);
+
+	match connection.execute(invalid_statement).await {
+		Err(_) => println!("      ✅ Invalid query properly handled with error"),
+		Ok(_) => println!("      ⚠️  Invalid query unexpectedly succeeded"),
+	}
+
+	Ok(())
+}
+
+pub mod test_utils {
+	use super::*;
+
+	pub fn create_test_config() -> PostgresConfig {
+		PostgresConfig {
+			database_url: "postgres://postgres:postgres@localhost:5432/imphnen_test"
+				.to_string(),
+			pool_size: 5,
+			connect_timeout: 10,
+			idle_timeout: 30,
+			max_lifetime: Some(600),
+			retry_attempts: 2,
+			retry_delay: 1,
+		}
+	}
+
+	pub fn create_test_user_model() -> UserModel {
+		UserModel {
+			id: Uuid::new_v4(),
+			email: format!("test_{}@example.com", Uuid::new_v4()),
+			password_hash: "test_password_hash".to_string(),
+			username: format!("testuser_{}", Uuid::new_v4()),
+			first_name: Some("Test".to_string()),
+			last_name: Some("User".to_string()),
+			avatar_url: None,
+			is_verified: false,
+			is_active: true,
+			metadata: None,
+			role_id: None,
+			created_at: Utc::now(),
+			updated_at: Utc::now(),
+			deleted_at: None,
+		}
+	}
+
+	pub fn create_test_role_model() -> RoleModel {
+		RoleModel {
+			id: Uuid::new_v4(),
+			name: format!("test_role_{}", Uuid::new_v4()),
+			description: "Test role description".to_string(),
+			permissions: Some(serde_json::json!(["test.permission"])),
+			is_system_role: false,
+			is_default: false,
+			created_at: Utc::now(),
+			updated_at: Utc::now(),
+			deleted_at: None,
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn test_create_test_config() {
+		let config = test_utils::create_test_config();
+		assert_eq!(config.pool_size, 5);
+		assert_eq!(config.connect_timeout, 10);
+		assert!(config.database_url.contains("imphnen_test"));
+	}
+
+	#[test]
+	fn test_create_test_user_model() {
+		let user = test_utils::create_test_user_model();
+		assert!(!user.email.is_empty());
+		assert!(!user.username.is_empty());
+		assert!(user.is_active);
+	}
+
+	#[test]
+	fn test_create_test_role_model() {
+		let role = test_utils::create_test_role_model();
+		assert!(!role.name.is_empty());
+		assert!(role.permissions.is_some());
+		assert!(!role.is_system_role);
+	}
+}

imphnen-backend/src/main.rs

@@ -3,8 +3,8 @@ use imphnen_libs::axum_init;
 
 #[tokio::main]
 async fn main() {
-	axum_init(|surrealdb_ws, surrealdb_mem| async {
-		gateway_service(surrealdb_ws, surrealdb_mem).await
-	})
-	.await;
+	tracing_subscriber::fmt::init();
+
+	let _ =
+		axum_init(|postgres_conn| async { gateway_service(postgres_conn).await }).await;
 }

imphnen-cms/Cargo.toml

@@ -0,0 +1,41 @@
+[package]
+name = "imphnen-cms"
+version = "0.3.0"
+edition = "2024"
+
+[dependencies]
+async-trait.workspace = true
+imphnen-iam.workspace = true
+imphnen-libs.workspace = true
+imphnen-utils.workspace = true
+imphnen-entities.workspace = true
+axum.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+utoipa.workspace = true
+lazy_static.workspace = true
+regex.workspace = true
+zod-rs.workspace = true
+zod-rs-util.workspace = true
+axum-test.workspace = true
+rand.workspace = true
+tokio.workspace = true
+chrono.workspace = true
+anyhow.workspace = true
+tower-http.workspace = true
+utoipa-swagger-ui.workspace = true
+log.workspace = true
+tracing.workspace = true
+sea-orm.workspace = true
+uuid.workspace = true
+
+paginator-rs.workspace = true
+paginator-utils.workspace = true
+paginator-sea-orm.workspace = true
+paginator-axum.workspace = true
+sqlx.workspace = true
+image.workspace = true
+qrcode.workspace = true
+
+[package.metadata.validator.regex]
+VALID_URL_REGEX = "^https?://"

imphnen-cms/src/events/application/event_service.rs

@@ -0,0 +1,43 @@
+use crate::events::domain::{EventEntity, EventRepository, EventService};
+use async_trait::async_trait;
+use imphnen_utils::AppError;
+use paginator_rs::PaginationParams;
+use paginator_utils::PaginatorResponse;
+use std::sync::Arc;
+use uuid::Uuid;
+
+pub struct EventServiceImpl {
+	repo: Arc<dyn EventRepository>,
+}
+
+impl EventServiceImpl {
+	pub fn new(repo: Arc<dyn EventRepository>) -> Self {
+		Self { repo }
+	}
+}
+
+#[async_trait]
+impl EventService for EventServiceImpl {
+	async fn list(
+		&self,
+		params: PaginationParams,
+	) -> Result<PaginatorResponse<EventEntity>, AppError> {
+		self.repo.find_all(params).await
+	}
+
+	async fn get(&self, id: Uuid) -> Result<EventEntity, AppError> {
+		self.repo.find_by_id(id).await
+	}
+
+	async fn create(&self, entity: EventEntity) -> Result<(), AppError> {
+		self.repo.create(entity).await
+	}
+
+	async fn update(&self, entity: EventEntity) -> Result<(), AppError> {
+		self.repo.update(entity).await
+	}
+
+	async fn delete(&self, id: Uuid) -> Result<(), AppError> {
+		self.repo.delete(id).await
+	}
+}

imphnen-cms/src/events/application/mod.rs

@@ -0,0 +1,3 @@
+pub mod event_service;
+
+pub use event_service::EventServiceImpl;

imphnen-cms/src/events/domain/event.rs

@@ -0,0 +1,18 @@
+use chrono::{DateTime, Utc};
+use uuid::Uuid;
+
+#[derive(Clone, Debug)]
+pub struct EventEntity {
+	pub id: Uuid,
+	pub name: String,
+	pub description: String,
+	pub detail_link: String,
+	pub price: f64,
+	pub is_online: bool,
+	pub is_deleted: bool,
+	pub location: Option<String>,
+	pub start_date: DateTime<Utc>,
+	pub end_date: DateTime<Utc>,
+	pub created_at: DateTime<Utc>,
+	pub updated_at: DateTime<Utc>,
+}

imphnen-cms/src/events/domain/mod.rs

@@ -0,0 +1,7 @@
+pub mod event;
+pub mod repository;
+pub mod service;
+
+pub use event::EventEntity;
+pub use repository::EventRepository;
+pub use service::EventService;

imphnen-cms/src/events/domain/repository.rs

@@ -0,0 +1,18 @@
+use super::event::EventEntity;
+use async_trait::async_trait;
+use imphnen_utils::AppError;
+use paginator_rs::PaginationParams;
+use paginator_utils::PaginatorResponse;
+use uuid::Uuid;
+
+#[async_trait]
+pub trait EventRepository: Send + Sync {
+	async fn find_all(
+		&self,
+		params: PaginationParams,
+	) -> Result<PaginatorResponse<EventEntity>, AppError>;
+	async fn find_by_id(&self, id: Uuid) -> Result<EventEntity, AppError>;
+	async fn create(&self, entity: EventEntity) -> Result<(), AppError>;
+	async fn update(&self, entity: EventEntity) -> Result<(), AppError>;
+	async fn delete(&self, id: Uuid) -> Result<(), AppError>;
+}

imphnen-cms/src/events/domain/service.rs

@@ -0,0 +1,18 @@
+use super::event::EventEntity;
+use async_trait::async_trait;
+use imphnen_utils::AppError;
+use paginator_rs::PaginationParams;
+use paginator_utils::PaginatorResponse;
+use uuid::Uuid;
+
+#[async_trait]
+pub trait EventService: Send + Sync {
+	async fn list(
+		&self,
+		params: PaginationParams,
+	) -> Result<PaginatorResponse<EventEntity>, AppError>;
+	async fn get(&self, id: Uuid) -> Result<EventEntity, AppError>;
+	async fn create(&self, entity: EventEntity) -> Result<(), AppError>;
+	async fn update(&self, entity: EventEntity) -> Result<(), AppError>;
+	async fn delete(&self, id: Uuid) -> Result<(), AppError>;
+}

imphnen-cms/src/events/infrastructure/http/dto.rs

@@ -0,0 +1,131 @@
+use crate::events::domain::event::EventEntity;
+use chrono::{DateTime, Utc};
+use imphnen_libs::ZodValidate;
+use serde::{Deserialize, Serialize};
+use utoipa::ToSchema;
+use uuid::Uuid;
+
+#[derive(Clone, Debug, Serialize, Deserialize, ToSchema)]
+pub struct EventsCreateRequestDto {
+	pub name: String,
+	pub description: String,
+	pub detail_link: String,
+	pub price: f64,
+	#[schema(example = "2025-09-20T13:00:00Z", value_type = String)]
+	pub end_date: DateTime<Utc>,
+	#[schema(example = "2025-09-20T13:00:00Z", value_type = String)]
+	pub start_date: DateTime<Utc>,
+	pub location: Option<String>,
+	pub is_online: bool,
+}
+
+impl ZodValidate for EventsCreateRequestDto {
+	fn zod_validate(value: &serde_json::Value) -> Result<Self, String> {
+		serde_json::from_value(value.clone()).map_err(|e| e.to_string())
+	}
+}
+
+impl From<EventsCreateRequestDto> for EventEntity {
+	fn from(dto: EventsCreateRequestDto) -> Self {
+		EventEntity {
+			id: Uuid::new_v4(),
+			name: dto.name,
+			description: dto.description,
+			detail_link: dto.detail_link,
+			price: dto.price,
+			is_online: dto.is_online,
+			is_deleted: false,
+			location: dto.location,
+			start_date: dto.start_date,
+			end_date: dto.end_date,
+			created_at: chrono::Utc::now(),
+			updated_at: chrono::Utc::now(),
+		}
+	}
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, ToSchema)]
+pub struct EventsUpdateRequestDto {
+	pub name: String,
+	#[schema(example = "2025-09-20T13:00:00Z", value_type = String)]
+	pub end_date: DateTime<Utc>,
+	#[schema(example = "2025-09-20T13:00:00Z", value_type = String)]
+	pub start_date: DateTime<Utc>,
+	pub price: f64,
+	pub is_online: bool,
+	pub description: String,
+	pub detail_link: String,
+	pub location: Option<String>,
+}
+
+impl ZodValidate for EventsUpdateRequestDto {
+	fn zod_validate(value: &serde_json::Value) -> Result<Self, String> {
+		serde_json::from_value(value.clone()).map_err(|e| e.to_string())
+	}
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, ToSchema)]
+pub struct EventsListItemDto {
+	pub id: String,
+	pub name: String,
+	pub description: String,
+	pub detail_link: String,
+	pub price: f64,
+	pub is_online: bool,
+	pub start_date: String,
+	pub end_date: String,
+	pub created_at: String,
+	pub location: Option<String>,
+	pub is_deleted: bool,
+}
+
+impl From<EventEntity> for EventsListItemDto {
+	fn from(e: EventEntity) -> Self {
+		EventsListItemDto {
+			id: e.id.to_string(),
+			name: e.name,
+			description: e.description,
+			detail_link: e.detail_link,
+			price: e.price,
+			is_online: e.is_online,
+			start_date: e.start_date.to_rfc3339(),
+			end_date: e.end_date.to_rfc3339(),
+			created_at: e.created_at.to_rfc3339(),
+			location: e.location,
+			is_deleted: e.is_deleted,
+		}
+	}
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, ToSchema)]
+pub struct EventsDetailItemDto {
+	pub id: String,
+	pub name: String,
+	pub description: String,
+	pub detail_link: String,
+	pub price: f64,
+	pub is_online: bool,
+	pub start_date: String,
+	pub end_date: String,
+	pub created_at: String,
+	pub updated_at: String,
+	pub location: Option<String>,
+}
+
+impl From<EventEntity> for EventsDetailItemDto {
+	fn from(e: EventEntity) -> Self {
+		EventsDetailItemDto {
+			id: e.id.to_string(),
+			name: e.name,
+			description: e.description,
+			detail_link: e.detail_link,
+			price: e.price,
+			is_online: e.is_online,
+			start_date: e.start_date.to_rfc3339(),
+			end_date: e.end_date.to_rfc3339(),
+			created_at: e.created_at.to_rfc3339(),
+			updated_at: e.updated_at.to_rfc3339(),
+			location: e.location,
+		}
+	}
+}

imphnen-cms/src/events/infrastructure/http/handlers.rs

@@ -0,0 +1,180 @@
+use super::dto::{
+	EventsCreateRequestDto, EventsDetailItemDto, EventsListItemDto,
+	EventsUpdateRequestDto,
+};
+use crate::events::domain::EventService;
+use axum::{
+	Extension,
+	extract::Path,
+	http::HeaderMap,
+	response::{IntoResponse, Response},
+};
+use imphnen_entities::ResponseSuccessDto;
+use imphnen_iam::{PermissionsEnum, require_permissions};
+use imphnen_libs::{AppState, ValidatedJson};
+use imphnen_utils::AppError;
+use imphnen_utils::{ApiMessage, ApiPaginated, ApiSuccess};
+use paginator_axum::PaginationQuery;
+use paginator_utils::PaginatorResponse;
+use std::sync::Arc;
+use uuid::Uuid;
+
+#[utoipa::path(
+    get,
+    path = "/v1/landing/cms/events",
+    params(
+        ("page" = Option<i64>, Query, description = "Page number"),
+        ("per_page" = Option<i64>, Query, description = "Items per page"),
+        ("search" = Option<String>, Query, description = "Search keyword"),
+        ("sort_by" = Option<String>, Query, description = "Sort by field"),
+        ("order" = Option<String>, Query, description = "Order ASC or DESC"),
+    ),
+    responses(
+        (status = 200, description = "[PUBLIC] Get event list")
+    ),
+    tag = "Events"
+)]
+pub async fn get_event_list(
+	Extension(service): Extension<Arc<dyn EventService>>,
+	PaginationQuery(params): PaginationQuery,
+) -> Response {
+	match service.list(params).await {
+		Ok(result) => {
+			let mapped = PaginatorResponse {
+				data: result
+					.data
+					.into_iter()
+					.map(EventsListItemDto::from)
+					.collect::<Vec<_>>(),
+				meta: result.meta,
+			};
+			ApiPaginated(mapped).into_response()
+		}
+		Err(e) => ApiMessage::new(axum::http::StatusCode::BAD_REQUEST, e.to_string())
+			.into_response(),
+	}
+}
+
+#[utoipa::path(
+    get,
+    path = "/v1/landing/cms/events/detail/{id}",
+    params(
+        ("id" = String, Path, description = "Event ID")
+    ),
+    responses(
+        (status = 200, description = "[PUBLIC] Get event by ID", body = ResponseSuccessDto<EventsDetailItemDto>)
+    ),
+    tag = "Events"
+)]
+pub async fn get_event_by_id(
+	Extension(service): Extension<Arc<dyn EventService>>,
+	Path(id): Path<String>,
+) -> Response {
+	let uuid = match Uuid::parse_str(&id) {
+		Ok(u) => u,
+		Err(e) => {
+			return ApiMessage::new(
+				axum::http::StatusCode::BAD_REQUEST,
+				format!("Invalid UUID: {e}"),
+			)
+			.into_response();
+		}
+	};
+	match service.get(uuid).await {
+		Ok(event) => ApiSuccess(EventsDetailItemDto::from(event)).into_response(),
+		Err(e) => ApiMessage::new(axum::http::StatusCode::NOT_FOUND, e.to_string())
+			.into_response(),
+	}
+}
+
+#[utoipa::path(
+    post,
+    security(("Bearer" = [])),
+    path = "/v1/landing/cms/events/create",
+    request_body = EventsCreateRequestDto,
+    responses(
+        (status = 201, description = "[ADMIN] Create new event")
+    ),
+    tag = "Events"
+)]
+pub async fn post_create_event(
+	headers: HeaderMap,
+	Extension(state): Extension<AppState>,
+	Extension(service): Extension<Arc<dyn EventService>>,
+	ValidatedJson(payload): ValidatedJson<EventsCreateRequestDto>,
+) -> Result<impl IntoResponse, AppError> {
+	require_permissions!(headers, state, [PermissionsEnum::Administrator], {
+		let entity = payload.into();
+		service.create(entity).await?;
+		Ok(ApiMessage::created("Event created"))
+	})
+}
+
+#[utoipa::path(
+    patch,
+    security(("Bearer" = [])),
+    path = "/v1/landing/cms/events/update/{id}",
+    params(
+        ("id" = String, Path, description = "Event ID")
+    ),
+    request_body = EventsUpdateRequestDto,
+    responses(
+        (status = 200, description = "[ADMIN] Update event")
+    ),
+    tag = "Events"
+)]
+pub async fn patch_update_event(
+	headers: HeaderMap,
+	Extension(state): Extension<AppState>,
+	Extension(service): Extension<Arc<dyn EventService>>,
+	Path(id): Path<String>,
+	ValidatedJson(payload): ValidatedJson<EventsUpdateRequestDto>,
+) -> Result<impl IntoResponse, AppError> {
+	require_permissions!(headers, state, [PermissionsEnum::Administrator], {
+		let uuid = Uuid::parse_str(&id)
+			.map_err(|e| AppError::BadRequestError(format!("Invalid UUID: {e}")))?;
+		let existing = service.get(uuid).await?;
+		let entity = crate::events::domain::EventEntity {
+			id: existing.id,
+			name: payload.name,
+			description: payload.description,
+			detail_link: payload.detail_link,
+			price: payload.price,
+			is_online: payload.is_online,
+			location: payload.location,
+			start_date: payload.start_date,
+			end_date: payload.end_date,
+			is_deleted: existing.is_deleted,
+			created_at: existing.created_at,
+			updated_at: chrono::Utc::now(),
+		};
+		service.update(entity).await?;
+		Ok(ApiMessage::ok("Event updated"))
+	})
+}
+
+#[utoipa::path(
+    delete,
+    security(("Bearer" = [])),
+    path = "/v1/landing/cms/events/delete/{id}",
+    params(
+        ("id" = String, Path, description = "Event ID")
+    ),
+    responses(
+        (status = 200, description = "[ADMIN] Soft delete event")
+    ),
+    tag = "Events"
+)]
+pub async fn delete_event(
+	headers: HeaderMap,
+	Extension(state): Extension<AppState>,
+	Extension(service): Extension<Arc<dyn EventService>>,
+	Path(id): Path<String>,
+) -> Result<impl IntoResponse, AppError> {
+	require_permissions!(headers, state, [PermissionsEnum::Administrator], {
+		let uuid = Uuid::parse_str(&id)
+			.map_err(|e| AppError::BadRequestError(format!("Invalid UUID: {e}")))?;
+		service.delete(uuid).await?;
+		Ok(ApiMessage::ok("Event deleted"))
+	})
+}

imphnen-cms/src/events/infrastructure/http/mod.rs

@@ -0,0 +1,5 @@
+pub mod dto;
+pub mod handlers;
+pub mod routes;
+
+pub use routes::{events_protected_routes, events_public_routes};

imphnen-cms/src/events/infrastructure/http/routes.rs

@@ -0,0 +1,35 @@
+use super::handlers::{
+	delete_event, get_event_by_id, get_event_list, patch_update_event,
+	post_create_event,
+};
+use crate::events::application::EventServiceImpl;
+use crate::events::domain::EventService;
+use crate::events::infrastructure::persistence::PostgresEventRepository;
+use axum::{
+	Extension, Router,
+	routing::{delete, get, patch, post},
+};
+use sea_orm::DatabaseConnection;
+use std::sync::Arc;
+
+fn build_service(db: DatabaseConnection) -> Arc<dyn EventService> {
+	let repo = Arc::new(PostgresEventRepository::new(db));
+	Arc::new(EventServiceImpl::new(repo))
+}
+
+pub fn events_public_routes(db: DatabaseConnection) -> Router {
+	let service = build_service(db);
+	Router::new()
+		.route("/events", get(get_event_list))
+		.route("/events/detail/{id}", get(get_event_by_id))
+		.layer(Extension(service))
+}
+
+pub fn events_protected_routes(db: DatabaseConnection) -> Router {
+	let service = build_service(db);
+	Router::new()
+		.route("/events/create", post(post_create_event))
+		.route("/events/update/{id}", patch(patch_update_event))
+		.route("/events/delete/{id}", delete(delete_event))
+		.layer(Extension(service))
+}

imphnen-cms/src/events/infrastructure/mod.rs

@@ -0,0 +1,2 @@
+pub mod http;
+pub mod persistence;

imphnen-cms/src/events/infrastructure/persistence/mod.rs

@@ -0,0 +1,3 @@
+pub mod postgres_event_repository;
+
+pub use postgres_event_repository::PostgresEventRepository;

imphnen-cms/src/events/infrastructure/persistence/postgres_event_repository.rs

@@ -0,0 +1,161 @@
+use crate::events::domain::{event::EventEntity, repository::EventRepository};
+use async_trait::async_trait;
+use imphnen_entities::seaorm::common::events::{
+	ActiveModel as EventsActiveModel, Column as EventsColumn, Entity as EventsEntity,
+	Model as EventsModel,
+};
+use imphnen_utils::AppError;
+use paginator_rs::{PaginationParams, SortDirection};
+use paginator_utils::{PaginatorResponse, PaginatorResponseMeta};
+use sea_orm::prelude::*;
+use sea_orm::{ActiveValue, Order, PaginatorTrait, QueryOrder};
+use std::sync::Arc;
+use uuid::Uuid;
+
+fn to_entity(model: EventsModel) -> EventEntity {
+	EventEntity {
+		id: model.id,
+		name: model.name,
+		description: model.description,
+		detail_link: model.detail_link,
+		price: model.price,
+		is_online: model.is_online,
+		is_deleted: model.is_deleted,
+		location: model.location,
+		start_date: model.start_date,
+		end_date: model.end_date,
+		created_at: model.created_at,
+		updated_at: model.updated_at,
+	}
+}
+
+pub struct PostgresEventRepository {
+	db: Arc<DatabaseConnection>,
+}
+
+impl PostgresEventRepository {
+	pub fn new(db: DatabaseConnection) -> Self {
+		Self { db: Arc::new(db) }
+	}
+}
+
+#[async_trait]
+impl EventRepository for PostgresEventRepository {
+	async fn find_all(
+		&self,
+		params: PaginationParams,
+	) -> Result<PaginatorResponse<EventEntity>, AppError> {
+		let page = params.page.max(1);
+		let per_page = params.per_page.clamp(1, 100);
+
+		let mut query = EventsEntity::find().filter(EventsColumn::IsDeleted.eq(false));
+
+		if let Some(ref search) = params.search {
+			query = query.filter(EventsColumn::Name.contains(&search.query));
+		}
+
+		query = match params.sort_by.as_deref() {
+			Some("name") => match params.sort_direction {
+				Some(SortDirection::Desc) => query.order_by(EventsColumn::Name, Order::Desc),
+				_ => query.order_by(EventsColumn::Name, Order::Asc),
+			},
+			_ => match params.sort_direction {
+				Some(SortDirection::Asc) => {
+					query.order_by(EventsColumn::CreatedAt, Order::Asc)
+				}
+				_ => query.order_by(EventsColumn::CreatedAt, Order::Desc),
+			},
+		};
+
+		let paginator = query.paginate(self.db.as_ref(), per_page as u64);
+		let total = paginator
+			.num_items()
+			.await
+			.map_err(|e| AppError::InternalServerError(e.to_string()))?;
+		let events = paginator
+			.fetch_page((page - 1) as u64)
+			.await
+			.map_err(|e| AppError::InternalServerError(e.to_string()))?;
+
+		let data = events.into_iter().map(to_entity).collect();
+		let meta = PaginatorResponseMeta::new(page, per_page, total as u32);
+		Ok(PaginatorResponse { data, meta })
+	}
+
+	async fn find_by_id(&self, id: Uuid) -> Result<EventEntity, AppError> {
+		let event = EventsEntity::find_by_id(id)
+			.filter(EventsColumn::IsDeleted.eq(false))
+			.one(self.db.as_ref())
+			.await
+			.map_err(|e| AppError::InternalServerError(e.to_string()))?
+			.ok_or_else(|| AppError::NotFoundError("Event not found".to_string()))?;
+
+		Ok(to_entity(event))
+	}
+
+	async fn create(&self, entity: EventEntity) -> Result<(), AppError> {
+		let active_model = EventsActiveModel {
+			id: ActiveValue::Set(entity.id),
+			name: ActiveValue::Set(entity.name),
+			description: ActiveValue::Set(entity.description),
+			detail_link: ActiveValue::Set(entity.detail_link),
+			price: ActiveValue::Set(entity.price),
+			is_online: ActiveValue::Set(entity.is_online),
+			is_deleted: ActiveValue::Set(false),
+			location: ActiveValue::Set(entity.location),
+			start_date: ActiveValue::Set(entity.start_date),
+			end_date: ActiveValue::Set(entity.end_date),
+			created_at: ActiveValue::Set(chrono::Utc::now()),
+			updated_at: ActiveValue::Set(chrono::Utc::now()),
+		};
+
+		EventsEntity::insert(active_model)
+			.exec(self.db.as_ref())
+			.await
+			.map_err(|e| AppError::InternalServerError(e.to_string()))?;
+
+		Ok(())
+	}
+
+	async fn update(&self, entity: EventEntity) -> Result<(), AppError> {
+		let mut active_model: EventsActiveModel = EventsEntity::find_by_id(entity.id)
+			.one(self.db.as_ref())
+			.await
+			.map_err(|e| AppError::InternalServerError(e.to_string()))?
+			.ok_or_else(|| AppError::NotFoundError("Event not found".to_string()))?
+			.into();
+
+		active_model.name = ActiveValue::Set(entity.name);
+		active_model.description = ActiveValue::Set(entity.description);
+		active_model.detail_link = ActiveValue::Set(entity.detail_link);
+		active_model.price = ActiveValue::Set(entity.price);
+		active_model.is_online = ActiveValue::Set(entity.is_online);
+		active_model.location = ActiveValue::Set(entity.location);
+		active_model.start_date = ActiveValue::Set(entity.start_date);
+		active_model.end_date = ActiveValue::Set(entity.end_date);
+		active_model.updated_at = ActiveValue::Set(chrono::Utc::now());
+
+		active_model
+			.update(self.db.as_ref())
+			.await
+			.map_err(|e| AppError::InternalServerError(e.to_string()))?;
+		Ok(())
+	}
+
+	async fn delete(&self, id: Uuid) -> Result<(), AppError> {
+		let mut active_model: EventsActiveModel = EventsEntity::find_by_id(id)
+			.one(self.db.as_ref())
+			.await
+			.map_err(|e| AppError::InternalServerError(e.to_string()))?
+			.ok_or_else(|| AppError::NotFoundError("Event not found".to_string()))?
+			.into();
+
+		active_model.is_deleted = ActiveValue::Set(true);
+		active_model.updated_at = ActiveValue::Set(chrono::Utc::now());
+		active_model
+			.update(self.db.as_ref())
+			.await
+			.map_err(|e| AppError::InternalServerError(e.to_string()))?;
+		Ok(())
+	}
+}

imphnen-cms/src/events/mod.rs

@@ -0,0 +1,5 @@
+pub mod application;
+pub mod domain;
+pub mod infrastructure;
+
+pub use infrastructure::http::{events_protected_routes, events_public_routes};

imphnen-cms/src/lib.rs

@@ -0,0 +1,9 @@
+pub mod events;
+pub mod roadmap;
+pub mod testimonials;
+pub mod qr;
+
+pub use events::{events_protected_routes, events_public_routes};
+pub use roadmap::{roadmap_protected_routes, roadmap_public_routes};
+pub use testimonials::{testimonials_protected_routes, testimonials_public_routes};
+pub use qr::qr_router;

imphnen-cms/src/qr/campaigns/application/campaign_service.rs

@@ -0,0 +1,101 @@
+use async_trait::async_trait;
+use image::{DynamicImage, GenericImageView, ImageFormat, imageops};
+use imphnen_utils::errors::AppError;
+use qrcode::QrCode;
+use std::io::Cursor;
+use std::sync::Arc;
+use uuid::Uuid;
+
+use crate::qr::campaigns::domain::{
+	entity::{CampaignEntity, CreateCampaignInput},
+	repository::CampaignRepository,
+	service::QrCampaignService,
+};
+
+pub struct QrCampaignServiceImpl {
+	repo: Arc<dyn CampaignRepository>,
+}
+
+impl QrCampaignServiceImpl {
+	pub fn new(repo: Arc<dyn CampaignRepository>) -> Self {
+		Self { repo }
+	}
+}
+
+#[async_trait]
+impl QrCampaignService for QrCampaignServiceImpl {
+	async fn create(
+		&self,
+		name: String,
+		url: String,
+		created_by: Uuid,
+	) -> Result<CampaignEntity, AppError> {
+		let qr = QrCode::new(url.as_bytes())
+			.map_err(|e| AppError::InternalServerError(e.to_string()))?;
+		let qr_img = qr
+			.render::<image::Luma<u8>>()
+			.min_dimensions(256, 256)
+			.build();
+		let mut qr_bytes = Vec::new();
+		DynamicImage::ImageLuma8(qr_img)
+			.write_to(&mut Cursor::new(&mut qr_bytes), ImageFormat::Png)
+			.map_err(|e| AppError::InternalServerError(e.to_string()))?;
+
+		let input = CreateCampaignInput {
+			name,
+			url,
+			created_by,
+			qr_code_data: qr_bytes,
+		};
+		self.repo.create(input).await
+	}
+
+	async fn list_all(&self) -> Result<Vec<CampaignEntity>, AppError> {
+		self.repo.find_all().await
+	}
+
+	async fn get_active_qr_data(&self) -> Result<Option<Vec<u8>>, AppError> {
+		self.repo.find_active_qr_data().await
+	}
+
+	async fn set_active(&self, id: Uuid) -> Result<CampaignEntity, AppError> {
+		self.repo.set_active(id).await
+	}
+
+	async fn delete(&self, id: Uuid) -> Result<(), AppError> {
+		self.repo.delete(id).await
+	}
+
+	async fn process_image(&self, image_bytes: Vec<u8>) -> Result<Vec<u8>, AppError> {
+		let qr_data = self
+			.repo
+			.find_active_qr_data()
+			.await?
+			.ok_or_else(|| AppError::NotFoundError("No active campaign".to_string()))?;
+
+		let img = image::load_from_memory(&image_bytes)
+			.map_err(|_| AppError::BadRequestError("Invalid image format".to_string()))?;
+
+		let qr_img = image::load_from_memory(&qr_data).map_err(|_| {
+			AppError::InternalServerError("Failed to load QR data".to_string())
+		})?;
+
+		let (w, h) = img.dimensions();
+		let qr_size = (std::cmp::min(w, h) / 5).max(100);
+
+		let qr_resized =
+			qr_img.resize_exact(qr_size, qr_size, imageops::FilterType::Nearest);
+
+		let mut output = img.to_rgba8();
+		let x = (w - qr_size - 10) as i64;
+		let y = (h - qr_size - 10) as i64;
+		imageops::overlay(&mut output, &qr_resized.to_rgba8(), x, y);
+
+		let mut out_bytes = Vec::new();
+		DynamicImage::ImageRgba8(output)
+			.write_to(&mut Cursor::new(&mut out_bytes), ImageFormat::Png)
+			.map_err(|e| AppError::InternalServerError(e.to_string()))?;
+
+		Ok(out_bytes)
+	}
+}

imphnen-cms/src/qr/campaigns/application/mod.rs

@@ -0,0 +1 @@
+pub mod campaign_service;

imphnen-cms/src/qr/campaigns/domain/entity.rs

@@ -0,0 +1,22 @@
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct CampaignEntity {
+	pub id: Uuid,
+	pub name: String,
+	pub url: String,
+	pub is_active: bool,
+	pub created_by: Uuid,
+	pub expires_at: DateTime<Utc>,
+	pub created_at: Option<DateTime<Utc>>,
+	pub updated_at: Option<DateTime<Utc>>,
+}
+
+pub struct CreateCampaignInput {
+	pub name: String,
+	pub url: String,
+	pub created_by: Uuid,
+	pub qr_code_data: Vec<u8>,
+}

imphnen-cms/src/qr/campaigns/domain/mod.rs

@@ -0,0 +1,3 @@
+pub mod entity;
+pub mod repository;
+pub mod service;

imphnen-cms/src/qr/campaigns/domain/repository.rs

@@ -0,0 +1,17 @@
+use async_trait::async_trait;
+use imphnen_utils::errors::AppError;
+use uuid::Uuid;
+
+use super::entity::{CampaignEntity, CreateCampaignInput};
+
+#[async_trait]
+pub trait CampaignRepository: Send + Sync {
+	async fn create(
+		&self,
+		input: CreateCampaignInput,
+	) -> Result<CampaignEntity, AppError>;
+	async fn find_all(&self) -> Result<Vec<CampaignEntity>, AppError>;
+	async fn find_active_qr_data(&self) -> Result<Option<Vec<u8>>, AppError>;
+	async fn set_active(&self, id: Uuid) -> Result<CampaignEntity, AppError>;
+	async fn delete(&self, id: Uuid) -> Result<(), AppError>;
+}

imphnen-cms/src/qr/campaigns/domain/service.rs

@@ -0,0 +1,20 @@
+use async_trait::async_trait;
+use imphnen_utils::errors::AppError;
+use uuid::Uuid;
+
+use super::entity::CampaignEntity;
+
+#[async_trait]
+pub trait QrCampaignService: Send + Sync {
+	async fn create(
+		&self,
+		name: String,
+		url: String,
+		created_by: Uuid,
+	) -> Result<CampaignEntity, AppError>;
+	async fn list_all(&self) -> Result<Vec<CampaignEntity>, AppError>;
+	async fn get_active_qr_data(&self) -> Result<Option<Vec<u8>>, AppError>;
+	async fn set_active(&self, id: Uuid) -> Result<CampaignEntity, AppError>;
+	async fn delete(&self, id: Uuid) -> Result<(), AppError>;
+	async fn process_image(&self, image_bytes: Vec<u8>) -> Result<Vec<u8>, AppError>;
+}

imphnen-cms/src/qr/campaigns/infrastructure/http/dto.rs

@@ -0,0 +1,22 @@
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+use utoipa::ToSchema;
+use uuid::Uuid;
+
+#[derive(Debug, Deserialize, ToSchema)]
+pub struct CreateCampaignRequest {
+	pub name: String,
+	pub url: String,
+}
+
+#[derive(Debug, Serialize, ToSchema)]
+pub struct CampaignResponse {
+	pub id: Uuid,
+	pub name: String,
+	pub url: String,
+	pub is_active: bool,
+	pub created_by: Uuid,
+	pub expires_at: DateTime<Utc>,
+	pub created_at: Option<DateTime<Utc>>,
+	pub updated_at: Option<DateTime<Utc>>,
+}

imphnen-cms/src/qr/campaigns/infrastructure/http/handlers.rs

@@ -0,0 +1,204 @@
+use axum::{
+	Extension, Json,
+	extract::{Multipart, Path},
+	response::{IntoResponse, Response},
+};
+use imphnen_utils::{errors::AppError, response_format::ApiSuccess};
+use std::sync::Arc;
+use uuid::Uuid;
+
+use crate::qr::{
+	campaigns::{
+		domain::service::QrCampaignService,
+		infrastructure::http::dto::CreateCampaignRequest,
+	},
+	middleware::qr_auth::QrAuthUser,
+};
+
+#[utoipa::path(
+    post,
+    path = "/v1/qr/campaigns",
+    request_body = CreateCampaignRequest,
+    responses(
+        (status = 201, description = "Create a QR campaign",
+         example = json!({
+             "data": {
+                 "id": "e5f6a7b8-c9d0-1234-efab-345678901234",
+                 "name": "Imphnen Hackathon 2025",
+                 "url": "https://imphnen.dev/register",
+                 "is_active": false,
+                 "created_by": "3fa85f64-5717-4562-b3fc-2c963f66afa6",
+                 "expires_at": "2025-12-31T23:59:59Z",
+                 "created_at": "2025-01-01T00:00:00Z",
+                 "updated_at": "2025-01-01T00:00:00Z"
+             },
+             "version": "0.3.0"
+         })),
+        (status = 401, description = "Unauthorized"),
+        (status = 403, description = "Forbidden - admin only")
+    ),
+    tag = "QR - Campaigns",
+    security(("Bearer" = []))
+)]
+pub async fn create_campaign_handler(
+	Extension(service): Extension<Arc<dyn QrCampaignService>>,
+	Extension(auth_user): Extension<QrAuthUser>,
+	Json(body): Json<CreateCampaignRequest>,
+) -> Result<Response, AppError> {
+	if auth_user.role != "admin" {
+		return Err(AppError::ForbiddenError(
+			"Admin access required".to_string(),
+		));
+	}
+	let campaign = service
+		.create(body.name, body.url, auth_user.user_id)
+		.await?;
+	Ok(imphnen_utils::response_format::ApiCreated(campaign).into_response())
+}
+
+#[utoipa::path(
+    get,
+    path = "/v1/qr/campaigns",
+    responses(
+        (status = 200, description = "Admin: list all QR campaigns",
+         example = json!({
+             "data": [
+                 {
+                     "id": "e5f6a7b8-c9d0-1234-efab-345678901234",
+                     "name": "Imphnen Hackathon 2025",
+                     "url": "https://imphnen.dev/register",
+                     "is_active": true,
+                     "created_by": "3fa85f64-5717-4562-b3fc-2c963f66afa6",
+                     "expires_at": "2025-12-31T23:59:59Z",
+                     "created_at": "2025-01-01T00:00:00Z",
+                     "updated_at": "2025-01-05T00:00:00Z"
+                 }
+             ],
+             "version": "0.3.0"
+         })),
+        (status = 401, description = "Unauthorized"),
+        (status = 403, description = "Forbidden - admin only")
+    ),
+    tag = "QR - Campaigns",
+    security(("Bearer" = []))
+)]
+pub async fn list_campaigns_handler(
+	Extension(service): Extension<Arc<dyn QrCampaignService>>,
+	Extension(auth_user): Extension<QrAuthUser>,
+) -> Result<Response, AppError> {
+	if auth_user.role != "admin" {
+		return Err(AppError::ForbiddenError(
+			"Admin access required".to_string(),
+		));
+	}
+	let campaigns = service.list_all().await?;
+	Ok(ApiSuccess(campaigns).into_response())
+}
+
+#[utoipa::path(
+    put,
+    path = "/v1/qr/campaigns/{id}/activate",
+    params(("id" = Uuid, Path, description = "Campaign ID")),
+    responses(
+        (status = 200, description = "Admin: activate a campaign (deactivates all others)",
+         example = json!({
+             "data": {
+                 "id": "e5f6a7b8-c9d0-1234-efab-345678901234",
+                 "name": "Imphnen Hackathon 2025",
+                 "url": "https://imphnen.dev/register",
+                 "is_active": true,
+                 "created_by": "3fa85f64-5717-4562-b3fc-2c963f66afa6",
+                 "expires_at": "2025-12-31T23:59:59Z",
+                 "created_at": "2025-01-01T00:00:00Z",
+                 "updated_at": "2025-01-05T10:00:00Z"
+             },
+             "version": "0.3.0"
+         })),
+        (status = 401, description = "Unauthorized"),
+        (status = 403, description = "Forbidden - admin only")
+    ),
+    tag = "QR - Campaigns",
+    security(("Bearer" = []))
+)]
+pub async fn activate_campaign_handler(
+	Extension(service): Extension<Arc<dyn QrCampaignService>>,
+	Extension(auth_user): Extension<QrAuthUser>,
+	Path(id): Path<Uuid>,
+) -> Result<Response, AppError> {
+	if auth_user.role != "admin" {
+		return Err(AppError::ForbiddenError(
+			"Admin access required".to_string(),
+		));
+	}
+	let campaign = service.set_active(id).await?;
+	Ok(ApiSuccess(campaign).into_response())
+}
+
+#[utoipa::path(
+    delete,
+    path = "/v1/qr/campaigns/{id}",
+    params(("id" = Uuid, Path, description = "Campaign ID")),
+    responses(
+        (status = 200, description = "Admin: delete a campaign",
+         example = json!({"message": "Campaign deleted successfully", "version": "0.3.0"})),
+        (status = 401, description = "Unauthorized"),
+        (status = 403, description = "Forbidden - admin only")
+    ),
+    tag = "QR - Campaigns",
+    security(("Bearer" = []))
+)]
+pub async fn delete_campaign_handler(
+	Extension(service): Extension<Arc<dyn QrCampaignService>>,
+	Extension(auth_user): Extension<QrAuthUser>,
+	Path(id): Path<Uuid>,
+) -> Result<Response, AppError> {
+	if auth_user.role != "admin" {
+		return Err(AppError::ForbiddenError(
+			"Admin access required".to_string(),
+		));
+	}
+	service.delete(id).await?;
+	Ok(
+		imphnen_utils::response_format::ApiMessage::ok("Campaign deleted successfully")
+			.into_response(),
+	)
+}
+
+#[utoipa::path(
+    post,
+    path = "/v1/qr/campaigns/process-image",
+    responses(
+        (status = 200, description = "Process QR code image — send multipart/form-data with field 'file'. Returns PNG image bytes.",
+         content_type = "image/png"),
+        (status = 400, description = "No file provided or invalid image"),
+        (status = 401, description = "Unauthorized")
+    ),
+    tag = "QR - Campaigns",
+    security(("Bearer" = []))
+)]
+pub async fn process_image_handler(
+	Extension(service): Extension<Arc<dyn QrCampaignService>>,
+	Extension(_auth_user): Extension<QrAuthUser>,
+	mut multipart: Multipart,
+) -> Result<Response, AppError> {
+	let mut image_bytes = Vec::new();
+	while let Some(field) = multipart
+		.next_field()
+		.await
+		.map_err(|e| AppError::BadRequestError(e.to_string()))?
+	{
+		if field.name() == Some("file") {
+			image_bytes = field
+				.bytes()
+				.await
+				.map_err(|e| AppError::BadRequestError(e.to_string()))?
+				.to_vec();
+			break;
+		}
+	}
+	if image_bytes.is_empty() {
+		return Err(AppError::BadRequestError("No file provided".to_string()));
+	}
+	let png_bytes = service.process_image(image_bytes).await?;
+	Ok(([(axum::http::header::CONTENT_TYPE, "image/png")], png_bytes).into_response())
+}

imphnen-cms/src/qr/campaigns/infrastructure/http/mod.rs

@@ -0,0 +1,3 @@
+pub mod dto;
+pub mod handlers;
+pub mod routes;

imphnen-cms/src/qr/campaigns/infrastructure/http/routes.rs

@@ -0,0 +1,41 @@
+use axum::{
+	Extension, Router,
+	middleware::from_fn,
+	routing::{delete, post, put},
+};
+use sqlx::PgPool;
+use std::sync::Arc;
+
+use crate::qr::{
+	campaigns::{
+		application::campaign_service::QrCampaignServiceImpl,
+		domain::{repository::CampaignRepository, service::QrCampaignService},
+		infrastructure::{
+			http::handlers::{
+				activate_campaign_handler, create_campaign_handler, delete_campaign_handler,
+				list_campaigns_handler, process_image_handler,
+			},
+			persistence::postgres_campaign_repository::PostgresCampaignRepository,
+		},
+	},
+	middleware::qr_auth::qr_auth_middleware,
+};
+
+pub fn qr_campaigns_routes(pool: Arc<PgPool>) -> Router {
+	let repo: Arc<dyn CampaignRepository> =
+		Arc::new(PostgresCampaignRepository::new(pool.clone()));
+	let service: Arc<dyn QrCampaignService> =
+		Arc::new(QrCampaignServiceImpl::new(repo));
+
+	Router::new()
+		.route(
+			"/campaigns",
+			post(create_campaign_handler).get(list_campaigns_handler),
+		)
+		.route("/campaigns/{id}/activate", put(activate_campaign_handler))
+		.route("/campaigns/{id}", delete(delete_campaign_handler))
+		.route("/campaigns/process-image", post(process_image_handler))
+		.layer(Extension(service))
+		.layer(from_fn(qr_auth_middleware))
+		.layer(Extension(pool))
+}

imphnen-cms/src/qr/campaigns/infrastructure/mod.rs

@@ -0,0 +1,2 @@
+pub mod http;
+pub mod persistence;

imphnen-cms/src/qr/campaigns/infrastructure/persistence/mod.rs

@@ -0,0 +1 @@
+pub mod postgres_campaign_repository;

imphnen-cms/src/qr/campaigns/infrastructure/persistence/postgres_campaign_repository.rs

@@ -0,0 +1,147 @@
+use async_trait::async_trait;
+use imphnen_utils::errors::AppError;
+use sqlx::FromRow;
+use sqlx::PgPool;
+use std::sync::Arc;
+use uuid::Uuid;
+
+use crate::qr::campaigns::domain::{
+	entity::{CampaignEntity, CreateCampaignInput},
+	repository::CampaignRepository,
+};
+
+#[derive(FromRow)]
+struct CampaignRow {
+	pub id: Uuid,
+	pub name: String,
+	pub url: String,
+	pub is_active: bool,
+	pub created_by: Uuid,
+	pub expires_at: chrono::DateTime<chrono::Utc>,
+	pub created_at: Option<chrono::DateTime<chrono::Utc>>,
+	pub updated_at: Option<chrono::DateTime<chrono::Utc>>,
+}
+
+impl From<CampaignRow> for CampaignEntity {
+	fn from(row: CampaignRow) -> Self {
+		CampaignEntity {
+			id: row.id,
+			name: row.name,
+			url: row.url,
+			is_active: row.is_active,
+			created_by: row.created_by,
+			expires_at: row.expires_at,
+			created_at: row.created_at,
+			updated_at: row.updated_at,
+		}
+	}
+}
+
+pub struct PostgresCampaignRepository {
+	pool: Arc<PgPool>,
+}
+
+impl PostgresCampaignRepository {
+	pub fn new(pool: Arc<PgPool>) -> Self {
+		Self { pool }
+	}
+}
+
+#[async_trait]
+impl CampaignRepository for PostgresCampaignRepository {
+	async fn create(
+		&self,
+		input: CreateCampaignInput,
+	) -> Result<CampaignEntity, AppError> {
+		let mut tx = self
+			.pool
+			.begin()
+			.await
+			.map_err(|e| AppError::InternalServerError(e.to_string()))?;
+
+		sqlx::query("UPDATE qr_campaigns SET is_active = false, updated_at = NOW()")
+			.execute(&mut *tx)
+			.await
+			.map_err(|e| AppError::InternalServerError(e.to_string()))?;
+
+		let id = Uuid::new_v4();
+		let campaign = sqlx::query_as::<_, CampaignRow>(
+            "INSERT INTO qr_campaigns (id, name, url, qr_code_data, is_active, created_by, expires_at) \
+             VALUES ($1, $2, $3, $4, true, $5, NOW() + INTERVAL '30 days') \
+             RETURNING id, name, url, is_active, created_by, expires_at, created_at, updated_at",
+        )
+        .bind(id)
+        .bind(&input.name)
+        .bind(&input.url)
+        .bind(&input.qr_code_data)
+        .bind(input.created_by)
+        .fetch_one(&mut *tx)
+        .await
+        .map_err(|e| AppError::InternalServerError(e.to_string()))?;
+
+		tx.commit()
+			.await
+			.map_err(|e| AppError::InternalServerError(e.to_string()))?;
+
+		Ok(campaign.into())
+	}
+
+	async fn find_all(&self) -> Result<Vec<CampaignEntity>, AppError> {
+		sqlx::query_as::<_, CampaignRow>(
+			"SELECT id, name, url, is_active, created_by, expires_at, created_at, updated_at \
+             FROM qr_campaigns ORDER BY created_at DESC",
+		)
+		.fetch_all(self.pool.as_ref())
+		.await
+		.map_err(|e| AppError::InternalServerError(e.to_string()))
+		.map(|rows| rows.into_iter().map(Into::into).collect())
+	}
+
+	async fn find_active_qr_data(&self) -> Result<Option<Vec<u8>>, AppError> {
+		let row = sqlx::query_as::<_, (Vec<u8>,)>(
+			"SELECT qr_code_data FROM qr_campaigns WHERE is_active = true LIMIT 1",
+		)
+		.fetch_optional(self.pool.as_ref())
+		.await
+		.map_err(|e| AppError::InternalServerError(e.to_string()))?;
+
+		Ok(row.map(|r| r.0))
+	}
+
+	async fn set_active(&self, id: Uuid) -> Result<CampaignEntity, AppError> {
+		let mut tx = self
+			.pool
+			.begin()
+			.await
+			.map_err(|e| AppError::InternalServerError(e.to_string()))?;
+
+		sqlx::query("UPDATE qr_campaigns SET is_active = false, updated_at = NOW()")
+			.execute(&mut *tx)
+			.await
+			.map_err(|e| AppError::InternalServerError(e.to_string()))?;
+
+		let campaign = sqlx::query_as::<_, CampaignRow>(
+            "UPDATE qr_campaigns SET is_active = true, updated_at = NOW() WHERE id = $1 \
+             RETURNING id, name, url, is_active, created_by, expires_at, created_at, updated_at",
+        )
+        .bind(id)
+        .fetch_one(&mut *tx)
+        .await
+        .map_err(|e| AppError::InternalServerError(e.to_string()))?;
+
+		tx.commit()
+			.await
+			.map_err(|e| AppError::InternalServerError(e.to_string()))?;
+
+		Ok(campaign.into())
+	}
+
+	async fn delete(&self, id: Uuid) -> Result<(), AppError> {
+		sqlx::query("DELETE FROM qr_campaigns WHERE id = $1")
+			.bind(id)
+			.execute(self.pool.as_ref())
+			.await
+			.map_err(|e| AppError::InternalServerError(e.to_string()))?;
+		Ok(())
+	}
+}

imphnen-cms/src/qr/campaigns/mod.rs

@@ -0,0 +1,4 @@
+pub mod application;
+pub mod domain;
+pub mod infrastructure;
+pub use infrastructure::http::routes::qr_campaigns_routes;

imphnen-cms/src/qr/middleware/mod.rs

@@ -0,0 +1 @@
+pub mod qr_auth;

imphnen-cms/src/qr/middleware/qr_auth.rs

@@ -0,0 +1,69 @@
+use axum::http::StatusCode;
+use axum::{
+	body::Body,
+	extract::Request,
+	middleware::Next,
+	response::{IntoResponse, Response},
+};
+use imphnen_libs::decode_access_token;
+use serde::{Deserialize, Serialize};
+use sqlx::PgPool;
+use std::sync::Arc;
+use uuid::Uuid;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct QrAuthUser {
+	pub user_id: Uuid,
+	pub role: String,
+}
+
+pub async fn qr_auth_middleware(
+	axum::Extension(pool): axum::Extension<Arc<PgPool>>,
+	mut request: Request<Body>,
+	next: Next,
+) -> Result<Response, Response> {
+	let auth_header = request
+		.headers()
+		.get("Authorization")
+		.and_then(|h| h.to_str().ok())
+		.ok_or_else(|| {
+			(StatusCode::UNAUTHORIZED, "Missing Authorization header").into_response()
+		})?;
+
+	let token = auth_header.strip_prefix("Bearer ").ok_or_else(|| {
+		(
+			StatusCode::UNAUTHORIZED,
+			"Invalid Authorization header format",
+		)
+			.into_response()
+	})?;
+
+	let token_data = decode_access_token(token).map_err(|_| {
+		(StatusCode::UNAUTHORIZED, "Invalid or expired token").into_response()
+	})?;
+
+	let user_id = Uuid::parse_str(&token_data.claims.user_id).map_err(|_| {
+		(StatusCode::UNAUTHORIZED, "Invalid user ID in token").into_response()
+	})?;
+
+	let _ = sqlx::query(
+        "INSERT INTO qr_users (id, email, name, role, provider) VALUES ($1, $2, $2, 'user', 'external') ON CONFLICT (id) DO NOTHING"
+    )
+    .bind(user_id)
+    .bind(&token_data.claims.sub)
+    .execute(pool.as_ref())
+    .await;
+
+	let role: String = sqlx::query_scalar("SELECT role FROM qr_users WHERE id = $1")
+		.bind(user_id)
+		.fetch_optional(pool.as_ref())
+		.await
+		.ok()
+		.flatten()
+		.unwrap_or_else(|| "user".to_string());
+
+	request
+		.extensions_mut()
+		.insert(QrAuthUser { user_id, role });
+	Ok(next.run(request).await)
+}

imphnen-cms/src/qr/mod.rs

@@ -0,0 +1,15 @@
+pub mod campaigns;
+pub mod middleware;
+pub mod users;
+
+use axum::Router;
+use sea_orm::DatabaseConnection;
+use sqlx::PgPool;
+use std::sync::Arc;
+
+pub fn qr_router(db: DatabaseConnection) -> Router {
+    let pool: Arc<PgPool> = Arc::new(db.get_postgres_connection_pool().clone());
+    Router::new()
+        .merge(users::infrastructure::http::routes::qr_users_routes(pool.clone()))
+        .merge(campaigns::infrastructure::http::routes::qr_campaigns_routes(pool))
+}

imphnen-cms/src/qr/users/application/mod.rs

@@ -0,0 +1 @@
+pub mod user_service;

imphnen-cms/src/qr/users/application/user_service.rs

@@ -0,0 +1,62 @@
+use async_trait::async_trait;
+use imphnen_utils::errors::AppError;
+use std::sync::Arc;
+use uuid::Uuid;
+
+use crate::qr::users::domain::{
+	entity::{UpdateUserInput, UserEntity},
+	repository::UserRepository,
+	service::QrUserService,
+};
+
+pub struct QrUserServiceImpl {
+	repo: Arc<dyn UserRepository>,
+}
+
+impl QrUserServiceImpl {
+	pub fn new(repo: Arc<dyn UserRepository>) -> Self {
+		Self { repo }
+	}
+}
+
+#[async_trait]
+impl QrUserService for QrUserServiceImpl {
+	async fn get_profile(&self, user_id: Uuid) -> Result<UserEntity, AppError> {
+		self
+			.repo
+			.find_by_id(user_id)
+			.await?
+			.ok_or_else(|| AppError::NotFoundError("User not found".to_string()))
+	}
+
+	async fn update_profile(
+		&self,
+		user_id: Uuid,
+		input: UpdateUserInput,
+	) -> Result<UserEntity, AppError> {
+		if let Some(ref email) = input.email
+			&& email.trim().is_empty()
+		{
+			return Err(AppError::ValidationError(
+				"Email cannot be empty".to_string(),
+			));
+		}
+		self.repo.update(user_id, input).await
+	}
+
+	async fn list_all(&self) -> Result<Vec<UserEntity>, AppError> {
+		self.repo.find_all().await
+	}
+
+	async fn update_role(
+		&self,
+		id: Uuid,
+		role: String,
+	) -> Result<UserEntity, AppError> {
+		self.repo.update_role(id, role).await
+	}
+
+	async fn delete(&self, id: Uuid) -> Result<(), AppError> {
+		self.repo.delete(id).await
+	}
+}

imphnen-cms/src/qr/users/domain/entity.rs

@@ -0,0 +1,19 @@
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct UserEntity {
+	pub id: Uuid,
+	pub email: String,
+	pub name: String,
+	pub role: String,
+	pub provider: String,
+	pub created_at: Option<DateTime<Utc>>,
+	pub updated_at: Option<DateTime<Utc>>,
+}
+
+pub struct UpdateUserInput {
+	pub name: Option<String>,
+	pub email: Option<String>,
+}

imphnen-cms/src/qr/users/domain/mod.rs

@@ -0,0 +1,3 @@
+pub mod entity;
+pub mod repository;
+pub mod service;

imphnen-cms/src/qr/users/domain/repository.rs

@@ -0,0 +1,22 @@
+use async_trait::async_trait;
+use imphnen_utils::errors::AppError;
+use uuid::Uuid;
+
+use super::entity::{UpdateUserInput, UserEntity};
+
+#[async_trait]
+pub trait UserRepository: Send + Sync {
+	async fn find_by_id(&self, id: Uuid) -> Result<Option<UserEntity>, AppError>;
+	async fn find_all(&self) -> Result<Vec<UserEntity>, AppError>;
+	async fn update(
+		&self,
+		id: Uuid,
+		input: UpdateUserInput,
+	) -> Result<UserEntity, AppError>;
+	async fn update_role(
+		&self,
+		id: Uuid,
+		role: String,
+	) -> Result<UserEntity, AppError>;
+	async fn delete(&self, id: Uuid) -> Result<(), AppError>;
+}

imphnen-cms/src/qr/users/domain/service.rs

@@ -0,0 +1,22 @@
+use async_trait::async_trait;
+use imphnen_utils::errors::AppError;
+use uuid::Uuid;
+
+use super::entity::{UpdateUserInput, UserEntity};
+
+#[async_trait]
+pub trait QrUserService: Send + Sync {
+	async fn get_profile(&self, user_id: Uuid) -> Result<UserEntity, AppError>;
+	async fn update_profile(
+		&self,
+		user_id: Uuid,
+		input: UpdateUserInput,
+	) -> Result<UserEntity, AppError>;
+	async fn list_all(&self) -> Result<Vec<UserEntity>, AppError>;
+	async fn update_role(
+		&self,
+		id: Uuid,
+		role: String,
+	) -> Result<UserEntity, AppError>;
+	async fn delete(&self, id: Uuid) -> Result<(), AppError>;
+}

imphnen-cms/src/qr/users/infrastructure/http/dto.rs

@@ -0,0 +1,22 @@
+use serde::{Deserialize, Serialize};
+use utoipa::ToSchema;
+
+#[derive(Debug, Deserialize, ToSchema)]
+pub struct UpdateProfileRequest {
+	pub name: Option<String>,
+	pub email: Option<String>,
+}
+
+#[derive(Debug, Deserialize, ToSchema)]
+pub struct UpdateRoleRequest {
+	pub role: String,
+}
+
+#[derive(Debug, Serialize, ToSchema)]
+pub struct UserResponse {
+	pub id: String,
+	pub email: String,
+	pub name: String,
+	pub role: String,
+	pub provider: String,
+}

imphnen-cms/src/qr/users/infrastructure/http/handlers.rs

@@ -0,0 +1,199 @@
+use axum::{
+	Extension, Json,
+	extract::Path,
+	response::{IntoResponse, Response},
+};
+use imphnen_utils::{errors::AppError, response_format::ApiSuccess};
+use std::sync::Arc;
+use uuid::Uuid;
+
+use crate::qr::{
+	middleware::qr_auth::QrAuthUser,
+	users::{
+		domain::{entity::UpdateUserInput, service::QrUserService},
+		infrastructure::http::dto::{UpdateProfileRequest, UpdateRoleRequest},
+	},
+};
+
+#[utoipa::path(
+    get,
+    path = "/v1/qr/users/me",
+    responses(
+        (status = 200, description = "Get my QR user profile",
+         example = json!({
+             "data": {
+                 "id": "3fa85f64-5717-4562-b3fc-2c963f66afa6",
+                 "email": "user@example.com",
+                 "name": "Budi Santoso",
+                 "role": "user",
+                 "provider": "google",
+                 "created_at": "2025-01-01T00:00:00Z",
+                 "updated_at": "2025-01-01T00:00:00Z"
+             },
+             "version": "0.3.0"
+         })),
+        (status = 401, description = "Unauthorized")
+    ),
+    tag = "QR - Users",
+    security(("Bearer" = []))
+)]
+pub async fn get_me_handler(
+	Extension(service): Extension<Arc<dyn QrUserService>>,
+	Extension(auth_user): Extension<QrAuthUser>,
+) -> Result<Response, AppError> {
+	let user = service.get_profile(auth_user.user_id).await?;
+	Ok(ApiSuccess(user).into_response())
+}
+
+#[utoipa::path(
+    put,
+    path = "/v1/qr/users/me",
+    request_body = UpdateProfileRequest,
+    responses(
+        (status = 200, description = "Update my QR user profile",
+         example = json!({
+             "data": {
+                 "id": "3fa85f64-5717-4562-b3fc-2c963f66afa6",
+                 "email": "updated@example.com",
+                 "name": "Budi Santoso Updated",
+                 "role": "user",
+                 "provider": "google",
+                 "created_at": "2025-01-01T00:00:00Z",
+                 "updated_at": "2025-01-15T00:00:00Z"
+             },
+             "version": "0.3.0"
+         })),
+        (status = 401, description = "Unauthorized")
+    ),
+    tag = "QR - Users",
+    security(("Bearer" = []))
+)]
+pub async fn update_me_handler(
+	Extension(service): Extension<Arc<dyn QrUserService>>,
+	Extension(auth_user): Extension<QrAuthUser>,
+	Json(body): Json<UpdateProfileRequest>,
+) -> Result<Response, AppError> {
+	let input = UpdateUserInput {
+		name: body.name,
+		email: body.email,
+	};
+	let user = service.update_profile(auth_user.user_id, input).await?;
+	Ok(ApiSuccess(user).into_response())
+}
+
+#[utoipa::path(
+    get,
+    path = "/v1/qr/users",
+    responses(
+        (status = 200, description = "Admin: list all QR users",
+         example = json!({
+             "data": [
+                 {
+                     "id": "3fa85f64-5717-4562-b3fc-2c963f66afa6",
+                     "email": "user@example.com",
+                     "name": "Budi Santoso",
+                     "role": "user",
+                     "provider": "google",
+                     "created_at": "2025-01-01T00:00:00Z",
+                     "updated_at": "2025-01-01T00:00:00Z"
+                 },
+                 {
+                     "id": "4gb96g75-6828-5673-c4gd-3d074g77bgb7",
+                     "email": "admin@example.com",
+                     "name": "Admin User",
+                     "role": "admin",
+                     "provider": "google",
+                     "created_at": "2024-12-01T00:00:00Z",
+                     "updated_at": "2024-12-01T00:00:00Z"
+                 }
+             ],
+             "version": "0.3.0"
+         })),
+        (status = 401, description = "Unauthorized"),
+        (status = 403, description = "Forbidden - admin only")
+    ),
+    tag = "QR - Users",
+    security(("Bearer" = []))
+)]
+pub async fn list_users_handler(
+	Extension(service): Extension<Arc<dyn QrUserService>>,
+	Extension(auth_user): Extension<QrAuthUser>,
+) -> Result<Response, AppError> {
+	if auth_user.role != "admin" {
+		return Err(AppError::ForbiddenError(
+			"Admin access required".to_string(),
+		));
+	}
+	let users = service.list_all().await?;
+	Ok(ApiSuccess(users).into_response())
+}
+
+#[utoipa::path(
+    put,
+    path = "/v1/qr/users/{id}/role",
+    params(("id" = Uuid, Path, description = "User ID")),
+    request_body = UpdateRoleRequest,
+    responses(
+        (status = 200, description = "Admin: update user role",
+         example = json!({
+             "data": {
+                 "id": "3fa85f64-5717-4562-b3fc-2c963f66afa6",
+                 "email": "user@example.com",
+                 "name": "Budi Santoso",
+                 "role": "admin",
+                 "provider": "google",
+                 "created_at": "2025-01-01T00:00:00Z",
+                 "updated_at": "2025-01-20T00:00:00Z"
+             },
+             "version": "0.3.0"
+         })),
+        (status = 401, description = "Unauthorized"),
+        (status = 403, description = "Forbidden - admin only")
+    ),
+    tag = "QR - Users",
+    security(("Bearer" = []))
+)]
+pub async fn update_role_handler(
+	Extension(service): Extension<Arc<dyn QrUserService>>,
+	Extension(auth_user): Extension<QrAuthUser>,
+	Path(id): Path<Uuid>,
+	Json(body): Json<UpdateRoleRequest>,
+) -> Result<Response, AppError> {
+	if auth_user.role != "admin" {
+		return Err(AppError::ForbiddenError(
+			"Admin access required".to_string(),
+		));
+	}
+	let user = service.update_role(id, body.role).await?;
+	Ok(ApiSuccess(user).into_response())
+}
+
+#[utoipa::path(
+    delete,
+    path = "/v1/qr/users/{id}",
+    params(("id" = Uuid, Path, description = "User ID")),
+    responses(
+        (status = 200, description = "Admin: delete QR user",
+         example = json!({"message": "User deleted successfully", "version": "0.3.0"})),
+        (status = 401, description = "Unauthorized"),
+        (status = 403, description = "Forbidden - admin only")
+    ),
+    tag = "QR - Users",
+    security(("Bearer" = []))
+)]
+pub async fn delete_user_handler(
+	Extension(service): Extension<Arc<dyn QrUserService>>,
+	Extension(auth_user): Extension<QrAuthUser>,
+	Path(id): Path<Uuid>,
+) -> Result<Response, AppError> {
+	if auth_user.role != "admin" {
+		return Err(AppError::ForbiddenError(
+			"Admin access required".to_string(),
+		));
+	}
+	service.delete(id).await?;
+	Ok(
+		imphnen_utils::response_format::ApiMessage::ok("User deleted successfully")
+			.into_response(),
+	)
+}

imphnen-cms/src/qr/users/infrastructure/http/mod.rs

@@ -0,0 +1,3 @@
+pub mod dto;
+pub mod handlers;
+pub mod routes;

imphnen-cms/src/qr/users/infrastructure/http/routes.rs

@@ -0,0 +1,37 @@
+use axum::{
+	Extension, Router,
+	middleware::from_fn,
+	routing::{delete, get, put},
+};
+use sqlx::PgPool;
+use std::sync::Arc;
+
+use crate::qr::{
+	middleware::qr_auth::qr_auth_middleware,
+	users::{
+		application::user_service::QrUserServiceImpl,
+		domain::{repository::UserRepository, service::QrUserService},
+		infrastructure::{
+			http::handlers::{
+				delete_user_handler, get_me_handler, list_users_handler, update_me_handler,
+				update_role_handler,
+			},
+			persistence::postgres_user_repository::PostgresUserRepository,
+		},
+	},
+};
+
+pub fn qr_users_routes(pool: Arc<PgPool>) -> Router {
+	let repo: Arc<dyn UserRepository> =
+		Arc::new(PostgresUserRepository::new(pool.clone()));
+	let service: Arc<dyn QrUserService> = Arc::new(QrUserServiceImpl::new(repo));
+
+	Router::new()
+		.route("/users/me", get(get_me_handler).put(update_me_handler))
+		.route("/users", get(list_users_handler))
+		.route("/users/{id}/role", put(update_role_handler))
+		.route("/users/{id}", delete(delete_user_handler))
+		.layer(Extension(service))
+		.layer(from_fn(qr_auth_middleware))
+		.layer(Extension(pool))
+}

imphnen-cms/src/qr/users/infrastructure/mod.rs

@@ -0,0 +1,2 @@
+pub mod http;
+pub mod persistence;

imphnen-cms/src/qr/users/infrastructure/persistence/mod.rs

@@ -0,0 +1 @@
+pub mod postgres_user_repository;

imphnen-cms/src/qr/users/infrastructure/persistence/postgres_user_repository.rs

@@ -0,0 +1,112 @@
+use async_trait::async_trait;
+use imphnen_utils::errors::AppError;
+use sqlx::FromRow;
+use sqlx::PgPool;
+use std::sync::Arc;
+use uuid::Uuid;
+
+use crate::qr::users::domain::{
+	entity::{UpdateUserInput, UserEntity},
+	repository::UserRepository,
+};
+
+#[derive(FromRow)]
+struct UserRow {
+	pub id: Uuid,
+	pub email: String,
+	pub name: String,
+	pub role: String,
+	pub provider: String,
+	pub created_at: Option<chrono::DateTime<chrono::Utc>>,
+	pub updated_at: Option<chrono::DateTime<chrono::Utc>>,
+}
+
+impl From<UserRow> for UserEntity {
+	fn from(row: UserRow) -> Self {
+		UserEntity {
+			id: row.id,
+			email: row.email,
+			name: row.name,
+			role: row.role,
+			provider: row.provider,
+			created_at: row.created_at,
+			updated_at: row.updated_at,
+		}
+	}
+}
+
+pub struct PostgresUserRepository {
+	pool: Arc<PgPool>,
+}
+
+impl PostgresUserRepository {
+	pub fn new(pool: Arc<PgPool>) -> Self {
+		Self { pool }
+	}
+}
+
+#[async_trait]
+impl UserRepository for PostgresUserRepository {
+	async fn find_by_id(&self, id: Uuid) -> Result<Option<UserEntity>, AppError> {
+		sqlx::query_as::<_, UserRow>(
+            "SELECT id, email, name, role, provider, created_at, updated_at FROM qr_users WHERE id = $1",
+        )
+        .bind(id)
+        .fetch_optional(self.pool.as_ref())
+        .await
+        .map_err(|e| AppError::InternalServerError(e.to_string()))
+        .map(|opt| opt.map(Into::into))
+	}
+
+	async fn find_all(&self) -> Result<Vec<UserEntity>, AppError> {
+		sqlx::query_as::<_, UserRow>(
+            "SELECT id, email, name, role, provider, created_at, updated_at FROM qr_users ORDER BY created_at DESC",
+        )
+        .fetch_all(self.pool.as_ref())
+        .await
+        .map_err(|e| AppError::InternalServerError(e.to_string()))
+        .map(|rows| rows.into_iter().map(Into::into).collect())
+	}
+
+	async fn update(
+		&self,
+		id: Uuid,
+		input: UpdateUserInput,
+	) -> Result<UserEntity, AppError> {
+		sqlx::query_as::<_, UserRow>(
+            "UPDATE qr_users SET name = COALESCE($1, name), email = COALESCE($2, email), updated_at = NOW() WHERE id = $3 RETURNING id, email, name, role, provider, created_at, updated_at",
+        )
+        .bind(input.name)
+        .bind(input.email)
+        .bind(id)
+        .fetch_one(self.pool.as_ref())
+        .await
+        .map_err(|e| AppError::InternalServerError(e.to_string()))
+        .map(Into::into)
+	}
+
+	async fn update_role(
+		&self,
+		id: Uuid,
+		role: String,
+	) -> Result<UserEntity, AppError> {
+		sqlx::query_as::<_, UserRow>(
+            "UPDATE qr_users SET role = $1, updated_at = NOW() WHERE id = $2 RETURNING id, email, name, role, provider, created_at, updated_at",
+        )
+        .bind(role)
+        .bind(id)
+        .fetch_one(self.pool.as_ref())
+        .await
+        .map_err(|e| AppError::InternalServerError(e.to_string()))
+        .map(Into::into)
+	}
+
+	async fn delete(&self, id: Uuid) -> Result<(), AppError> {
+		sqlx::query("DELETE FROM qr_users WHERE id = $1")
+			.bind(id)
+			.execute(self.pool.as_ref())
+			.await
+			.map_err(|e| AppError::InternalServerError(e.to_string()))?;
+		Ok(())
+	}
+}

imphnen-cms/src/qr/users/mod.rs

@@ -0,0 +1,4 @@
+pub mod application;
+pub mod domain;
+pub mod infrastructure;
+pub use infrastructure::http::routes::qr_users_routes;

imphnen-cms/src/roadmap/application/mod.rs

@@ -0,0 +1,3 @@
+pub mod roadmap_service;
+
+pub use roadmap_service::RoadmapServiceImpl;

imphnen-cms/src/roadmap/application/roadmap_service.rs

@@ -0,0 +1,47 @@
+use crate::roadmap::domain::{RoadmapEntity, RoadmapRepository, RoadmapService};
+use async_trait::async_trait;
+use imphnen_utils::AppError;
+use paginator_rs::PaginationParams;
+use paginator_utils::PaginatorResponse;
+use std::sync::Arc;
+use uuid::Uuid;
+
+pub struct RoadmapServiceImpl {
+	repo: Arc<dyn RoadmapRepository>,
+}
+
+impl RoadmapServiceImpl {
+	pub fn new(repo: Arc<dyn RoadmapRepository>) -> Self {
+		Self { repo }
+	}
+}
+
+#[async_trait]
+impl RoadmapService for RoadmapServiceImpl {
+	async fn list(
+		&self,
+		params: PaginationParams,
+	) -> Result<PaginatorResponse<RoadmapEntity>, AppError> {
+		self.repo.find_all(params).await
+	}
+
+	async fn get(&self, id: Uuid) -> Result<RoadmapEntity, AppError> {
+		self.repo.find_by_id(id).await
+	}
+
+	async fn create(&self, entity: RoadmapEntity) -> Result<(), AppError> {
+		self.repo.create(entity).await
+	}
+
+	async fn update(&self, entity: RoadmapEntity) -> Result<(), AppError> {
+		self.repo.update(entity).await
+	}
+
+	async fn delete(&self, id: Uuid) -> Result<(), AppError> {
+		self.repo.delete(id).await
+	}
+
+	async fn vote(&self, id: Uuid) -> Result<(), AppError> {
+		self.repo.increment_votes(id).await
+	}
+}

imphnen-cms/src/roadmap/domain/mod.rs

@@ -0,0 +1,7 @@
+pub mod roadmap;
+pub mod repository;
+pub mod service;
+
+pub use roadmap::RoadmapEntity;
+pub use repository::RoadmapRepository;
+pub use service::RoadmapService;

imphnen-cms/src/roadmap/domain/repository.rs

@@ -0,0 +1,19 @@
+use super::roadmap::RoadmapEntity;
+use async_trait::async_trait;
+use imphnen_utils::AppError;
+use paginator_rs::PaginationParams;
+use paginator_utils::PaginatorResponse;
+use uuid::Uuid;
+
+#[async_trait]
+pub trait RoadmapRepository: Send + Sync {
+	async fn find_all(
+		&self,
+		params: PaginationParams,
+	) -> Result<PaginatorResponse<RoadmapEntity>, AppError>;
+	async fn find_by_id(&self, id: Uuid) -> Result<RoadmapEntity, AppError>;
+	async fn create(&self, entity: RoadmapEntity) -> Result<(), AppError>;
+	async fn update(&self, entity: RoadmapEntity) -> Result<(), AppError>;
+	async fn delete(&self, id: Uuid) -> Result<(), AppError>;
+	async fn increment_votes(&self, id: Uuid) -> Result<(), AppError>;
+}

imphnen-cms/src/roadmap/domain/roadmap.rs

@@ -0,0 +1,14 @@
+use chrono::{DateTime, Utc};
+use uuid::Uuid;
+
+#[derive(Clone, Debug)]
+pub struct RoadmapEntity {
+	pub id: Uuid,
+	pub title: String,
+	pub description: String,
+	pub status: String,
+	pub votes: i32,
+	pub is_deleted: bool,
+	pub created_at: DateTime<Utc>,
+	pub updated_at: DateTime<Utc>,
+}

imphnen-cms/src/roadmap/domain/service.rs

@@ -0,0 +1,19 @@
+use super::roadmap::RoadmapEntity;
+use async_trait::async_trait;
+use imphnen_utils::AppError;
+use paginator_rs::PaginationParams;
+use paginator_utils::PaginatorResponse;
+use uuid::Uuid;
+
+#[async_trait]
+pub trait RoadmapService: Send + Sync {
+	async fn list(
+		&self,
+		params: PaginationParams,
+	) -> Result<PaginatorResponse<RoadmapEntity>, AppError>;
+	async fn get(&self, id: Uuid) -> Result<RoadmapEntity, AppError>;
+	async fn create(&self, entity: RoadmapEntity) -> Result<(), AppError>;
+	async fn update(&self, entity: RoadmapEntity) -> Result<(), AppError>;
+	async fn delete(&self, id: Uuid) -> Result<(), AppError>;
+	async fn vote(&self, id: Uuid) -> Result<(), AppError>;
+}

imphnen-cms/src/roadmap/infrastructure/http/dto.rs

@@ -0,0 +1,98 @@
+use crate::roadmap::domain::roadmap::RoadmapEntity;
+use imphnen_libs::ZodValidate;
+use serde::{Deserialize, Serialize};
+use utoipa::ToSchema;
+use uuid::Uuid;
+
+#[derive(Clone, Debug, Serialize, Deserialize, ToSchema)]
+pub struct RoadmapCreateRequestDto {
+	pub title: String,
+	pub description: String,
+	#[schema(example = "upcoming")]
+	pub status: String,
+}
+
+impl ZodValidate for RoadmapCreateRequestDto {
+	fn zod_validate(value: &serde_json::Value) -> Result<Self, String> {
+		serde_json::from_value(value.clone()).map_err(|e| e.to_string())
+	}
+}
+
+impl From<RoadmapCreateRequestDto> for RoadmapEntity {
+	fn from(dto: RoadmapCreateRequestDto) -> Self {
+		RoadmapEntity {
+			id: Uuid::new_v4(),
+			title: dto.title,
+			description: dto.description,
+			status: dto.status,
+			votes: 0,
+			is_deleted: false,
+			created_at: chrono::Utc::now(),
+			updated_at: chrono::Utc::now(),
+		}
+	}
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, ToSchema)]
+pub struct RoadmapUpdateRequestDto {
+	pub title: String,
+	pub description: String,
+	#[schema(example = "upcoming")]
+	pub status: String,
+}
+
+impl ZodValidate for RoadmapUpdateRequestDto {
+	fn zod_validate(value: &serde_json::Value) -> Result<Self, String> {
+		serde_json::from_value(value.clone()).map_err(|e| e.to_string())
+	}
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, ToSchema)]
+pub struct RoadmapListItemDto {
+	pub id: String,
+	pub title: String,
+	pub description: String,
+	pub status: String,
+	pub votes: i32,
+	pub is_deleted: bool,
+	pub created_at: String,
+}
+
+impl From<RoadmapEntity> for RoadmapListItemDto {
+	fn from(e: RoadmapEntity) -> Self {
+		RoadmapListItemDto {
+			id: e.id.to_string(),
+			title: e.title,
+			description: e.description,
+			status: e.status,
+			votes: e.votes,
+			is_deleted: e.is_deleted,
+			created_at: e.created_at.to_rfc3339(),
+		}
+	}
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, ToSchema)]
+pub struct RoadmapDetailItemDto {
+	pub id: String,
+	pub title: String,
+	pub description: String,
+	pub status: String,
+	pub votes: i32,
+	pub created_at: String,
+	pub updated_at: String,
+}
+
+impl From<RoadmapEntity> for RoadmapDetailItemDto {
+	fn from(e: RoadmapEntity) -> Self {
+		RoadmapDetailItemDto {
+			id: e.id.to_string(),
+			title: e.title,
+			description: e.description,
+			status: e.status,
+			votes: e.votes,
+			created_at: e.created_at.to_rfc3339(),
+			updated_at: e.updated_at.to_rfc3339(),
+		}
+	}
+}

imphnen-cms/src/roadmap/infrastructure/http/handlers.rs

@@ -0,0 +1,208 @@
+use super::dto::{
+	RoadmapCreateRequestDto, RoadmapDetailItemDto, RoadmapListItemDto,
+	RoadmapUpdateRequestDto,
+};
+use crate::roadmap::domain::RoadmapService;
+use axum::{
+	Extension,
+	extract::Path,
+	http::HeaderMap,
+	response::{IntoResponse, Response},
+};
+use imphnen_entities::ResponseSuccessDto;
+use imphnen_iam::{PermissionsEnum, require_permissions};
+use imphnen_libs::{AppState, ValidatedJson};
+use imphnen_utils::AppError;
+use imphnen_utils::{ApiMessage, ApiPaginated, ApiSuccess};
+use paginator_axum::PaginationQuery;
+use paginator_utils::PaginatorResponse;
+use std::sync::Arc;
+use uuid::Uuid;
+
+#[utoipa::path(
+    get,
+    path = "/v1/landing/cms/roadmap",
+    params(
+        ("page" = Option<i64>, Query, description = "Page number"),
+        ("per_page" = Option<i64>, Query, description = "Items per page"),
+        ("search" = Option<String>, Query, description = "Search keyword"),
+        ("sort_by" = Option<String>, Query, description = "Sort by field"),
+        ("order" = Option<String>, Query, description = "Order ASC or DESC"),
+    ),
+    responses(
+        (status = 200, description = "[PUBLIC] Get roadmap list")
+    ),
+    tag = "Roadmap"
+)]
+pub async fn get_roadmap_list(
+	Extension(service): Extension<Arc<dyn RoadmapService>>,
+	PaginationQuery(params): PaginationQuery,
+) -> Response {
+	match service.list(params).await {
+		Ok(result) => {
+			let mapped = PaginatorResponse {
+				data: result
+					.data
+					.into_iter()
+					.map(RoadmapListItemDto::from)
+					.collect::<Vec<_>>(),
+				meta: result.meta,
+			};
+			ApiPaginated(mapped).into_response()
+		}
+		Err(e) => ApiMessage::new(axum::http::StatusCode::BAD_REQUEST, e.to_string())
+			.into_response(),
+	}
+}
+
+#[utoipa::path(
+    get,
+    path = "/v1/landing/cms/roadmap/detail/{id}",
+    params(
+        ("id" = String, Path, description = "Roadmap item ID")
+    ),
+    responses(
+        (status = 200, description = "[PUBLIC] Get roadmap item by ID", body = ResponseSuccessDto<RoadmapDetailItemDto>)
+    ),
+    tag = "Roadmap"
+)]
+pub async fn get_roadmap_by_id(
+	Extension(service): Extension<Arc<dyn RoadmapService>>,
+	Path(id): Path<String>,
+) -> Response {
+	let uuid = match Uuid::parse_str(&id) {
+		Ok(u) => u,
+		Err(e) => {
+			return ApiMessage::new(
+				axum::http::StatusCode::BAD_REQUEST,
+				format!("Invalid UUID: {e}"),
+			)
+			.into_response();
+		}
+	};
+	match service.get(uuid).await {
+		Ok(item) => ApiSuccess(RoadmapDetailItemDto::from(item)).into_response(),
+		Err(e) => ApiMessage::new(axum::http::StatusCode::NOT_FOUND, e.to_string())
+			.into_response(),
+	}
+}
+
+#[utoipa::path(
+    post,
+    security(("Bearer" = [])),
+    path = "/v1/landing/cms/roadmap/create",
+    request_body = RoadmapCreateRequestDto,
+    responses(
+        (status = 201, description = "[ADMIN] Create new roadmap item")
+    ),
+    tag = "Roadmap"
+)]
+pub async fn post_create_roadmap(
+	headers: HeaderMap,
+	Extension(state): Extension<AppState>,
+	Extension(service): Extension<Arc<dyn RoadmapService>>,
+	ValidatedJson(payload): ValidatedJson<RoadmapCreateRequestDto>,
+) -> Result<impl IntoResponse, AppError> {
+	require_permissions!(headers, state, [PermissionsEnum::Administrator], {
+		let entity = payload.into();
+		service.create(entity).await?;
+		Ok(ApiMessage::created("Roadmap item created"))
+	})
+}
+
+#[utoipa::path(
+    patch,
+    security(("Bearer" = [])),
+    path = "/v1/landing/cms/roadmap/update/{id}",
+    params(
+        ("id" = String, Path, description = "Roadmap item ID")
+    ),
+    request_body = RoadmapUpdateRequestDto,
+    responses(
+        (status = 200, description = "[ADMIN] Update roadmap item")
+    ),
+    tag = "Roadmap"
+)]
+pub async fn patch_update_roadmap(
+	headers: HeaderMap,
+	Extension(state): Extension<AppState>,
+	Extension(service): Extension<Arc<dyn RoadmapService>>,
+	Path(id): Path<String>,
+	ValidatedJson(payload): ValidatedJson<RoadmapUpdateRequestDto>,
+) -> Result<impl IntoResponse, AppError> {
+	require_permissions!(headers, state, [PermissionsEnum::Administrator], {
+		let uuid = Uuid::parse_str(&id)
+			.map_err(|e| AppError::BadRequestError(format!("Invalid UUID: {e}")))?;
+		let existing = service.get(uuid).await?;
+		let entity = crate::roadmap::domain::RoadmapEntity {
+			id: existing.id,
+			title: payload.title,
+			description: payload.description,
+			status: payload.status,
+			votes: existing.votes,
+			is_deleted: existing.is_deleted,
+			created_at: existing.created_at,
+			updated_at: chrono::Utc::now(),
+		};
+		service.update(entity).await?;
+		Ok(ApiMessage::ok("Roadmap item updated"))
+	})
+}
+
+#[utoipa::path(
+    delete,
+    security(("Bearer" = [])),
+    path = "/v1/landing/cms/roadmap/delete/{id}",
+    params(
+        ("id" = String, Path, description = "Roadmap item ID")
+    ),
+    responses(
+        (status = 200, description = "[ADMIN] Soft delete roadmap item")
+    ),
+    tag = "Roadmap"
+)]
+pub async fn delete_roadmap(
+	headers: HeaderMap,
+	Extension(state): Extension<AppState>,
+	Extension(service): Extension<Arc<dyn RoadmapService>>,
+	Path(id): Path<String>,
+) -> Result<impl IntoResponse, AppError> {
+	require_permissions!(headers, state, [PermissionsEnum::Administrator], {
+		let uuid = Uuid::parse_str(&id)
+			.map_err(|e| AppError::BadRequestError(format!("Invalid UUID: {e}")))?;
+		service.delete(uuid).await?;
+		Ok(ApiMessage::ok("Roadmap item deleted"))
+	})
+}
+
+#[utoipa::path(
+    post,
+    path = "/v1/landing/cms/roadmap/vote/{id}",
+    params(
+        ("id" = String, Path, description = "Roadmap item ID")
+    ),
+    responses(
+        (status = 200, description = "[PUBLIC] Vote for a roadmap item")
+    ),
+    tag = "Roadmap"
+)]
+pub async fn post_vote_roadmap(
+	Extension(service): Extension<Arc<dyn RoadmapService>>,
+	Path(id): Path<String>,
+) -> Response {
+	let uuid = match Uuid::parse_str(&id) {
+		Ok(u) => u,
+		Err(e) => {
+			return ApiMessage::new(
+				axum::http::StatusCode::BAD_REQUEST,
+				format!("Invalid UUID: {e}"),
+			)
+			.into_response();
+		}
+	};
+	match service.vote(uuid).await {
+		Ok(()) => ApiMessage::ok("Vote recorded").into_response(),
+		Err(e) => ApiMessage::new(axum::http::StatusCode::BAD_REQUEST, e.to_string())
+			.into_response(),
+	}
+}

imphnen-cms/src/roadmap/infrastructure/http/mod.rs

@@ -0,0 +1,5 @@
+pub mod dto;
+pub mod handlers;
+pub mod routes;
+
+pub use routes::{roadmap_protected_routes, roadmap_public_routes};

imphnen-cms/src/roadmap/infrastructure/http/routes.rs

@@ -0,0 +1,36 @@
+use super::handlers::{
+	delete_roadmap, get_roadmap_by_id, get_roadmap_list, patch_update_roadmap,
+	post_create_roadmap, post_vote_roadmap,
+};
+use crate::roadmap::application::RoadmapServiceImpl;
+use crate::roadmap::domain::RoadmapService;
+use crate::roadmap::infrastructure::persistence::PostgresRoadmapRepository;
+use axum::{
+	Extension, Router,
+	routing::{delete, get, patch, post},
+};
+use sea_orm::DatabaseConnection;
+use std::sync::Arc;
+
+fn build_service(db: DatabaseConnection) -> Arc<dyn RoadmapService> {
+	let repo = Arc::new(PostgresRoadmapRepository::new(db));
+	Arc::new(RoadmapServiceImpl::new(repo))
+}
+
+pub fn roadmap_public_routes(db: DatabaseConnection) -> Router {
+	let service = build_service(db);
+	Router::new()
+		.route("/roadmap", get(get_roadmap_list))
+		.route("/roadmap/detail/{id}", get(get_roadmap_by_id))
+		.route("/roadmap/vote/{id}", post(post_vote_roadmap))
+		.layer(Extension(service))
+}
+
+pub fn roadmap_protected_routes(db: DatabaseConnection) -> Router {
+	let service = build_service(db);
+	Router::new()
+		.route("/roadmap/create", post(post_create_roadmap))
+		.route("/roadmap/update/{id}", patch(patch_update_roadmap))
+		.route("/roadmap/delete/{id}", delete(delete_roadmap))
+		.layer(Extension(service))
+}

imphnen-cms/src/roadmap/infrastructure/mod.rs

@@ -0,0 +1,2 @@
+pub mod http;
+pub mod persistence;

imphnen-cms/src/roadmap/infrastructure/persistence/mod.rs

@@ -0,0 +1,3 @@
+pub mod postgres_roadmap_repository;
+
+pub use postgres_roadmap_repository::PostgresRoadmapRepository;

imphnen-cms/src/roadmap/infrastructure/persistence/postgres_roadmap_repository.rs

@@ -0,0 +1,171 @@
+use crate::roadmap::domain::{roadmap::RoadmapEntity, repository::RoadmapRepository};
+use async_trait::async_trait;
+use imphnen_entities::seaorm::common::roadmap_items::{
+	ActiveModel as RoadmapActiveModel, Column as RoadmapColumn, Entity as RoadmapEntity_,
+	Model as RoadmapModel,
+};
+use imphnen_utils::AppError;
+use paginator_rs::{PaginationParams, SortDirection};
+use paginator_utils::{PaginatorResponse, PaginatorResponseMeta};
+use sea_orm::prelude::*;
+use sea_orm::{ActiveValue, Order, PaginatorTrait, QueryOrder};
+use std::sync::Arc;
+use uuid::Uuid;
+
+fn to_entity(model: RoadmapModel) -> RoadmapEntity {
+	RoadmapEntity {
+		id: model.id,
+		title: model.title,
+		description: model.description,
+		status: model.status,
+		votes: model.votes,
+		is_deleted: model.is_deleted,
+		created_at: model.created_at,
+		updated_at: model.updated_at,
+	}
+}
+
+pub struct PostgresRoadmapRepository {
+	db: Arc<DatabaseConnection>,
+}
+
+impl PostgresRoadmapRepository {
+	pub fn new(db: DatabaseConnection) -> Self {
+		Self { db: Arc::new(db) }
+	}
+}
+
+#[async_trait]
+impl RoadmapRepository for PostgresRoadmapRepository {
+	async fn find_all(
+		&self,
+		params: PaginationParams,
+	) -> Result<PaginatorResponse<RoadmapEntity>, AppError> {
+		let page = params.page.max(1);
+		let per_page = params.per_page.clamp(1, 100);
+
+		let mut query = RoadmapEntity_::find().filter(RoadmapColumn::IsDeleted.eq(false));
+
+		if let Some(ref search) = params.search {
+			query = query.filter(RoadmapColumn::Title.contains(&search.query));
+		}
+
+		query = match params.sort_by.as_deref() {
+			Some("title") => match params.sort_direction {
+				Some(SortDirection::Desc) => query.order_by(RoadmapColumn::Title, Order::Desc),
+				_ => query.order_by(RoadmapColumn::Title, Order::Asc),
+			},
+			Some("votes") => match params.sort_direction {
+				Some(SortDirection::Asc) => query.order_by(RoadmapColumn::Votes, Order::Asc),
+				_ => query.order_by(RoadmapColumn::Votes, Order::Desc),
+			},
+			_ => match params.sort_direction {
+				Some(SortDirection::Asc) => {
+					query.order_by(RoadmapColumn::CreatedAt, Order::Asc)
+				}
+				_ => query.order_by(RoadmapColumn::CreatedAt, Order::Desc),
+			},
+		};
+
+		let paginator = query.paginate(self.db.as_ref(), per_page as u64);
+		let total = paginator
+			.num_items()
+			.await
+			.map_err(|e| AppError::InternalServerError(e.to_string()))?;
+		let items = paginator
+			.fetch_page((page - 1) as u64)
+			.await
+			.map_err(|e| AppError::InternalServerError(e.to_string()))?;
+
+		let data = items.into_iter().map(to_entity).collect();
+		let meta = PaginatorResponseMeta::new(page, per_page, total as u32);
+		Ok(PaginatorResponse { data, meta })
+	}
+
+	async fn find_by_id(&self, id: Uuid) -> Result<RoadmapEntity, AppError> {
+		let item = RoadmapEntity_::find_by_id(id)
+			.filter(RoadmapColumn::IsDeleted.eq(false))
+			.one(self.db.as_ref())
+			.await
+			.map_err(|e| AppError::InternalServerError(e.to_string()))?
+			.ok_or_else(|| AppError::NotFoundError("Roadmap item not found".to_string()))?;
+
+		Ok(to_entity(item))
+	}
+
+	async fn create(&self, entity: RoadmapEntity) -> Result<(), AppError> {
+		let active_model = RoadmapActiveModel {
+			id: ActiveValue::Set(entity.id),
+			title: ActiveValue::Set(entity.title),
+			description: ActiveValue::Set(entity.description),
+			status: ActiveValue::Set(entity.status),
+			votes: ActiveValue::Set(0),
+			is_deleted: ActiveValue::Set(false),
+			created_at: ActiveValue::Set(chrono::Utc::now()),
+			updated_at: ActiveValue::Set(chrono::Utc::now()),
+		};
+
+		RoadmapEntity_::insert(active_model)
+			.exec(self.db.as_ref())
+			.await
+			.map_err(|e| AppError::InternalServerError(e.to_string()))?;
+
+		Ok(())
+	}
+
+	async fn update(&self, entity: RoadmapEntity) -> Result<(), AppError> {
+		let mut active_model: RoadmapActiveModel = RoadmapEntity_::find_by_id(entity.id)
+			.one(self.db.as_ref())
+			.await
+			.map_err(|e| AppError::InternalServerError(e.to_string()))?
+			.ok_or_else(|| AppError::NotFoundError("Roadmap item not found".to_string()))?
+			.into();
+
+		active_model.title = ActiveValue::Set(entity.title);
+		active_model.description = ActiveValue::Set(entity.description);
+		active_model.status = ActiveValue::Set(entity.status);
+		active_model.updated_at = ActiveValue::Set(chrono::Utc::now());
+
+		active_model
+			.update(self.db.as_ref())
+			.await
+			.map_err(|e| AppError::InternalServerError(e.to_string()))?;
+		Ok(())
+	}
+
+	async fn delete(&self, id: Uuid) -> Result<(), AppError> {
+		let mut active_model: RoadmapActiveModel = RoadmapEntity_::find_by_id(id)
+			.one(self.db.as_ref())
+			.await
+			.map_err(|e| AppError::InternalServerError(e.to_string()))?
+			.ok_or_else(|| AppError::NotFoundError("Roadmap item not found".to_string()))?
+			.into();
+
+		active_model.is_deleted = ActiveValue::Set(true);
+		active_model.updated_at = ActiveValue::Set(chrono::Utc::now());
+		active_model
+			.update(self.db.as_ref())
+			.await
+			.map_err(|e| AppError::InternalServerError(e.to_string()))?;
+		Ok(())
+	}
+
+	async fn increment_votes(&self, id: Uuid) -> Result<(), AppError> {
+		let item = RoadmapEntity_::find_by_id(id)
+			.filter(RoadmapColumn::IsDeleted.eq(false))
+			.one(self.db.as_ref())
+			.await
+			.map_err(|e| AppError::InternalServerError(e.to_string()))?
+			.ok_or_else(|| AppError::NotFoundError("Roadmap item not found".to_string()))?;
+
+		let new_votes = item.votes + 1;
+		let mut active_model: RoadmapActiveModel = item.into();
+		active_model.votes = ActiveValue::Set(new_votes);
+		active_model.updated_at = ActiveValue::Set(chrono::Utc::now());
+		active_model
+			.update(self.db.as_ref())
+			.await
+			.map_err(|e| AppError::InternalServerError(e.to_string()))?;
+		Ok(())
+	}
+}