refactor: update surrealdb client usage to support 'any' engine type

crud testi: acc banh

.github/workflows/deploy-to-ancikri.yml

@@ -0,0 +1,65 @@
+name: Deploy to Ancikri
+
+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_ANCIKRI_IP }}
+          username: ${{ secrets.VPS_ANCIKRI_USER }}
+          key: ${{ secrets.VPS_ANCIKRI_SSH_KEY }}
+          port: ${{ secrets.VPS_ANCIKRI_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_ANCIKRI_IP }}
+          username: ${{ secrets.VPS_ANCIKRI_USER }}
+          key: ${{ secrets.VPS_ANCIKRI_SSH_KEY }}
+          port: ${{ secrets.VPS_ANCIKRI_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_ANCIKRI_IP }}
+          username: ${{ secrets.VPS_ANCIKRI_USER }}
+          key: ${{ secrets.VPS_ANCIKRI_SSH_KEY }}
+          port: ${{ secrets.VPS_ANCIKRI_PORT }}
+          script: |
+            set -e
+
+            echo "Restarting the service"
+
+            sudo systemctl daemon-reload
+
+            sudo systemctl restart imphnen-backend-service
+
+            echo "Deployment completed successfully"

Cargo.lock

@@ -1091,6 +1091,12 @@ dependencies = [
  "urlencoding",
 ]
 
+[[package]]
+name = "dotenvy"
+version = "0.15.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1aaf95b3e5c8f23aa320147307562d361db0ae0d51242340f558153b4eb2439b"
+
 [[package]]
 name = "double-ended-peekable"
 version = "0.1.0"
@@ -1927,6 +1933,7 @@ dependencies = [
  "axum-test",
  "chrono",
  "env_logger",
+ "imphnen-cms",
  "imphnen-entities",
  "imphnen-gateway",
  "imphnen-iam",
@@ -1954,6 +1961,7 @@ dependencies = [
  "axum-test",
  "chrono",
  "imphnen-entities",
+ "imphnen-iam",
  "imphnen-libs",
  "imphnen-utils",
  "lazy_static",
@@ -2038,6 +2046,7 @@ dependencies = [
  "axum",
  "axum-test",
  "chrono",
+ "imphnen-cms",
  "imphnen-entities",
  "imphnen-gacha",
  "imphnen-iam",
@@ -2088,6 +2097,7 @@ dependencies = [
  "argon2",
  "axum",
  "chrono",
+ "dotenvy",
  "imphnen-entities",
  "jsonwebtoken",
  "lettre",

Cargo.toml

@@ -41,7 +41,7 @@ fancy-regex = "0.14.0"
 futures = "0.3.31"
 tower = "0.5.2"
 env_logger = "0.11.8"
-
+dotenvy = "0.15.7"
 [profile.release]
 lto = "fat"
 codegen-units = 1

Dockerfile

@@ -1,22 +1,47 @@
-FROM rust:1.83-slim-bullseye AS builder
+FROM rust:1.85-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-entities/src imphnen-gacha/src imphnen-gateway/src \
+    imphnen-iam/src imphnen-libs/src imphnen-middleware/src \
+    imphnen-utils/src tests/src && \
+    echo "fn main() {}" > imphnen-backend/src/main.rs && \
+    find . -name "src" -type d -exec sh -c 'echo "// dummy" > "$1/lib.rs"' _ {} \;
 
-FROM gcr.io/distroless/cc AS runner
+RUN echo '[package]\nname = "tests"\nversion = "0.1.0"\nedition = "2021"' > tests/Cargo.toml
 
-WORKDIR /app
 
-COPY --from=builder /app/target/release/imphnen-backend-service .
+RUN echo -e '[package]\nname = "tests"\nversion = "0.1.0"\nedition = "2021"' > tests/Cargo.toml
 
-CMD ["/app/imphnen-backend-service"]
+
+COPY imphnen-backend ./imphnen-backend
+COPY imphnen-cms ./imphnen-cms
+COPY imphnen-dimentorin ./imphnen-dimentorin
+COPY imphnen-entities ./imphnen-entities
+COPY imphnen-gacha ./imphnen-gacha
+COPY imphnen-gateway ./imphnen-gateway
+COPY imphnen-iam ./imphnen-iam
+COPY imphnen-libs ./imphnen-libs
+COPY imphnen-middleware ./imphnen-middleware
+COPY imphnen-utils ./imphnen-utils
+COPY tests ./tests
+
+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
+
+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

@@ -6,12 +6,13 @@
 
 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.
+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
 
@@ -39,7 +40,7 @@ This repository serves as the **monorepo** for all backend services of IMPHNEN.
      if you use unix based system
 
      ```sh
-     sh apply-env.sh
+     source ./apply-env.sh
      ```
 
    - Modify the `.env` files with your specific configuration settings.
@@ -49,7 +50,15 @@ This repository serves as the **monorepo** for all backend services of IMPHNEN.
    Ensure you have [Rust](https://www.rust-lang.org/) installed. Then, run:
 
    ```sh
-   cargo build
+   cargo fetch
+   ```
+
+4. **Run the seeders**:
+
+   to run the seeders, run:
+
+   ```sh
+   cargo run --bin seeder
    ```
 
 ## How to Run
@@ -64,10 +73,16 @@ To run the services in development mode:
    docker-compose up -d
    ```
 
-2. **Run the desired service**. For example, to run the Core Service:
+2. **Run using cargo run**. For example, to run the Core Service:
 
    ```sh
-   cargo run -p imphnen-core-service --bin api
+   cargo run --bin api
+   ```
+
+3. **Run using cargo watch**. For example, to run the Core Service:
+
+   ```sh
+   cargo watch -x "run --bin api"
    ```
 
 ### Production
@@ -77,17 +92,25 @@ For production deployment:
 1. **Build the Docker image**:
 
    ```sh
-   docker build -t imphnen-backend-service .
+   docker build -t imphnen-backend .
    ```
 
 2. **Run the Docker container**:
 
    ```sh
-   docker run -d --env-file .env -p 8080:8080 imphnen-backend-service
+   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.

apply-env.cmd

@@ -0,0 +1,35 @@
+@echo off
+setlocal
+
+:: Cek apakah file .env ada
+if not exist ".env" (
+    echo File .env tidak ditemukan di direktori saat ini.
+    exit /b 1
+)
+
+echo Memuat variabel dari .env...
+
+:: Baca file .env baris per baris
+for /f "tokens=*" %%a in ('type ".env" ^| findstr /v "^$" ^| findstr /v "^#"') do (
+    echo.%%a | findstr "=" >nul && (
+        for /f "tokens=1,2 delims==" %%b in ("%%a") do (
+            set "key=%%b"
+            set "value=%%c"
+            :: Trim whitespace
+            call :trimValue key value
+            echo Set variabel: %%b=%%c
+            setx %%b %%c >nul
+        )
+    )
+)
+
+echo.
+echo Semua variabel telah dimuat.
+endlocal
+goto :eof
+
+:: Fungsi trim (sederhana)
+:trimValue
+set "%1=%[%1]%"
+set "%2=%[%2]%"
+goto :eof

imphnen-backend/Cargo.toml

@@ -9,6 +9,7 @@ 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" }
+imphnen-cms = { version = "0.1.0", path = "../imphnen-cms" }
 axum.workspace = true
 serde.workspace = true
 serde_json.workspace = true

imphnen-backend/src/bin/seed_events.rs

@@ -0,0 +1,93 @@
+use imphnen_cms::v1::landing::events::events_schema::EventsSchema;
+use imphnen_utils::{get_iso_date, Env};
+use std::error::Error;
+use surrealdb::engine::any;
+use surrealdb::{opt::auth::Root, sql::Thing};
+use imphnen_libs::enviroment::load_env;
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn Error>> {
+	load_env();
+	let env = Env::new();
+	let db = any::connect(&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 events = vec![
+		(
+			"e1a2b3c4-5d6e-7f8g-9h0i-1j2k3l4m5n6o",
+			"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",
+		),
+		(
+			"f2b3c4d5-6e7f-8g9h-0i1j-2k3l4m5n6o7p",
+			"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",
+		),
+		(
+			"g3c4d5e6-7f8g-9h0i-1j2k-3l4m5n6o7p8q",
+			"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",
+		),
+		(
+			"h4d5e6f7-8g9h-0i1j-2k3l-4m5n6o7p8q9r",
+			"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",
+		),
+	];
+
+	for (id, name, description, detail_link, price, location, is_online, start_date, end_date) in events {
+		let event = EventsSchema {
+			id: Thing::from(("app_events", id)),
+			name: name.into(),
+			description: description.into(),
+			detail_link: detail_link.into(),
+			price,
+			location,
+			is_online,
+			is_deleted: false,
+			start_date: start_date.into(),
+			end_date: end_date.into(),
+			created_at: get_iso_date(),
+			updated_at: get_iso_date(),
+		};
+
+		db.create::<Option<EventsSchema>>(("app_events", id))
+			.content(event)
+			.await?;
+
+		println!("✅ Inserted event: {} ({})", name, if is_online { "Online" } else { "In-person" });
+	}
+
+	println!("✅ All Events seeded");
+	Ok(())
+}

imphnen-backend/src/bin/seed_permissions.rs

@@ -1,12 +1,17 @@
+use imphnen_iam::PermissionsEnum;
+use imphnen_libs::enviroment::load_env;
 use imphnen_utils::{get_iso_date, Env};
 use serde_json::json;
 use std::error::Error;
-use surrealdb::{engine::remote::ws::Ws, opt::auth::Root, Surreal};
+use surrealdb::engine::any;
+use surrealdb::opt::auth::Root;
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn Error>> {
+	load_env();
+
 	let env = Env::new();
-	let db = Surreal::new::<Ws>(env.surrealdb_url).await?;
+	let db = any::connect(&env.surrealdb_url).await?;
 	db.signin(Root {
 		username: &env.surrealdb_username,
 		password: &env.surrealdb_password,
@@ -15,131 +20,50 @@ async fn main() -> Result<(), Box<dyn Error>> {
 	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 {
+
+	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,
+	] {
 		db.query("CREATE type::thing('app_permissions', $id) CONTENT $data")
-			.bind(("id", id))
+			.bind(("id", permission.id()))
 			.bind((
 				"data",
 				json!({
-						"name": name,
-						"is_deleted": false,
-						"created_at": get_iso_date(),
-						"updated_at": get_iso_date()
+					"name": permission.to_string(),
+					"is_deleted": false,
+					"created_at": get_iso_date(),
+					"updated_at": get_iso_date()
 				}),
 			))
 			.await?;
-		println!("✅ Inserted: {}", name);
+		println!("✅ Inserted: {}", permission.to_string());
 	}
+
 	println!("✅ All Permissions seeded");
 	Ok(())
 }

imphnen-backend/src/bin/seed_roles.rs

@@ -1,12 +1,14 @@
 use imphnen_utils::{get_iso_date, Env};
 use serde_json::json;
 use std::error::Error;
-use surrealdb::{engine::remote::ws::Ws, opt::auth::Root, Surreal};
-
+use surrealdb::opt::auth::Root;
+use imphnen_libs::enviroment::load_env;
+use surrealdb::engine::any;
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn Error>> {
+	load_env();
 	let env = Env::new();
-	let db = Surreal::new::<Ws>(env.surrealdb_url).await?;
+	let db = any::connect(&env.surrealdb_url).await?;
 	db.signin(Root {
 		username: &env.surrealdb_username,
 		password: &env.surrealdb_password,

imphnen-backend/src/bin/seed_roles_permissions.rs

@@ -1,57 +1,58 @@
-use imphnen_iam::{get_iso_date, make_thing, Env};
+use imphnen_iam::{get_iso_date, make_thing, Env, PermissionsEnum};
 use std::error::Error;
-use surrealdb::{engine::remote::ws::Ws, opt::auth::Root, Surreal};
-
+use surrealdb::opt::auth::Root;
+use surrealdb::engine::any;
+use imphnen_libs::enviroment::load_env;
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn Error>> {
+	load_env();
 	let env = Env::new();
-	let db = Surreal::new::<Ws>(env.surrealdb_url).await?;
-
+	let db = any::connect(&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 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 permission_refs_admin: Vec<_> = [
+		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,
+	]
+	.iter()
+	.map(|perm| make_thing("app_permissions", perm.id()))
+	.collect();
 	let admin_role_id = "f6b03f25-e416-4893-ac88-caaa690afb07";
-
-	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");
-
+	println!("✅ All permissions successfully added to Admin role");
 	Ok(())
 }

imphnen-backend/src/bin/seed_users.rs

@@ -1,12 +1,14 @@
 use imphnen_iam::UsersSchema;
+use imphnen_libs::enviroment::load_env;
 use imphnen_utils::{get_iso_date, hash_password, Env};
 use std::error::Error;
-use surrealdb::{engine::remote::ws::Ws, opt::auth::Root, sql::Thing, Surreal};
-
+use surrealdb::{opt::auth::Root, sql::Thing};
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn Error>> {
+	load_env();
 	let env = Env::new();
-	let db = Surreal::new::<Ws>(env.surrealdb_url).await?;
+	use surrealdb::engine::any;
+	let db = any::connect(&env.surrealdb_url).await?;
 	db.signin(Root {
 		username: &env.surrealdb_username,
 		password: &env.surrealdb_password,

imphnen-backend/src/bin/seeder.rs

@@ -0,0 +1,26 @@
+use std::error::Error;
+use std::process::Command;
+
+fn run_seed(bin: &str) -> Result<(), Box<dyn Error>> {
+	println!("🔧 Seeding: {bin}");
+	let status = Command::new("cargo").args(["run", "--bin", 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")?;
+
+	println!("\n✅ All seeding completed successfully.");
+	Ok(())
+}

imphnen-cms/Cargo.toml

@@ -4,6 +4,7 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
+imphnen-iam = { version = "0.1.0", path = "../imphnen-iam" }
 imphnen-libs = { version = "0.1.0", path = "../imphnen-libs" }
 imphnen-utils = { version = "0.1.0", path = "../imphnen-utils" }
 imphnen-entities = { version = "0.1.0", path = "../imphnen-entities" }

imphnen-cms/src/lib.rs

@@ -1,14 +1,2 @@
-pub fn add(left: u64, right: u64) -> u64 {
-	left + right
-}
-
-#[cfg(test)]
-mod tests {
-	use super::*;
-
-	#[test]
-	fn it_works() {
-		let result = add(2, 2);
-		assert_eq!(result, 4);
-	}
-}
+pub mod v1;
+pub use v1::*;

imphnen-cms/src/v1/landing/events/events_controller.rs

@@ -0,0 +1,119 @@
+use super::{
+	events_dto::{
+		EventsCreateRequestDto, EventsDetailItemDto, EventsListItemDto,
+		EventsUpdateRequestDto,
+	},
+	events_service::EventsService,
+};
+use axum::extract::{Path, Query};
+use axum::response::IntoResponse;
+use axum::{Extension, Json};
+use imphnen_libs::{
+	AppState, MessageResponseDto, MetaRequestDto, ResponseListSuccessDto,
+	ResponseSuccessDto,
+};
+
+#[utoipa::path(
+    get,
+    path = "/v1/cms/landing/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"),
+        ("filter" = Option<String>, Query, description = "Filter value"),
+        ("filter_by" = Option<String>, Query, description = "Field to filter by"),
+    ),
+    responses(
+        (status = 200, description = "Get event list", body = ResponseListSuccessDto<Vec<EventsListItemDto>>)
+    ),
+    tag = "Events"
+)]
+pub async fn get_event_list(
+	Extension(state): Extension<AppState>,
+	Query(meta): Query<MetaRequestDto>,
+) -> impl IntoResponse {
+	EventsService::get_event_list(&state, meta).await
+}
+
+#[utoipa::path(
+    get,
+    path = "/v1/cms/landing/events/detail/{id}",
+    params(
+        ("id" = String, Path, description = "Event ID")
+    ),
+    responses(
+        (status = 200, description = "Get event by ID", body = ResponseSuccessDto<EventsDetailItemDto>)
+    ),
+    tag = "Events"
+)]
+pub async fn get_event_by_id(
+	Extension(state): Extension<AppState>,
+	Path(id): Path<String>,
+) -> impl IntoResponse {
+	EventsService::get_event_by_id(&state, id).await
+}
+
+#[utoipa::path(
+    post,
+    security(
+        ("Bearer" = [])
+    ),
+    path = "/v1/cms/landing/events/create",
+    request_body = EventsCreateRequestDto,
+    responses(
+        (status = 201, description = "Create new event", body = MessageResponseDto)
+    ),
+    tag = "Events"
+)]
+pub async fn post_create_event(
+	Extension(state): Extension<AppState>,
+	Json(payload): Json<EventsCreateRequestDto>,
+) -> impl IntoResponse {
+	EventsService::create_event(&state, payload).await
+}
+
+#[utoipa::path(
+    patch,
+    security(
+        ("Bearer" = [])
+    ),
+    path = "/v1/cms/landing/events/update/{id}",
+    params(
+        ("id" = String, Path, description = "Event ID")
+    ),
+    request_body = EventsUpdateRequestDto,
+    responses(
+        (status = 200, description = "Update event", body = MessageResponseDto)
+    ),
+    tag = "Events"
+)]
+pub async fn patch_update_event(
+	Extension(state): Extension<AppState>,
+	Path(id): Path<String>,
+	Json(payload): Json<EventsUpdateRequestDto>,
+) -> impl IntoResponse {
+	EventsService::update_event(&state, id, payload).await
+}
+
+#[utoipa::path(
+    delete,
+    security(
+        ("Bearer" = [])
+    ),
+    path = "/v1/cms/landing/events/delete/{id}",
+    params(
+        ("id" = String, Path, description = "Event ID")
+    ),
+    responses(
+        (status = 200, description = "Soft delete event", body = MessageResponseDto)
+    ),
+    tag = "Events"
+)]
+pub async fn delete_event(
+	Extension(state): Extension<AppState>,
+	Path(id): Path<String>,
+) -> impl IntoResponse {
+	EventsService::delete_event(&state, id).await
+}

imphnen-cms/src/v1/landing/events/events_dto.rs

@@ -0,0 +1,121 @@
+use chrono::{DateTime, Utc};
+use lazy_static::lazy_static;
+use regex::Regex;
+use serde::{Deserialize, Serialize};
+use surrealdb::sql::Thing;
+use utoipa::ToSchema;
+use validator::Validate;
+
+// Lazy static regex for URL validation
+lazy_static! {
+	static ref VALID_URL_REGEX: Regex = Regex::new(r"^https?://").unwrap();
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, ToSchema, Validate)]
+pub struct EventsCreateRequestDto {
+	#[validate(length(min = 1, message = "Name is required"))]
+	pub name: String,
+
+	#[validate(length(min = 1, message = "Description is required"))]
+	pub description: String,
+
+	#[validate(regex(
+		path = "VALID_URL_REGEX",
+		message = "Detail link must be a valid URL"
+	))]
+	pub detail_link: String,
+
+	#[validate(range(min = 0, message = "Price cannot be negative"))]
+	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,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, ToSchema, Validate)]
+pub struct EventsUpdateRequestDto {
+	#[validate(length(min = 1, message = "Name is required"))]
+	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>,
+}
+
+#[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,
+}
+
+#[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>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct EventsQueryDto {
+	pub id: Thing,
+	pub name: String,
+	pub description: String,
+	pub detail_link: String,
+	pub price: f64,
+	pub is_online: bool,
+	pub is_deleted: bool,
+	pub start_date: String,
+	pub end_date: String,
+	pub created_at: String,
+	pub updated_at: String,
+	pub location: Option<String>,
+}
+
+impl EventsQueryDto {
+	pub fn from(self) -> EventsListItemDto {
+		EventsListItemDto {
+			id: self.id.id.to_raw(),
+			name: self.name,
+			description: self.description,
+			detail_link: self.detail_link,
+			price: self.price,
+			location: self.location,
+			is_online: self.is_online,
+			start_date: self.start_date,
+			end_date: self.end_date,
+			created_at: self.created_at,
+			is_deleted: self.is_deleted,
+		}
+	}
+}

imphnen-cms/src/v1/landing/events/events_repository.rs

@@ -0,0 +1,113 @@
+use super::{events_dto::EventsQueryDto, events_schema::EventsSchema};
+use anyhow::{Result, bail};
+use imphnen_libs::{AppState, MetaRequestDto, ResourceEnum, ResponseListSuccessDto};
+use imphnen_utils::{DetailQueryBuilder, ListQueryBuilder, get_id, get_iso_date};
+
+pub struct EventsRepository<'a> {
+	state: &'a AppState,
+}
+
+impl<'a> EventsRepository<'a> {
+	pub fn new(state: &'a AppState) -> Self {
+		Self { state }
+	}
+
+	pub async fn query_event_list(
+		&self,
+		meta: MetaRequestDto,
+	) -> Result<ResponseListSuccessDto<Vec<EventsQueryDto>>> {
+		let query = ListQueryBuilder::new(&ResourceEnum::Events.to_string())
+			.with_select_fields(vec!["*"])
+			.with_pagination(meta.page, Some(10))
+			.with_sorting(meta.sort_by.as_deref(), meta.order.as_deref())
+			.build();
+		let res: Vec<EventsQueryDto> =
+			self.state.surrealdb_ws.query(query).await?.take(0)?;
+		let data = ResponseListSuccessDto {
+			data: res,
+			meta: None,
+		};
+		Ok(data)
+	}
+
+	// Get event by ID
+	pub async fn query_event_by_id(&self, id: String) -> Result<EventsQueryDto> {
+		let db = &self.state.surrealdb_ws;
+		let builder = DetailQueryBuilder::new(ResourceEnum::Events.to_string())
+			.with_id(&id)
+			.with_select_fields(vec!["*"]);
+		let sql = builder.build();
+		let result: Option<EventsQueryDto> =
+			builder.apply_bindings(db.query(sql)).await?.take(0)?;
+
+		match result {
+			Some(event) => {
+				if event.is_deleted {
+					bail!("Event not found");
+				}
+				Ok(event)
+			}
+			None => bail!("Event not found"),
+		}
+	}
+
+	// Create new event
+	pub async fn query_create_event(&self, data: EventsSchema) -> Result<String> {
+		let db = &self.state.surrealdb_ws;
+		let record: Option<EventsSchema> = db
+			.create(ResourceEnum::Events.to_string())
+			.content(data)
+			.await?;
+
+		match record {
+			Some(_) => Ok("Success create event".into()),
+			None => bail!("Failed to create event"),
+		}
+	}
+
+	// Update existing event
+	pub async fn query_update_event(&self, data: EventsSchema) -> Result<String> {
+		let db = &self.state.surrealdb_ws;
+
+		// Cek apakah event ada
+		let existing = self.query_event_by_id(data.id.id.to_raw()).await?;
+		if existing.is_deleted {
+			bail!("Event already deleted");
+		}
+
+		// Merge field tertentu jika diperlukan
+		let merged = EventsSchema {
+			created_at: existing.created_at,
+			updated_at: get_iso_date(),
+			..data
+		};
+
+		let record_key = get_id(&merged.id)?;
+		let record: Option<EventsSchema> = db.update(record_key).merge(merged).await?;
+
+		match record {
+			Some(_) => Ok("Success update event".into()),
+			None => bail!("Failed to update event"),
+		}
+	}
+
+	// Soft delete event (mark is_deleted = true)
+	pub async fn query_delete_event(&self, id: String) -> Result<String> {
+		let db = &self.state.surrealdb_ws;
+		let event = self.query_event_by_id(id).await?;
+		if event.is_deleted {
+			bail!("Event not found");
+		}
+
+		let record_key = get_id(&event.id)?;
+		let record: Option<EventsSchema> = db
+			.update(record_key)
+			.merge(serde_json::json!({ "is_deleted": true }))
+			.await?;
+
+		match record {
+			Some(_) => Ok("Success delete event".into()),
+			None => bail!("Failed to delete event"),
+		}
+	}
+}

imphnen-cms/src/v1/landing/events/events_schema.rs

@@ -0,0 +1,100 @@
+use imphnen_libs::ResourceEnum;
+use surrealdb::Uuid;
+use surrealdb::sql::Thing;
+use serde::{Deserialize, Serialize};
+use imphnen_utils::{get_iso_date, make_thing};
+
+use super::events_dto::{EventsCreateRequestDto, EventsQueryDto, EventsUpdateRequestDto};
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct EventsSchema {
+	pub id: Thing,
+	pub price: f64,
+	pub is_online: bool,
+	pub is_deleted: bool,
+	pub name: String,
+	pub end_date: String,
+	pub start_date: String,
+	pub created_at: String,
+	pub updated_at: String,
+	pub description: String,
+	pub detail_link: String,
+	pub location: Option<String>,
+}
+
+impl Default for EventsSchema {
+	fn default() -> Self {
+		Self {
+			id: make_thing(
+				&ResourceEnum::Events.to_string(),
+				&Uuid::new_v4().to_string(),
+			),
+			name: String::new(),
+			description: String::new(),
+			detail_link: String::new(),
+			price: 0.0,
+			location: None,
+			is_online: false,
+			is_deleted: false,
+			start_date: String::new(),
+			end_date: String::new(),
+			created_at: get_iso_date(),
+			updated_at: get_iso_date(),
+		}
+	}
+}
+
+impl EventsSchema {
+	pub fn from(dto: EventsQueryDto) -> Self {
+		Self {
+			id: dto.id,
+			name: dto.name,
+			description: dto.description,
+			detail_link: dto.detail_link,
+			price: dto.price,
+			location: dto.location,
+			is_online: dto.is_online,
+			is_deleted: false,
+			start_date: dto.start_date,
+			end_date: dto.end_date,
+			created_at: dto.created_at,
+			updated_at: dto.updated_at,
+		}
+	}
+
+	pub fn create(payload: EventsCreateRequestDto) -> Self {
+		Self {
+			id: make_thing(
+				&ResourceEnum::Events.to_string(),
+				&Uuid::new_v4().to_string(),
+			),
+			name: payload.name,
+			description: payload.description,
+			detail_link: payload.detail_link,
+			price: payload.price,
+			location: payload.location,
+			is_online: payload.is_online,
+			is_deleted: false,
+			end_date: payload.end_date.to_string(),
+			start_date: payload.start_date.to_string(),
+			created_at: get_iso_date(),
+			updated_at: get_iso_date(),
+		}
+	}
+
+	pub fn update(payload: EventsUpdateRequestDto, id: String) -> Self {
+		Self {
+			id: make_thing(&ResourceEnum::Events.to_string(), &id),
+			name: payload.name,
+			price: payload.price,
+			location: payload.location,
+			is_online: payload.is_online,
+			description: payload.description,
+			detail_link: payload.detail_link,
+			end_date: payload.end_date.to_string(),
+			start_date: payload.start_date.to_string(),
+			updated_at: get_iso_date(),
+			..Default::default()
+		}
+	}
+}

imphnen-cms/src/v1/landing/events/events_service.rs

@@ -0,0 +1,86 @@
+use super::{
+    events_dto::{EventsCreateRequestDto, EventsDetailItemDto, EventsListItemDto, EventsQueryDto, EventsUpdateRequestDto},
+    events_repository::EventsRepository,
+    events_schema::EventsSchema,
+};
+use imphnen_libs::{AppState, MetaRequestDto, ResponseListSuccessDto, ResponseSuccessDto};
+use imphnen_utils::{common_response, success_list_response, success_response, validate_request};
+use axum::{http::StatusCode, response::Response};
+
+pub struct EventsService;
+
+impl EventsService {
+    pub async fn get_event_list(state: &AppState, meta: MetaRequestDto) -> Response {
+        let repo = EventsRepository::new(state);
+        match repo.query_event_list(meta).await {
+            Ok(data) => {
+                let items: Vec<EventsListItemDto> = data.data
+                    .into_iter()
+                    .filter(|e| !e.is_deleted)
+                    .map(EventsQueryDto::from)
+                    .collect();
+                let response = ResponseListSuccessDto {
+                    data: items,
+                    meta: data.meta,
+                };
+                success_list_response(response)
+            }
+            Err(e) => common_response(StatusCode::BAD_REQUEST, &e.to_string()),
+        }
+    }
+
+    pub async fn get_event_by_id(state: &AppState, id: String) -> Response {
+        let repo = EventsRepository::new(state);
+        match repo.query_event_by_id(id).await {
+            Ok(event) if !event.is_deleted => success_response(ResponseSuccessDto {
+                data: EventsDetailItemDto {
+                    id: event.id.id.to_raw(),
+                    name: event.name,
+                    description: event.description,
+                    detail_link: event.detail_link,
+                    price: event.price,
+                    is_online: event.is_online,
+                    start_date: event.start_date,
+                    end_date: event.end_date,
+                    created_at: event.created_at,
+                    updated_at: event.updated_at,
+                    location: event.location,
+                },
+            }),
+            Ok(_) => common_response(StatusCode::NOT_FOUND, "Event not found"),
+            Err(e) => common_response(StatusCode::NOT_FOUND, &e.to_string()),
+        }
+    }
+
+    pub async fn create_event(state: &AppState, payload: EventsCreateRequestDto) -> Response {
+        if let Err((status, message)) = validate_request(&payload) {
+            return common_response(status, &message);
+        }
+        let repo = EventsRepository::new(state);
+        let schema = EventsSchema::create(payload);
+        match repo.query_create_event(schema).await {
+            Ok(msg) => common_response(StatusCode::CREATED, &msg),
+            Err(e) => common_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
+        }
+    }
+
+    pub async fn update_event(state: &AppState, id: String, payload: EventsUpdateRequestDto) -> Response {
+        if let Err((status, message)) = validate_request(&payload) {
+            return common_response(status, &message);
+        }
+        let repo = EventsRepository::new(state);
+        let schema = EventsSchema::update(payload, id);
+        match repo.query_update_event(schema).await {
+            Ok(msg) => common_response(StatusCode::OK, &msg),
+            Err(e) => common_response(StatusCode::BAD_REQUEST, &e.to_string()),
+        }
+    }
+
+    pub async fn delete_event(state: &AppState, id: String) -> Response {
+        let repo = EventsRepository::new(state);
+        match repo.query_delete_event(id).await {
+            Ok(msg) => common_response(StatusCode::OK, &msg),
+            Err(e) => common_response(StatusCode::BAD_REQUEST, &e.to_string()),
+        }
+    }
+}

imphnen-cms/src/v1/landing/events/mod.rs

@@ -0,0 +1,44 @@
+use axum::{
+	Router,
+	routing::{delete, get, patch, post},
+};
+
+pub mod events_controller;
+pub mod events_dto;
+pub mod events_repository;
+pub mod events_schema;
+pub mod events_service;
+
+pub use events_controller::*;
+pub use events_dto::*;
+pub use events_repository::*;
+pub use events_schema::*;
+pub use events_service::*;
+
+pub fn events_public_routes() -> Router {
+	Router::new()
+		.route(
+			"/cms/landing/events",
+			get(events_controller::get_event_list),
+		)
+		.route(
+			"/cms/landing/events/detail/{id}",
+			get(events_controller::get_event_by_id),
+		)
+}
+
+pub fn events_protected_routes() -> Router {
+	Router::new()
+		.route(
+			"/cms/landing/events/create",
+			post(events_controller::post_create_event),
+		)
+		.route(
+			"/cms/landing/events/update/{id}",
+			patch(events_controller::patch_update_event),
+		)
+		.route(
+			"/cms/landing/events/delete/{id}",
+			delete(events_controller::delete_event),
+		)
+}

imphnen-cms/src/v1/landing/mod.rs

@@ -0,0 +1,5 @@
+pub mod events;
+pub mod testimonials;
+
+pub use events::*;
+pub use testimonials::*;

imphnen-cms/src/v1/landing/testimonials/mod.rs

@@ -0,0 +1,44 @@
+use axum::{
+	Router,
+	routing::{delete, get, patch, post},
+};
+
+pub mod testimonials_controller;
+pub mod testimonials_dto;
+pub mod testimonials_repository;
+pub mod testimonials_schema;
+pub mod testimonials_service;
+
+pub use testimonials_controller::*;
+pub use testimonials_dto::*;
+pub use testimonials_repository::*;
+pub use testimonials_schema::*;
+pub use testimonials_service::*;
+
+pub fn testimonials_public_routes() -> Router {
+	Router::new()
+		.route(
+			"/cms/landing/testimonials",
+			get(testimonials_controller::get_testimonial_list),
+		)
+		.route(
+			"/cms/landing/testimonials/detail/{id}",
+			get(testimonials_controller::get_testimonial_by_id),
+		)
+}
+
+pub fn testimonials_protected_routes() -> Router {
+	Router::new()
+		.route(
+			"/cms/landing/testimonials/create",
+			post(testimonials_controller::post_create_testimonial),
+		)
+		.route(
+			"/cms/landing/testimonials/update/{id}",
+			patch(testimonials_controller::patch_update_testimonial),
+		)
+		.route(
+			"/cms/landing/testimonials/delete/{id}",
+			delete(testimonials_controller::delete_testimonial),
+		)
+}

imphnen-cms/src/v1/landing/testimonials/testimonials_controller.rs

@@ -0,0 +1,125 @@
+use super::{
+	testimonials_dto::{
+		TestimonialsCreateRequestDto, TestimonialsDetailItemDto,
+		TestimonialsListItemDto, TestimonialsUpdateRequestDto,
+	},
+	testimonials_service::TestimonialsService,
+};
+use axum::extract::{Path, Query};
+use axum::response::IntoResponse;
+use axum::{Extension, Json};
+use imphnen_iam::UsersDetailQueryDto;
+use imphnen_libs::{
+	AppState, MessageResponseDto, MetaRequestDto, ResponseListSuccessDto,
+	ResponseSuccessDto,
+};
+
+#[utoipa::path(
+    get,
+    path = "/v1/cms/landing/testimonials",
+    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"),
+        ("filter" = Option<String>, Query, description = "Filter value"),
+        ("filter_by" = Option<String>, Query, description = "Field to filter by"),
+    ),
+    responses(
+        (status = 200, description = "Get testimonial list", body = ResponseListSuccessDto<Vec<TestimonialsListItemDto>>)
+    ),
+    tag = "Testimonials"
+)]
+pub async fn get_testimonial_list(
+	Extension(state): Extension<AppState>,
+	Query(meta): Query<MetaRequestDto>,
+) -> impl IntoResponse {
+	TestimonialsService::get_testimonial_list(&state, meta).await
+}
+
+#[utoipa::path(
+    get,
+    path = "/v1/cms/landing/testimonials/detail/{id}",
+    params(
+        ("id" = String, Path, description = "Testimonial ID")
+    ),
+    responses(
+        (status = 200, description = "Get testimonial by ID", body = ResponseSuccessDto<TestimonialsDetailItemDto>)
+    ),
+    tag = "Testimonials"
+)]
+pub async fn get_testimonial_by_id(
+	Extension(state): Extension<AppState>,
+	Path(id): Path<String>,
+) -> impl IntoResponse {
+	TestimonialsService::get_testimonial_by_id(&state, id).await
+}
+
+#[utoipa::path(
+    post,
+    security(
+        ("Bearer" = [])
+    ),
+    path = "/v1/cms/landing/testimonials/create",
+    request_body = TestimonialsCreateRequestDto,
+    responses(
+        (status = 201, description = "Create new testimonial", body = MessageResponseDto)
+    ),
+    tag = "Testimonials"
+)]
+pub async fn post_create_testimonial(
+	Extension(state): Extension<AppState>,
+	Extension(authenticated_user): Extension<UsersDetailQueryDto>,
+	Json(payload): Json<TestimonialsCreateRequestDto>,
+) -> impl IntoResponse {
+	println!("Authenticated User Now: {:?}", authenticated_user);
+	TestimonialsService::create_testimonial(&state, payload, &authenticated_user).await
+}
+
+#[utoipa::path(
+    patch,
+    security(
+        ("Bearer" = [])
+    ),
+    path = "/v1/cms/landing/testimonials/update/{id}",
+    params(
+        ("id" = String, Path, description = "Testimonial ID")
+    ),
+    request_body = TestimonialsUpdateRequestDto,
+    responses(
+        (status = 200, description = "Update testimonial", body = MessageResponseDto)
+    ),
+    tag = "Testimonials"
+)]
+pub async fn patch_update_testimonial(
+	Path(id): Path<String>,
+	Extension(state): Extension<AppState>,
+	Extension(authenticated_user): Extension<UsersDetailQueryDto>,
+	Json(payload): Json<TestimonialsUpdateRequestDto>,
+) -> impl IntoResponse {
+	TestimonialsService::update_testimonial(&state, id, payload, &authenticated_user)
+		.await
+}
+
+#[utoipa::path(
+    delete,
+    security(
+        ("Bearer" = [])
+    ),
+    path = "/v1/cms/landing/testimonials/delete/{id}",
+    params(
+        ("id" = String, Path, description = "Testimonial ID")
+    ),
+    responses(
+        (status = 200, description = "Soft delete testimonial", body = MessageResponseDto)
+    ),
+    tag = "Testimonials"
+)]
+pub async fn delete_testimonial(
+	Extension(state): Extension<AppState>,
+	Extension(authenticated_user): Extension<UsersDetailQueryDto>,
+	Path(id): Path<String>,
+) -> impl IntoResponse {
+	TestimonialsService::delete_testimonial(&state, id, &authenticated_user).await
+}

imphnen-cms/src/v1/landing/testimonials/testimonials_dto.rs

@@ -0,0 +1,78 @@
+use imphnen_iam::users::UsersSchema;
+use serde::{Deserialize, Serialize};
+use surrealdb::sql::Thing;
+use utoipa::ToSchema;
+use validator::Validate;
+
+#[derive(Clone, Debug, Serialize, Deserialize, ToSchema, Validate)]
+pub struct TestimonialsCreateRequestDto {
+	#[validate(length(min = 1, message = "Role is required"))]
+	pub role: String,
+
+	#[validate(length(
+		min = 1,
+		max = 500,
+		message = "Content must be between 1 and 500 characters"
+	))]
+	pub content: String,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, ToSchema, Validate)]
+pub struct TestimonialsUpdateRequestDto {
+	#[validate(length(min = 1, message = "Role is required"))]
+	pub role: String,
+
+	#[validate(length(
+		min = 1,
+		max = 500,
+		message = "Content must be between 1 and 500 characters"
+	))]
+	pub content: String,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, ToSchema)]
+pub struct TestimonialsListItemDto {
+	pub id: String,
+	pub user_id: String,
+	pub user_fullname: String, // Assuming we'll fetch user's full name
+	pub role: String,
+	pub content: String,
+	pub created_at: String,
+	pub is_deleted: bool,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, ToSchema)]
+pub struct TestimonialsDetailItemDto {
+	pub id: String,
+	pub user_id: String,
+	pub user_fullname: String, // Assuming we'll fetch user's full name
+	pub role: String,
+	pub content: String,
+	pub created_at: String,
+	pub updated_at: String,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct TestimonialsQueryDto {
+	pub id: Thing,
+	pub user: UsersSchema, // Change from Thing to UsersSchema
+	pub role: String,
+	pub content: String,
+	pub is_deleted: bool,
+	pub created_at: String,
+	pub updated_at: String,
+}
+
+impl TestimonialsQueryDto {
+	pub fn from(self) -> TestimonialsListItemDto {
+		TestimonialsListItemDto {
+			id: self.id.id.to_raw(),
+			user_id: self.user.id.id.to_raw(),
+			user_fullname: self.user.fullname, // Extract fullname from UsersSchema
+			role: self.role,
+			content: self.content,
+			created_at: self.created_at,
+			is_deleted: self.is_deleted,
+		}
+	}
+}

imphnen-cms/src/v1/landing/testimonials/testimonials_repository.rs

@@ -0,0 +1,120 @@
+use super::{
+	testimonials_dto::TestimonialsQueryDto, testimonials_schema::TestimonialsSchema,
+};
+use anyhow::{Result, bail};
+use imphnen_libs::{AppState, MetaRequestDto, ResourceEnum, ResponseListSuccessDto};
+use imphnen_utils::{DetailQueryBuilder, ListQueryBuilder, get_id, get_iso_date};
+
+pub struct TestimonialsRepository<'a> {
+	state: &'a AppState,
+}
+
+impl<'a> TestimonialsRepository<'a> {
+	pub fn new(state: &'a AppState) -> Self {
+		Self { state }
+	}
+
+	pub async fn query_testimonial_list(
+		&self,
+		meta: MetaRequestDto,
+	) -> Result<ResponseListSuccessDto<Vec<TestimonialsQueryDto>>> {
+		let query = ListQueryBuilder::new(&ResourceEnum::Testimonials.to_string())
+			.with_select_fields(vec!["*", "user.* as user"]) // Select user details
+			.with_pagination(meta.page, Some(10))
+			.with_sorting(meta.sort_by.as_deref(), meta.order.as_deref())
+			.build();
+		let res: Vec<TestimonialsQueryDto> =
+			self.state.surrealdb_ws.query(query).await?.take(0)?;
+		let data = ResponseListSuccessDto {
+			data: res,
+			meta: None,
+		};
+		Ok(data)
+	}
+
+	pub async fn query_testimonial_by_id(
+		&self,
+		id: String,
+	) -> Result<TestimonialsQueryDto> {
+		let db = &self.state.surrealdb_ws;
+		let builder = DetailQueryBuilder::new(ResourceEnum::Testimonials.to_string())
+			.with_id(&id)
+			.with_select_fields(vec!["*", "user.* as user"]); // Select user details
+		let sql = builder.build();
+		let result: Option<TestimonialsQueryDto> =
+			builder.apply_bindings(db.query(sql)).await?.take(0)?;
+
+		match result {
+			Some(testimonial) => {
+				if testimonial.is_deleted {
+					bail!("Testimonial not found");
+				}
+				Ok(testimonial)
+			}
+			None => bail!("Testimonial not found"),
+		}
+	}
+
+	pub async fn query_create_testimonial(
+		&self,
+		data: TestimonialsSchema,
+	) -> Result<String> {
+		let db = &self.state.surrealdb_ws;
+		let record: Option<TestimonialsSchema> = db
+			.create(ResourceEnum::Testimonials.to_string())
+			.content(data)
+			.await?;
+
+		match record {
+			Some(_) => Ok("Success create testimonial".into()),
+			None => bail!("Failed to create testimonial"),
+		}
+	}
+
+	pub async fn query_update_testimonial(
+		&self,
+		data: TestimonialsSchema,
+	) -> Result<String> {
+		let db = &self.state.surrealdb_ws;
+
+		let existing = self.query_testimonial_by_id(data.id.id.to_raw()).await?;
+		if existing.is_deleted {
+			bail!("Testimonial already deleted");
+		}
+
+		let merged = TestimonialsSchema {
+			created_at: existing.created_at,
+			updated_at: get_iso_date(),
+			user: existing.user.id, // Preserve user ID
+			..data
+		};
+
+		let record_key = get_id(&merged.id)?;
+		let record: Option<TestimonialsSchema> =
+			db.update(record_key).merge(merged).await?;
+
+		match record {
+			Some(_) => Ok("Success update testimonial".into()),
+			None => bail!("Failed to update testimonial"),
+		}
+	}
+
+	pub async fn query_delete_testimonial(&self, id: String) -> Result<String> {
+		let db = &self.state.surrealdb_ws;
+		let testimonial = self.query_testimonial_by_id(id).await?;
+		if testimonial.is_deleted {
+			bail!("Testimonial not found");
+		}
+
+		let record_key = get_id(&testimonial.id)?;
+		let record: Option<TestimonialsSchema> = db
+			.update(record_key)
+			.merge(serde_json::json!({ "is_deleted": true }))
+			.await?;
+
+		match record {
+			Some(_) => Ok("Success delete testimonial".into()),
+			None => bail!("Failed to delete testimonial"),
+		}
+	}
+}

imphnen-cms/src/v1/landing/testimonials/testimonials_schema.rs

@@ -0,0 +1,84 @@
+use imphnen_libs::ResourceEnum;
+use imphnen_utils::{get_iso_date, make_thing};
+use serde::{Deserialize, Serialize};
+use surrealdb::Uuid;
+use surrealdb::sql::Thing;
+
+use super::testimonials_dto::{
+	TestimonialsCreateRequestDto, TestimonialsQueryDto, TestimonialsUpdateRequestDto,
+};
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct TestimonialsSchema {
+	pub id: Thing,
+	pub user: Thing, // Link to app_users table
+	pub role: String,
+	pub content: String,
+	pub is_deleted: bool,
+	pub created_at: String,
+	pub updated_at: String,
+}
+
+impl Default for TestimonialsSchema {
+	fn default() -> Self {
+		Self {
+			id: make_thing(
+				&ResourceEnum::Testimonials.to_string(),
+				&Uuid::new_v4().to_string(),
+			),
+			user: make_thing(
+				&ResourceEnum::Users.to_string(),
+				&Uuid::new_v4().to_string(), // Placeholder, will be replaced by actual user ID
+			),
+			role: String::new(),
+			content: String::new(),
+			is_deleted: false,
+			created_at: get_iso_date(),
+			updated_at: get_iso_date(),
+		}
+	}
+}
+
+impl TestimonialsSchema {
+	pub fn from(dto: TestimonialsQueryDto) -> Self {
+		Self {
+			id: dto.id,
+			user: dto.user.id,
+			role: dto.role,
+			content: dto.content,
+			is_deleted: dto.is_deleted,
+			created_at: dto.created_at,
+			updated_at: dto.updated_at,
+		}
+	}
+
+	pub fn create(payload: TestimonialsCreateRequestDto, user_id: &Thing) -> Self {
+		Self {
+			id: make_thing(
+				&ResourceEnum::Testimonials.to_string(),
+				&Uuid::new_v4().to_string(),
+			),
+			user: user_id.clone(),
+			role: payload.role,
+			content: payload.content,
+			is_deleted: false,
+			created_at: get_iso_date(),
+			updated_at: get_iso_date(),
+		}
+	}
+
+	pub fn update(
+		payload: TestimonialsUpdateRequestDto,
+		id: String,
+		user_id: &Thing,
+	) -> Self {
+		Self {
+			id: make_thing(&ResourceEnum::Testimonials.to_string(), &id),
+			role: payload.role,
+			content: payload.content,
+			updated_at: get_iso_date(),
+			user: user_id.clone(),
+			..Default::default()
+		}
+	}
+}

imphnen-cms/src/v1/landing/testimonials/testimonials_service.rs

@@ -0,0 +1,108 @@
+use super::{
+	testimonials_dto::{
+		TestimonialsCreateRequestDto, TestimonialsDetailItemDto,
+		TestimonialsListItemDto, TestimonialsUpdateRequestDto,
+	},
+	testimonials_repository::TestimonialsRepository,
+	testimonials_schema::TestimonialsSchema,
+};
+use axum::{http::StatusCode, response::Response};
+use imphnen_libs::{
+	AppState, MetaRequestDto, ResponseListSuccessDto, ResponseSuccessDto,
+};
+use imphnen_utils::{
+	common_response, success_list_response, success_response, validate_request,
+};
+
+pub struct TestimonialsService;
+
+impl TestimonialsService {
+	pub async fn get_testimonial_list(
+		state: &AppState,
+		meta: MetaRequestDto,
+	) -> Response {
+		let repo = TestimonialsRepository::new(state);
+		match repo.query_testimonial_list(meta).await {
+			Ok(data) => {
+				let items: Vec<TestimonialsListItemDto> = data
+					.data
+					.into_iter()
+					.filter(|e| !e.is_deleted)
+					.map(|e| e.from())
+					.collect();
+				let response = ResponseListSuccessDto {
+					data: items,
+					meta: data.meta,
+				};
+				success_list_response(response)
+			}
+			Err(e) => common_response(StatusCode::BAD_REQUEST, &e.to_string()),
+		}
+	}
+
+	pub async fn get_testimonial_by_id(state: &AppState, id: String) -> Response {
+		let repo = TestimonialsRepository::new(state);
+		match repo.query_testimonial_by_id(id).await {
+			Ok(testimonial) if !testimonial.is_deleted => {
+				success_response(ResponseSuccessDto {
+					data: TestimonialsDetailItemDto {
+						id: testimonial.id.id.to_raw(),
+						user_id: testimonial.user.id.id.to_raw(),
+						user_fullname: testimonial.user.fullname,
+						role: testimonial.role,
+						content: testimonial.content,
+						created_at: testimonial.created_at,
+						updated_at: testimonial.updated_at,
+					},
+				})
+			}
+			Ok(_) => common_response(StatusCode::NOT_FOUND, "Testimonial not found"),
+			Err(e) => common_response(StatusCode::NOT_FOUND, &e.to_string()),
+		}
+	}
+
+	pub async fn create_testimonial(
+		state: &AppState,
+		payload: TestimonialsCreateRequestDto,
+		authenticated_user: &imphnen_iam::UsersDetailQueryDto,
+	) -> Response {
+		if let Err((status, message)) = validate_request(&payload) {
+			return common_response(status, &message);
+		}
+		let repo = TestimonialsRepository::new(state);
+		let schema = TestimonialsSchema::create(payload, &authenticated_user.id);
+		match repo.query_create_testimonial(schema).await {
+			Ok(msg) => common_response(StatusCode::CREATED, &msg),
+			Err(e) => common_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
+		}
+	}
+
+	pub async fn update_testimonial(
+		state: &AppState,
+		id: String,
+		payload: TestimonialsUpdateRequestDto,
+		authenticated_user: &imphnen_iam::UsersDetailQueryDto,
+	) -> Response {
+		if let Err((status, message)) = validate_request(&payload) {
+			return common_response(status, &message);
+		}
+		let repo = TestimonialsRepository::new(state);
+		let schema = TestimonialsSchema::update(payload, id, &authenticated_user.id);
+		match repo.query_update_testimonial(schema).await {
+			Ok(msg) => common_response(StatusCode::OK, &msg),
+			Err(e) => common_response(StatusCode::BAD_REQUEST, &e.to_string()),
+		}
+	}
+
+	pub async fn delete_testimonial(
+		state: &AppState,
+		id: String,
+		_authenticated_user: &imphnen_iam::UsersDetailQueryDto,
+	) -> Response {
+		let repo = TestimonialsRepository::new(state);
+		match repo.query_delete_testimonial(id).await {
+			Ok(msg) => common_response(StatusCode::OK, &msg),
+			Err(e) => common_response(StatusCode::BAD_REQUEST, &e.to_string()),
+		}
+	}
+}

imphnen-cms/src/v1/mod.rs

@@ -0,0 +1,3 @@
+pub mod landing;
+
+pub use landing::*;

imphnen-entities/src/common_dto.rs

@@ -1,6 +1,7 @@
 use serde::{Deserialize, Serialize};
 use surrealdb::{
-	engine::{local::Db, remote::ws::Client},
+	engine::local::Db,
+	engine::any::Any,
 	Surreal,
 };
 use utoipa::{IntoParams, ToSchema};
@@ -54,7 +55,7 @@ pub struct ResponseListSuccessDto<T: Serialize> {
 	pub meta: Option<MetaResponseDto>,
 }
 
-pub type SurrealWsClient = Surreal<Client>;
+pub type SurrealWsClient = Surreal<Any>;
 pub type SurrealMemClient = Surreal<Db>;
 
 #[derive(Clone)]

imphnen-gacha/src/v1/gacha_claim/mod.rs

@@ -1,22 +0,0 @@
-use axum::{
-	Router,
-	routing::{get, post},
-};
-
-pub mod gacha_claim_controller;
-pub mod gacha_claim_dto;
-pub mod gacha_claim_repository;
-pub mod gacha_claim_schema;
-pub mod gacha_claim_service;
-
-pub use gacha_claim_controller::*;
-pub use gacha_claim_dto::*;
-pub use gacha_claim_repository::*;
-pub use gacha_claim_schema::*;
-pub use gacha_claim_service::*;
-
-pub fn gacha_claim_router() -> Router {
-	Router::new()
-		.route("/create", post(post_create_gacha_claim))
-		.route("/detail/{id}", get(get_detail_gacha_claim))
-}

imphnen-gacha/src/v1/gacha_claims/gacha_claims_dto.rs

@@ -38,7 +38,7 @@ impl GachaClaimItemDto {
 		Self {
 			id: dto.id.id.to_raw(),
 			user: UsersDetailItemDto::from(&dto.user),
-			item: GachaItemDto::from(&dto.item),
+			item: GachaItemDto::from(dto.item.clone()),
 			is_deleted: dto.is_deleted,
 			created_at: dto.created_at.clone(),
 			updated_at: dto.updated_at.clone(),

imphnen-gacha/src/v1/gacha_claims/gacha_claims_schema.rs

@@ -1,4 +1,5 @@
-use crate::{ResourceEnum, make_thing};
+use crate::{GachaRollQueryDto, ResourceEnum, make_thing};
+use imphnen_iam::get_iso_date;
 use serde::{Deserialize, Serialize};
 use surrealdb::{Uuid, sql::Thing};
 
@@ -30,8 +31,8 @@ impl Default for GachaClaimSchema {
 				&Uuid::new_v4().to_string(),
 			),
 			is_deleted: false,
-			created_at: None,
-			updated_at: None,
+			created_at: Some(get_iso_date()),
+			updated_at: Some(get_iso_date()),
 		}
 	}
 }
@@ -45,9 +46,19 @@ impl GachaClaimSchema {
 			),
 			user: make_thing(&ResourceEnum::Users.to_string(), &dto.user_id),
 			item: make_thing(&ResourceEnum::GachaItems.to_string(), &dto.item_id),
-			is_deleted: false,
-			created_at: None,
-			updated_at: None,
+			..Default::default()
+		}
+	}
+
+	pub fn roll(roll: GachaRollQueryDto, user_id: Thing) -> Self {
+		Self {
+			id: make_thing(
+				&ResourceEnum::GachaClaims.to_string(),
+				&Uuid::new_v4().to_string(),
+			),
+			user: user_id,
+			item: roll.item.id.clone(),
+			..Default::default()
 		}
 	}
 }

imphnen-gacha/src/v1/gacha_claims/mod.rs

@@ -0,0 +1,22 @@
+use axum::{
+	Router,
+	routing::{get, post},
+};
+
+pub mod gacha_claims_controller;
+pub mod gacha_claims_dto;
+pub mod gacha_claims_repository;
+pub mod gacha_claims_schema;
+pub mod gacha_claims_service;
+
+pub use gacha_claims_controller::*;
+pub use gacha_claims_dto::*;
+pub use gacha_claims_repository::*;
+pub use gacha_claims_schema::*;
+pub use gacha_claims_service::*;
+
+pub fn gacha_claim_router() -> Router {
+	Router::new()
+		.route("/create", post(post_create_gacha_claim))
+		.route("/detail/{id}", get(get_detail_gacha_claim))
+}

imphnen-gacha/src/v1/gacha_credits/gacha_credits_dto.rs

@@ -0,0 +1,7 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct GachaCreditRequestDto {
+	pub user_id: String,
+	pub amount: i32,
+}

imphnen-gacha/src/v1/gacha_credits/gacha_credits_repository.rs

@@ -0,0 +1,82 @@
+use super::{GachaCreditRequestDto, GachaCreditSchema};
+use crate::{AppState, ResourceEnum};
+use anyhow::{Result, bail};
+use imphnen_iam::make_thing;
+use surrealdb::Uuid;
+
+pub struct GachaCreditRepository<'a> {
+	state: &'a AppState,
+}
+
+impl<'a> GachaCreditRepository<'a> {
+	pub fn new(state: &'a AppState) -> Self {
+		Self { state }
+	}
+
+	pub async fn query_by_user_id(
+		&self,
+		user_id: String,
+	) -> Result<Option<GachaCreditSchema>> {
+		let db = &self.state.surrealdb_ws;
+		let sql = format!(
+			"SELECT * FROM {} WHERE user = {}:⟨$user_id⟩ AND is_deleted = false LIMIT 1",
+			ResourceEnum::GachaCredits.to_string(),
+			ResourceEnum::Users.to_string()
+		);
+		let result: Vec<GachaCreditSchema> =
+			db.query(sql).bind(("user_id", user_id)).await?.take(0)?;
+		Ok(result.into_iter().next())
+	}
+
+	pub async fn query_consume_credit(&self, user_id: String) -> Result<()> {
+		let db = &self.state.surrealdb_ws;
+		let credit_opt = self.query_by_user_id(user_id).await?;
+		let Some(mut credit) = credit_opt else {
+			return Ok(());
+		};
+		if credit.available_rolls <= 0 {
+			bail!("No extra roll credits remaining");
+		}
+		credit.available_rolls -= 1;
+		let _: Option<GachaCreditSchema> = db
+			.update((
+				&ResourceEnum::GachaCredits.to_string(),
+				credit.id.id.to_raw(),
+			))
+			.merge(credit)
+			.await?;
+		Ok(())
+	}
+
+	pub async fn query_add_credit(
+		&self,
+		payload: GachaCreditRequestDto,
+	) -> Result<()> {
+		let db = &self.state.surrealdb_ws;
+		if let Some(mut credit) = self.query_by_user_id(payload.user_id.clone()).await? {
+			credit.available_rolls += payload.amount;
+			let _: Option<GachaCreditSchema> = db
+				.update((
+					&ResourceEnum::GachaCredits.to_string(),
+					credit.id.id.to_raw(),
+				))
+				.merge(credit)
+				.await?;
+		} else {
+			let data = GachaCreditSchema::from(&GachaCreditSchema {
+				id: make_thing(
+					&ResourceEnum::GachaCredits.to_string(),
+					&Uuid::new_v4().to_string(),
+				),
+				user: make_thing(&ResourceEnum::Users.to_string(), &payload.user_id),
+				available_rolls: payload.amount,
+				..Default::default()
+			});
+			let _: Option<GachaCreditSchema> = db
+				.create(&ResourceEnum::GachaCredits.to_string())
+				.content(data)
+				.await?;
+		}
+		Ok(())
+	}
+}

imphnen-gacha/src/v1/gacha_credits/gacha_credits_schema.rs

@@ -0,0 +1,39 @@
+use imphnen_iam::get_iso_date;
+use serde::{Deserialize, Serialize};
+use surrealdb::sql::Thing;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct GachaCreditSchema {
+	pub id: Thing,
+	pub user: Thing,
+	pub available_rolls: i32,
+	pub is_deleted: bool,
+	pub created_at: Option<String>,
+	pub updated_at: Option<String>,
+}
+
+impl Default for GachaCreditSchema {
+	fn default() -> Self {
+		GachaCreditSchema {
+			id: Thing::from(("app_gacha_credits", "uuid")),
+			user: Thing::from(("app_users", "uuid")),
+			available_rolls: 0,
+			is_deleted: false,
+			created_at: Some(get_iso_date()),
+			updated_at: Some(get_iso_date()),
+		}
+	}
+}
+
+impl GachaCreditSchema {
+	pub fn from(&self) -> Self {
+		Self {
+			id: self.id.clone(),
+			user: self.user.clone(),
+			available_rolls: self.available_rolls,
+			is_deleted: false,
+			created_at: Some(get_iso_date()),
+			updated_at: Some(get_iso_date()),
+		}
+	}
+}

imphnen-gacha/src/v1/gacha_credits/mod.rs

@@ -0,0 +1,7 @@
+pub mod gacha_credits_dto;
+pub mod gacha_credits_repository;
+pub mod gacha_credits_schema;
+
+pub use gacha_credits_dto::*;
+pub use gacha_credits_repository::*;
+pub use gacha_credits_schema::*;

imphnen-gacha/src/v1/gacha_items/gacha_items_controller.rs

@@ -1,8 +1,6 @@
 use crate::{
-	AppState, MessageResponseDto, MetaRequestDto, ResponseListSuccessDto,
-	ResponseSuccessDto,
-	gacha_item_dto::{GachaItemDto, GachaItemRequestDto},
-	gacha_item_service::GachaItemService,
+	AppState, GachaItemDto, GachaItemRequestDto, GachaItemService, MessageResponseDto,
+	MetaRequestDto, ResponseListSuccessDto, ResponseSuccessDto,
 };
 use axum::{
 	Extension, Json,

imphnen-gacha/src/v1/gacha_items/gacha_items_dto.rs

@@ -21,7 +21,7 @@ pub struct GachaItemDto {
 }
 
 impl GachaItemDto {
-	pub fn from(dto: &GachaItemSchema) -> Self {
+	pub fn from(dto: GachaItemSchema) -> Self {
 		Self {
 			id: dto.id.id.to_raw(),
 			name: dto.name.clone(),

imphnen-gacha/src/v1/gacha_items/gacha_items_repository.rs

@@ -1,9 +1,10 @@
 use super::GachaItemSchema;
 use crate::{
 	AppState, GachaItemDto, MetaRequestDto, ResourceEnum, ResponseListSuccessDto,
-	get_id, make_thing, query_list_with_meta,
+	get_id, make_thing,
 };
 use anyhow::{Result, bail};
+use imphnen_iam::QueryListBuilder;
 
 pub struct GachaItemRepository<'a> {
 	state: &'a AppState,
@@ -19,24 +20,23 @@ impl<'a> GachaItemRepository<'a> {
 		meta: MetaRequestDto,
 	) -> Result<ResponseListSuccessDto<Vec<GachaItemDto>>> {
 		let raw_result: ResponseListSuccessDto<Vec<GachaItemSchema>> =
-			query_list_with_meta(
+			QueryListBuilder::new(
 				&self.state.surrealdb_ws,
 				&ResourceEnum::GachaItems.to_string(),
 				&meta,
-				vec!["is_deleted = false".into()],
-				None,
-				"name",
-				Some(vec!["*"]),
-				None,
 			)
+			.with_condition("is_deleted = false")
+			.search_field("name")
+			.select_fields(vec!["*"])
+			.build()
 			.await?;
-		let transformed_data = raw_result
+		let data = raw_result
 			.data
 			.into_iter()
-			.map(|gacha_item| GachaItemDto::from(&gacha_item))
+			.map(GachaItemDto::from)
 			.collect();
 		Ok(ResponseListSuccessDto {
-			data: transformed_data,
+			data,
 			meta: raw_result.meta,
 		})
 	}

imphnen-gacha/src/v1/gacha_items/gacha_items_schema.rs

@@ -40,9 +40,7 @@ impl GachaItemSchema {
 			),
 			name: dto.name,
 			image_url: dto.image_url,
-			is_deleted: false,
-			created_at: Some(get_iso_date()),
-			updated_at: Some(get_iso_date()),
+			..Default::default()
 		}
 	}
 }

imphnen-gacha/src/v1/gacha_items/gacha_items_service.rs

@@ -31,7 +31,7 @@ impl GachaItemService {
 		let repo = GachaItemRepository::new(state);
 		match repo.query_gacha_item_by_id(id).await {
 			Ok(item) => success_response(ResponseSuccessDto {
-				data: GachaItemDto::from(&item),
+				data: GachaItemDto::from(item),
 			}),
 			Err(e) => common_response(StatusCode::NOT_FOUND, &e.to_string()),
 		}

imphnen-gacha/src/v1/gacha_items/mod.rs

@@ -3,17 +3,17 @@ use axum::{
 	routing::{delete, get, post, put},
 };
 
-pub mod gacha_item_controller;
-pub mod gacha_item_dto;
-pub mod gacha_item_repository;
-pub mod gacha_item_schema;
-pub mod gacha_item_service;
+pub mod gacha_items_controller;
+pub mod gacha_items_dto;
+pub mod gacha_items_repository;
+pub mod gacha_items_schema;
+pub mod gacha_items_service;
 
-pub use gacha_item_controller::*;
-pub use gacha_item_dto::*;
-pub use gacha_item_repository::*;
-pub use gacha_item_schema::*;
-pub use gacha_item_service::*;
+pub use gacha_items_controller::*;
+pub use gacha_items_dto::*;
+pub use gacha_items_repository::*;
+pub use gacha_items_schema::*;
+pub use gacha_items_service::*;
 
 pub fn gacha_item_router() -> Router {
 	Router::new()

imphnen-gacha/src/v1/gacha_roll/mod.rs

@@ -1,22 +0,0 @@
-pub mod gacha_roll_controller;
-pub mod gacha_roll_dto;
-pub mod gacha_roll_repository;
-pub mod gacha_roll_schema;
-pub mod gacha_roll_service;
-
-use axum::{
-	Router,
-	routing::{get, post},
-};
-pub use gacha_roll_controller::*;
-pub use gacha_roll_dto::*;
-pub use gacha_roll_repository::*;
-pub use gacha_roll_schema::*;
-pub use gacha_roll_service::*;
-
-pub fn gacha_roll_router() -> Router {
-	Router::new()
-		.route("/create", post(post_create_gacha_roll))
-		.route("/execute", post(post_execute_gacha_roll))
-		.route("/detail/{id}", get(get_detail_gacha_roll))
-}

imphnen-gacha/src/v1/gacha_rolls/gacha_rolls_controller.rs

@@ -1,7 +1,6 @@
 use crate::{
-	AppState, MessageResponseDto, ResponseSuccessDto,
-	gacha_roll_dto::{GachaRollItemDto, GachaRollRequestDto},
-	gacha_roll_service::GachaRollService,
+	AppState, GachaRollItemDto, GachaRollRequestDto, GachaRollService,
+	MessageResponseDto, ResponseSuccessDto,
 };
 use axum::{
 	Extension, Json, extract::Path, http::HeaderMap, response::IntoResponse,
@@ -88,7 +87,7 @@ pub async fn post_execute_gacha_roll(
 	)
 	.await
 	{
-		Ok(_) => GachaRollService::execute_roll_once(&state).await,
+		Ok(_) => GachaRollService::execute_roll_once(headers, &state).await,
 		Err(response) => response,
 	}
 }

imphnen-gacha/src/v1/gacha_rolls/gacha_rolls_dto.rs

@@ -8,7 +8,6 @@ use validator::Validate;
 pub struct GachaRollRequestDto {
 	#[validate(length(min = 1, message = "Item ID must not be empty"))]
 	pub item_id: String,
-	#[validate(range(min = 1, message = "Weight must be greater than zero"))]
 	pub weight: f32,
 	#[validate(range(min = 1, message = "Quantity must be at least 1"))]
 	pub quantity: i32,
@@ -18,7 +17,7 @@ pub struct GachaRollRequestDto {
 pub struct GachaRollItemDto {
 	pub id: String,
 	pub item: GachaItemDto,
-	pub weight: String,
+	pub weight: f32,
 	pub quantity: i32,
 	pub is_deleted: bool,
 	pub created_at: Option<String>,
@@ -29,8 +28,8 @@ impl GachaRollItemDto {
 	pub fn from(dto: &GachaRollQueryDto) -> Self {
 		Self {
 			id: dto.id.id.to_raw(),
-			item: GachaItemDto::from(&dto.item),
-			weight: dto.weight.to_string(),
+			item: GachaItemDto::from(dto.item.clone()),
+			weight: dto.weight.clone(),
 			quantity: dto.quantity,
 			is_deleted: dto.is_deleted,
 			created_at: dto.created_at.clone(),

imphnen-gacha/src/v1/gacha_rolls/gacha_rolls_repository.rs

@@ -2,6 +2,7 @@ use super::GachaRollQueryDto;
 use super::GachaRollSchema;
 use crate::{AppState, DetailQueryBuilder, ResourceEnum};
 use anyhow::{Result, bail};
+use imphnen_iam::ListQueryBuilder;
 use rand::prelude::*;
 use rand::rng;
 use rand_distr::weighted::WeightedIndex;
@@ -50,12 +51,10 @@ impl<'a> GachaRollRepository<'a> {
 
 	pub async fn query_all_active_rolls(&self) -> Result<Vec<GachaRollQueryDto>> {
 		let db = &self.state.surrealdb_ws;
-		let sql = DetailQueryBuilder::new(ResourceEnum::GachaRolls.to_string())
-			.with_where("is_deleted")
-			.where_value("false")
+		let builder = ListQueryBuilder::new(ResourceEnum::GachaRolls.to_string())
 			.with_select_fields(vec!["*"])
-			.with_fetch("item")
-			.build();
+			.with_fetch(Some(vec!["item"]));
+		let sql = builder.build();
 		let result: Vec<GachaRollQueryDto> = db.query(sql).await?.take(0)?;
 		Ok(result)
 	}

imphnen-gacha/src/v1/gacha_rolls/gacha_rolls_schema.rs

@@ -46,9 +46,7 @@ impl GachaRollSchema {
 			item: make_thing(&ResourceEnum::GachaItems.to_string(), &dto.item_id),
 			weight: dto.weight,
 			quantity: dto.quantity,
-			is_deleted: false,
-			created_at: Some(get_iso_date()),
-			updated_at: Some(get_iso_date()),
+			..Default::default()
 		}
 	}
 }

imphnen-gacha/src/v1/gacha_rolls/gacha_rolls_service.rs

@@ -1,10 +1,11 @@
 use crate::{
-	AppState, GachaRollItemDto, GachaRollRepository, GachaRollRequestDto,
-	GachaRollSchema, ResponseSuccessDto, common_response, success_response,
-	validate_request,
+	AppState, GachaClaimRepository, GachaClaimSchema, GachaRollItemDto,
+	GachaRollRepository, GachaRollRequestDto, GachaRollSchema, ResponseSuccessDto,
+	common_response, success_response, validate_request,
 };
-use axum::http::StatusCode;
+use axum::http::{HeaderMap, StatusCode};
 use axum::response::Response;
+use imphnen_iam::{UsersRepository, extract_email};
 
 pub struct GachaRollService;
 
@@ -34,13 +35,29 @@ impl GachaRollService {
 		}
 	}
 
-	pub async fn execute_roll_once(state: &AppState) -> Response {
+	pub async fn execute_roll_once(headers: HeaderMap, state: &AppState) -> Response {
 		let repo = GachaRollRepository::new(state);
+		let repo_claim = GachaClaimRepository::new(state);
+		let repo_user = UsersRepository::new(state);
+		let Some(email) = extract_email(&headers) else {
+			return common_response(StatusCode::UNAUTHORIZED, "Unauthorized");
+		};
+		let Ok(user) = repo_user.query_user_by_email(email.to_string()).await else {
+			return common_response(StatusCode::NOT_FOUND, "User not found");
+		};
 		match repo.query_all_active_rolls().await {
 			Ok(rolls) => match GachaRollRepository::roll_once(&rolls) {
-				Some(roll) => success_response(ResponseSuccessDto {
-					data: GachaRollItemDto::from(&roll),
-				}),
+				Some(roll) => {
+					let claim = GachaClaimSchema::roll(roll.clone(), user.id);
+					match repo_claim.query_create_gacha_claim(claim).await {
+						Ok(_) => success_response(ResponseSuccessDto {
+							data: GachaRollItemDto::from(&roll),
+						}),
+						Err(e) => {
+							common_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string())
+						}
+					}
+				}
 				None => common_response(StatusCode::NOT_FOUND, "No rollable item available"),
 			},
 			Err(e) => common_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),

imphnen-gacha/src/v1/gacha_rolls/mod.rs

@@ -0,0 +1,22 @@
+pub mod gacha_rolls_controller;
+pub mod gacha_rolls_dto;
+pub mod gacha_rolls_repository;
+pub mod gacha_rolls_schema;
+pub mod gacha_rolls_service;
+
+use axum::{
+	Router,
+	routing::{get, post},
+};
+pub use gacha_rolls_controller::*;
+pub use gacha_rolls_dto::*;
+pub use gacha_rolls_repository::*;
+pub use gacha_rolls_schema::*;
+pub use gacha_rolls_service::*;
+
+pub fn gacha_roll_router() -> Router {
+	Router::new()
+		.route("/create", post(post_create_gacha_roll))
+		.route("/execute", post(post_execute_gacha_roll))
+		.route("/detail/{id}", get(get_detail_gacha_roll))
+}

imphnen-gacha/src/v1/mod.rs

@@ -1,12 +1,14 @@
 use axum::Router;
 
-pub mod gacha_claim;
-pub mod gacha_item;
-pub mod gacha_roll;
+pub mod gacha_claims;
+pub mod gacha_credits;
+pub mod gacha_items;
+pub mod gacha_rolls;
 
-pub use gacha_claim::*;
-pub use gacha_item::*;
-pub use gacha_roll::*;
+pub use gacha_claims::*;
+pub use gacha_credits::*;
+pub use gacha_items::*;
+pub use gacha_rolls::*;
 
 pub fn gacha_router() -> Router {
 	Router::new()

imphnen-gateway/Cargo.toml

@@ -10,6 +10,7 @@ imphnen-utils = { version = "0.1.0", path = "../imphnen-utils" }
 imphnen-gacha = { version = "0.1.0", path = "../imphnen-gacha" }
 imphnen-entities = { version = "0.1.0", path = "../imphnen-entities" }
 imphnen-middleware = { version = "0.1.0", path = "../imphnen-middleware" }
+imphnen-cms = { version = "0.1.0", path = "../imphnen-cms" }
 axum.workspace = true
 serde.workspace = true
 serde_json.workspace = true

imphnen-gateway/src/docs.rs

@@ -5,7 +5,9 @@ use utoipa::{
 	openapi::security::{Http, HttpAuthScheme, SecurityScheme},
 	Modify, OpenApi,
 };
-use imphnen_gacha::{gacha_claim, gacha_item, gacha_roll, GachaClaimItemDto, GachaClaimRequestDto, GachaItemDto, GachaItemRequestDto, GachaRollItemDto, GachaRollRequestDto};
+use imphnen_gacha::{gacha_claims, gacha_items, gacha_rolls, GachaClaimItemDto, GachaClaimRequestDto, GachaItemDto, GachaItemRequestDto, GachaRollItemDto, GachaRollRequestDto};
+use imphnen_cms::{events_controller, events_dto::{EventsDetailItemDto, EventsListItemDto}, testimonials_controller, testimonials_dto::{TestimonialsCreateRequestDto, TestimonialsDetailItemDto, TestimonialsListItemDto, TestimonialsUpdateRequestDto}};
+
 
 #[derive(OpenApi)]
 #[openapi(
@@ -35,16 +37,26 @@ use imphnen_gacha::{gacha_claim, gacha_item, gacha_roll, GachaClaimItemDto, Gach
      permissions::permissions_controller::post_create_permission,
      permissions::permissions_controller::put_update_permission,
      permissions::permissions_controller::delete_permission,
-     gacha_claim::get_detail_gacha_claim,
-     gacha_claim::post_create_gacha_claim,
-     gacha_item::get_gacha_item_list,
-     gacha_item::get_gacha_item_by_id,
-     gacha_item::post_create_gacha_item,
-     gacha_item::put_update_gacha_item,
-     gacha_item::delete_gacha_item,
-     gacha_roll::get_detail_gacha_roll,
-     gacha_roll::post_create_gacha_roll,
-     gacha_roll::post_execute_gacha_roll,
+     gacha_claims::get_detail_gacha_claim,
+     gacha_claims::post_create_gacha_claim,
+     gacha_items::get_gacha_item_list,
+     gacha_items::get_gacha_item_by_id,
+     gacha_items::post_create_gacha_item,
+     gacha_items::put_update_gacha_item,
+     gacha_items::delete_gacha_item,
+     gacha_rolls::get_detail_gacha_roll,
+     gacha_rolls::post_create_gacha_roll,
+     gacha_rolls::post_execute_gacha_roll,
+	 events_controller::get_event_list,
+	 events_controller::get_event_by_id,
+	 events_controller::post_create_event,
+	 events_controller::patch_update_event,
+	 events_controller::delete_event,
+	 testimonials_controller::get_testimonial_list,
+	 testimonials_controller::get_testimonial_by_id,
+	 testimonials_controller::post_create_testimonial,
+	 testimonials_controller::patch_update_testimonial,
+	 testimonials_controller::delete_testimonial,
     ),
     components(
         schemas(
@@ -83,7 +95,14 @@ use imphnen_gacha::{gacha_claim, gacha_item, gacha_roll, GachaClaimItemDto, Gach
            ResponseListSuccessDto<Vec<UsersListItemDto>>,
            ResponseSuccessDto<UsersDetailItemDto>,
            ResponseListSuccessDto<Vec<PermissionsItemDto>>,
-           ResponseSuccessDto<PermissionsItemDto>
+           ResponseSuccessDto<PermissionsItemDto>,
+		   ResponseListSuccessDto<Vec<EventsListItemDto>>,
+		   ResponseSuccessDto<EventsDetailItemDto>,
+		   ResponseListSuccessDto<Vec<TestimonialsListItemDto>>,
+		   ResponseSuccessDto<TestimonialsDetailItemDto>,
+		   TestimonialsCreateRequestDto,
+		   TestimonialsUpdateRequestDto,
+		   MessageResponseDto,
         )
     ),
     info(

imphnen-gateway/src/lib.rs

@@ -1,6 +1,10 @@
 use axum::{
 	Extension, Router, middleware::from_fn, response::Redirect, routing::get,
 };
+use imphnen_cms::{
+	events_protected_routes, events_public_routes, testimonials_protected_routes,
+	testimonials_public_routes,
+};
 use imphnen_entities::{AppState, SurrealMemClient, SurrealWsClient};
 use imphnen_gacha::gacha_router;
 use imphnen_iam::{iam_protected_routes, iam_public_routes};
@@ -19,16 +23,23 @@ pub async fn gateway_service(
 		surrealdb_mem,
 	};
 
-	let public_routes = iam_public_routes();
+	let public_routes = Router::new()
+		.merge(iam_public_routes())
+		.merge(testimonials_public_routes())
+		.merge(events_public_routes());
 
 	let protected_routes = Router::new()
 		.merge(iam_protected_routes())
+		.merge(events_protected_routes())
+		.merge(testimonials_protected_routes())
 		.merge(gacha_router())
 		.layer(from_fn(auth_middleware));
 
+	let routes = public_routes.merge(protected_routes);
+
 	Router::new()
 		.route("/", get(Redirect::to("/docs")))
-		.nest("/v1", public_routes.merge(protected_routes))
+		.nest("/v1", routes)
 		.merge(SwaggerUi::new("/docs").url("/openapi.json", docs_router()))
 		.layer(cors_middleware())
 		.layer(Extension(state))

imphnen-iam/src/v1/auth/auth_dto.rs

@@ -1,24 +1,13 @@
-use lazy_static::lazy_static;
-use regex::Regex;
+use crate::UsersDetailItemDto;
 use serde::{Deserialize, Serialize};
 use utoipa::ToSchema;
 use validator::{Validate, ValidationError};
 
-use crate::UsersDetailItemDto;
-
-lazy_static! {
-	static ref PASSWORD_REGEX: Regex = Regex::new(
-		r"^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$"
-	)
-	.unwrap();
-}
-
 fn validate_password_complexity(password: &str) -> Result<(), ValidationError> {
 	let has_uppercase = password.chars().any(|c| c.is_ascii_uppercase());
 	let has_lowercase = password.chars().any(|c| c.is_ascii_lowercase());
 	let has_digit = password.chars().any(|c| c.is_ascii_digit());
 	let has_special = password.chars().any(|c| "@$!%*?&".contains(c));
-
 	if has_uppercase && has_lowercase && has_digit && has_special {
 		Ok(())
 	} else {
@@ -98,10 +87,14 @@ pub struct AuthRefreshTokenRequestDto {
 
 #[derive(Clone, Debug, Serialize, Deserialize, ToSchema, Validate)]
 pub struct AuthNewPasswordRequestDto {
-	pub token: String,
 	#[validate(length(min = 1, message = "Token cannot be empty"))]
-	#[validate(regex(
-		path = "PASSWORD_REGEX",
+	pub token: String,
+	#[validate(length(
+		min = 8,
+		message = "Password must have at least 8 characters"
+	))]
+	#[validate(custom(
+		function = "validate_password_complexity",
 		message = "Password must include uppercase, lowercase, number, and special character"
 	))]
 	pub password: String,
@@ -118,8 +111,8 @@ pub struct AuthSetNewPasswordRequestDto {
 		min = 8,
 		message = "Password must have at least 8 characters"
 	))]
-	#[validate(regex(
-		path = "PASSWORD_REGEX",
+	#[validate(custom(
+		function = "validate_password_complexity",
 		message = "Password must include uppercase, lowercase, number, and special character"
 	))]
 	pub password: String,

imphnen-iam/src/v1/auth/auth_service.rs

@@ -94,7 +94,6 @@ impl AuthService {
 		if let Err((status, message)) = validate_request(&payload) {
 			return common_response(status, &message);
 		}
-
 		let user_repo = UsersRepository::new(state);
 		let auth_repo = AuthRepository::new(state);
 		let role_repo = RolesRepository::new(state);
@@ -105,7 +104,6 @@ impl AuthService {
 			Ok(role) => role,
 			Err(_) => return common_response(StatusCode::BAD_REQUEST, "Role Not Found"),
 		};
-
 		if user_repo
 			.query_user_by_email(payload.email.clone())
 			.await
@@ -113,7 +111,6 @@ impl AuthService {
 		{
 			return common_response(StatusCode::BAD_REQUEST, "User already exists");
 		}
-
 		let hashed_password = match hash_password(&payload.password) {
 			Ok(hash) => hash,
 			Err(_) => {
@@ -123,16 +120,13 @@ impl AuthService {
 				);
 			}
 		};
-
 		let new_user = AuthRegisterRequestDto {
 			email: payload.email,
 			password: hashed_password,
 			fullname: payload.fullname,
 			phone_number: payload.phone_number,
 		};
-
 		let otp = generate_otp::OtpManager::generate_otp();
-
 		match auth_repo
 			.query_store_otp(new_user.email.clone(), otp.clone())
 			.await
@@ -150,13 +144,11 @@ impl AuthService {
 				return common_response(StatusCode::INTERNAL_SERVER_ERROR, &err.to_string());
 			}
 		}
-
 		let role_thing = make_thing(&ResourceEnum::Roles.to_string(), &role.id);
 		let user_thing = make_thing(
 			&ResourceEnum::Users.to_string(),
 			&Uuid::new_v4().to_string(),
 		);
-
 		match user_repo
 			.query_create_user(UsersSchema {
 				id: user_thing,
@@ -185,7 +177,6 @@ impl AuthService {
 		if let Err((status, message)) = validate_request(&payload) {
 			return common_response(status, &message);
 		}
-
 		let user_repo = UsersRepository::new(state);
 		if user_repo
 			.query_user_by_email(payload.email.clone())
@@ -194,10 +185,8 @@ impl AuthService {
 		{
 			return common_response(StatusCode::BAD_REQUEST, "User not found");
 		}
-
 		let auth_repo = AuthRepository::new(state);
 		let _ = auth_repo.query_get_stored_otp(payload.email.clone()).await;
-
 		let otp = generate_otp::OtpManager::generate_otp();
 		let message = format!("Your OTP code is {}", otp);
 		match auth_repo.query_store_otp(payload.email.clone(), otp).await {

imphnen-iam/src/v1/permissions/permissions_enum.rs

@@ -63,3 +63,44 @@ impl fmt::Display for PermissionsEnum {
 		write!(f, "{}", permission_str)
 	}
 }
+
+impl PermissionsEnum {
+	pub fn id(&self) -> &'static str {
+		match self {
+			PermissionsEnum::ReadListUsers => "7c15e31d-36e2-49f9-97db-138c03fb0cf6",
+			PermissionsEnum::ReadDetailUsers => "319ee593-ff0a-4f29-bbaf-9feb3174a3a6",
+			PermissionsEnum::CreateUsers => "023e2dfe-93c3-4008-94a8-b5dff403f73b",
+			PermissionsEnum::DeleteUsers => "96df0689-2ae9-4894-bf00-837c19415e5c",
+			PermissionsEnum::UpdateUsers => "98b3dc4c-0124-461f-afcd-166637c5e6e8",
+			PermissionsEnum::ActivateUsers => "4da8b434-89f9-4d91-85ae-eebd63cdbeda",
+			PermissionsEnum::ReadListRoles => "9164ca6e-c7e3-4238-a15f-f36ab9577e7e",
+			PermissionsEnum::ReadDetailRoles => "73888d18-b3e9-4f62-95a5-ba2c0d69fccb",
+			PermissionsEnum::CreateRoles => "319ee593-ff0a-4f29-bbaf-9feb3174a3a2",
+			PermissionsEnum::DeleteRoles => "35b0d992-65c8-4b62-b030-e6e0320e4048",
+			PermissionsEnum::UpdateRoles => "a00d5608-4c48-4542-845c-dfe004687022",
+			PermissionsEnum::ReadListPermissions => "8195eeb8-e64f-4172-aa57-596492c84a72",
+			PermissionsEnum::ReadDetailPermissions => {
+				"dad435cf-042c-41bd-a946-cea61ed2ffbc"
+			}
+			PermissionsEnum::CreatePermissions => "0269ed71-0ae0-4c43-ad29-e3d861d8f9a0",
+			PermissionsEnum::DeletePermissions => "b2dc3928-86ba-4c59-a03d-0b57d5183ebc",
+			PermissionsEnum::UpdatePermissions => "299cb4d5-6556-4cc9-b6c1-32e6d31e0f9b",
+			PermissionsEnum::CreateGachaClaims => "f41d53ce-4f88-4bb6-b9b4-5e3a8c38d962",
+			PermissionsEnum::ReadDetailGachaClaims => {
+				"c1c3d6c2-19fb-4b70-b58c-c19f2e8cfc79"
+			}
+			PermissionsEnum::ReadListGachaItems => "fa6eb842-0a61-40c2-9c24-b226ad975037",
+			PermissionsEnum::ReadDetailGachaItems => {
+				"9c7857d7-b5ae-4688-923d-ef5572e9bc8b"
+			}
+			PermissionsEnum::CreateGachaItems => "cf063be1-4d71-489e-b9fb-1c08c65f396c",
+			PermissionsEnum::DeleteGachaItems => "46f8c6cf-ea0c-4c90-860c-69e2e65f7eb1",
+			PermissionsEnum::UpdateGachaItems => "2d0cf4ae-56ae-4714-a12e-655cfc3d9eb2",
+			PermissionsEnum::ReadDetailGachaRolls => {
+				"53d6483a-04cd-4667-8792-2d0cc8e2d343"
+			}
+			PermissionsEnum::CreateGachaRolls => "18e36c63-fcb7-4877-b911-c5aa611e878f",
+			PermissionsEnum::ExecuteGachaRolls => "14c6a1cd-5c63-4643-89b5-b1a5f9920cc0",
+		}
+	}
+}

imphnen-iam/src/v1/permissions/permissions_repository.rs

@@ -1,10 +1,9 @@
 use super::{PermissionsItemDto, PermissionsSchema};
 use crate::{
-	AppState, MetaRequestDto, ResourceEnum, ResponseListSuccessDto, get_id,
-	make_thing, query_list_with_meta,
+	AppState, MetaRequestDto, ResourceEnum, ResponseListSuccessDto, get_id, make_thing,
 };
 use anyhow::{Result, bail};
-use imphnen_utils::{DetailQueryBuilder, extract_id};
+use imphnen_utils::{DetailQueryBuilder, QueryListBuilder, extract_id};
 
 pub struct PermissionsRepository<'a> {
 	state: &'a AppState,
@@ -20,22 +19,23 @@ impl<'a> PermissionsRepository<'a> {
 		meta: MetaRequestDto,
 	) -> Result<ResponseListSuccessDto<Vec<PermissionsItemDto>>> {
 		let raw_result: ResponseListSuccessDto<Vec<PermissionsSchema>> =
-			query_list_with_meta(
+			QueryListBuilder::new(
 				&self.state.surrealdb_ws,
 				&ResourceEnum::Permissions.to_string(),
 				&meta,
-				vec!["is_deleted = false".into()],
-				None,
-				"name",
-				Some(vec!["*"]),
-				None,
 			)
+			.with_condition("is_deleted = false")
+			.search_field("name")
+			.select_fields(vec!["*"])
+			.build()
 			.await?;
+
 		let transformed_data = raw_result
 			.data
 			.into_iter()
 			.map(|permission| PermissionsSchema::list(&permission))
 			.collect();
+
 		Ok(ResponseListSuccessDto {
 			data: transformed_data,
 			meta: raw_result.meta,

imphnen-iam/src/v1/roles/roles_repository.rs

@@ -3,11 +3,10 @@ use super::{
 	RolesRequestUpdateDto, RolesSchema,
 };
 use crate::{
-	AppState, MetaRequestDto, PermissionsItemDto, ResourceEnum,
-	ResponseListSuccessDto, extract_id, get_id, make_thing, query_list_with_meta,
+	AppState, MetaRequestDto, ResourceEnum, ResponseListSuccessDto, get_id, make_thing,
 };
 use anyhow::{Result, bail};
-use imphnen_utils::DetailQueryBuilder;
+use imphnen_utils::{DetailQueryBuilder, QueryListBuilder};
 use surrealdb::Uuid;
 use surrealdb::sql::Thing;
 
@@ -24,36 +23,22 @@ impl<'a> RolesRepository<'a> {
 		&self,
 		meta: MetaRequestDto,
 	) -> Result<ResponseListSuccessDto<Vec<RolesListItemDto>>> {
-		let mut conditions = vec!["is_deleted = false".into()];
-		if let Some(_search) = meta.search.as_deref().filter(|s| !s.is_empty()) {
-			conditions.push("string::contains(name ?? '', $search)".into());
-		}
-		if let (Some(filter_by), Some(filter_val)) =
-			(meta.filter_by.as_ref(), meta.filter.as_ref())
-		{
-			if !filter_val.is_empty() {
-				conditions.push(format!("{} = $filter", filter_by));
-			}
-		}
-		let raw_result: ResponseListSuccessDto<Vec<RolesSchema>> = query_list_with_meta(
+		let result: ResponseListSuccessDto<Vec<RolesSchema>> = QueryListBuilder::new(
 			&self.state.surrealdb_ws,
 			&ResourceEnum::Roles.to_string(),
 			&meta,
-			conditions,
-			None,
-			"name",
-			None,
-			None,
 		)
+		.search_field("name")
+		.build()
 		.await?;
-		let data = raw_result
+		let data = result
 			.data
 			.into_iter()
 			.map(|role| RolesSchema::list(&role))
 			.collect();
 		Ok(ResponseListSuccessDto {
 			data,
-			meta: raw_result.meta,
+			meta: result.meta,
 		})
 	}
 
@@ -65,16 +50,8 @@ impl<'a> RolesRepository<'a> {
 		let builder = DetailQueryBuilder::new(ResourceEnum::Roles.to_string())
 			.with_where("name")
 			.where_value(name.clone())
-			.with_select_fields(vec![
-				"id",
-				"name",
-				"permissions",
-				"created_at",
-				"updated_at",
-				"is_deleted",
-			])
+			.with_select_fields(vec!["*"])
 			.with_fetch("permissions");
-
 		let sql = builder.build();
 		let result: Option<RolesDetailQueryDto> = builder
 			.apply_bindings(db.query(sql).bind(("name", name)))
@@ -84,38 +61,14 @@ impl<'a> RolesRepository<'a> {
 			Some(r) if !r.is_deleted => r,
 			_ => bail!("Role not found"),
 		};
-		let permissions = role
-			.permissions
-			.into_iter()
-			.map(|perm| PermissionsItemDto {
-				id: extract_id(&perm.id),
-				name: perm.name,
-				created_at: perm.created_at,
-				updated_at: perm.updated_at,
-			})
-			.collect();
-		Ok(RolesDetailItemDto {
-			id: extract_id(&role.id),
-			name: role.name,
-			is_deleted: role.is_deleted,
-			permissions,
-			created_at: role.created_at,
-			updated_at: role.updated_at,
-		})
+		Ok(RolesDetailItemDto::from(&role))
 	}
 
 	pub async fn query_role_by_id(&self, id: String) -> Result<RolesDetailItemDto> {
 		let db = &self.state.surrealdb_ws;
 		let builder = DetailQueryBuilder::new(ResourceEnum::Roles.to_string())
 			.with_id(&id)
-			.with_select_fields(vec![
-				"id",
-				"name",
-				"is_deleted",
-				"permissions",
-				"created_at",
-				"updated_at",
-			])
+			.with_select_fields(vec!["*"])
 			.with_fetch("permissions");
 		let sql = builder.build();
 		let result: Option<RolesDetailQueryDto> =
@@ -124,24 +77,7 @@ impl<'a> RolesRepository<'a> {
 			Some(r) if !r.is_deleted => r,
 			_ => bail!("Role not found"),
 		};
-		let permissions = role
-			.permissions
-			.into_iter()
-			.map(|perm| PermissionsItemDto {
-				id: extract_id(&perm.id),
-				name: perm.name,
-				created_at: perm.created_at,
-				updated_at: perm.updated_at,
-			})
-			.collect();
-		Ok(RolesDetailItemDto {
-			id: extract_id(&role.id),
-			name: role.name,
-			is_deleted: role.is_deleted,
-			permissions,
-			created_at: role.created_at,
-			updated_at: role.updated_at,
-		})
+		Ok(RolesDetailItemDto::from(&role))
 	}
 
 	pub async fn query_create_role(

imphnen-iam/src/v1/roles/roles_schema.rs

@@ -46,7 +46,7 @@ impl RolesSchema {
 				.permissions
 				.into_iter()
 				.map(|perm| {
-					make_thing(&ResourceEnum::Permissions.to_string(), &perm.id.to_raw())
+					make_thing(&ResourceEnum::Permissions.to_string(), &perm.id.id.to_raw())
 				})
 				.collect(),
 			is_deleted: dto.is_deleted,

imphnen-iam/src/v1/users/users_dto.rs

@@ -139,7 +139,7 @@ pub struct UsersListQueryDto {
 }
 
 impl UsersListQueryDto {
-	pub fn from(&self) -> UsersListItemDto {
+	pub fn from(self) -> UsersListItemDto {
 		UsersListItemDto {
 			id: self.id.id.to_raw(),
 			role: self.role.name.clone(),

imphnen-iam/src/v1/users/users_repository.rs

@@ -1,10 +1,9 @@
 use super::{UsersDetailQueryDto, UsersListItemDto, UsersListQueryDto, UsersSchema};
 use crate::{
-	AppState, MetaRequestDto, ResourceEnum, ResponseListSuccessDto, get_id,
-	make_thing, query_list_with_meta,
+	AppState, MetaRequestDto, ResourceEnum, ResponseListSuccessDto, get_id, make_thing,
 };
 use anyhow::{Result, bail};
-use imphnen_utils::DetailQueryBuilder;
+use imphnen_utils::{DetailQueryBuilder, QueryListBuilder};
 use surrealdb::{Surreal, engine::remote::ws::Client};
 
 pub struct UsersRepository<'a> {
@@ -35,29 +34,26 @@ impl<'a> UsersRepository<'a> {
 		&self,
 		meta: MetaRequestDto,
 	) -> Result<ResponseListSuccessDto<Vec<UsersListItemDto>>> {
-		let db = &self.state.surrealdb_ws;
-
-		let raw_result = query_list_with_meta::<UsersListQueryDto>(
-			db,
-			&ResourceEnum::Users.to_string(),
-			&meta,
-			vec!["is_deleted = false".into()],
-			None,
-			"fullname",
-			Some(vec!["*"]),
-			Some(vec!["role", "role.permissions"]),
-		)
-		.await?;
-
-		let data = raw_result
+		let result: ResponseListSuccessDto<Vec<UsersListQueryDto>> =
+			QueryListBuilder::new(
+				&self.state.surrealdb_ws,
+				&ResourceEnum::Users.to_string(),
+				&meta,
+			)
+			.with_condition("is_deleted = false")
+			.search_field("fullname")
+			.select_fields(vec!["*"])
+			.fetch_fields(vec!["role", "role.permissions"])
+			.build()
+			.await?;
+		let data = result
 			.data
 			.into_iter()
-			.map(|schema| UsersListQueryDto::from(&schema))
-			.collect::<Vec<_>>();
-
+			.map(UsersListQueryDto::from)
+			.collect();
 		Ok(ResponseListSuccessDto {
 			data,
-			meta: raw_result.meta,
+			meta: result.meta,
 		})
 	}
 
@@ -66,52 +62,46 @@ impl<'a> UsersRepository<'a> {
 		email: String,
 	) -> Result<UsersDetailQueryDto> {
 		let db = &self.state.surrealdb_ws;
-
 		let builder = DetailQueryBuilder::new(ResourceEnum::Users.to_string())
 			.with_where("email")
 			.where_value(email.clone())
 			.with_select_fields(vec!["*"])
 			.with_fetch("role")
 			.with_fetch("role.permissions");
-
 		let sql = builder.build();
-
 		let user_opt: Option<UsersDetailQueryDto> =
 			builder.apply_bindings(db.query(sql)).await?.take(0)?;
-
 		let Some(user) = user_opt else {
 			bail!("User not found");
 		};
-
+		if user.is_deleted {
+			bail!("User not found");
+		}
 		if user.role.is_deleted {
 			bail!("User not found");
 		}
-
 		Ok(UsersDetailQueryDto::from(&user))
 	}
 
 	pub async fn query_user_by_id(&self, id: String) -> Result<UsersDetailQueryDto> {
 		let db = &self.state.surrealdb_ws;
-
 		let builder = DetailQueryBuilder::new(ResourceEnum::Users.to_string())
 			.with_id(&id)
 			.with_select_fields(vec!["*"])
 			.with_fetch("role")
 			.with_fetch("role.permissions");
-
 		let sql = builder.build();
-
 		let result: Option<UsersDetailQueryDto> =
 			builder.apply_bindings(db.query(sql)).await?.take(0)?;
-
 		let Some(user) = result else {
 			bail!("User not found");
 		};
-
+		if user.is_deleted {
+			bail!("User not found");
+		}
 		if user.role.is_deleted {
 			bail!("User not found");
 		}
-
 		Ok(UsersDetailQueryDto::from(&user))
 	}
 
@@ -135,9 +125,9 @@ impl<'a> UsersRepository<'a> {
 			bail!("User already deleted");
 		}
 		let role_thing = if data.role == existing.role.id {
-			existing.role.id
+			existing.role.id.clone()
 		} else {
-			data.clone().role
+			data.role.clone()
 		};
 		let merged = UsersSchema {
 			password: existing.password,
@@ -156,7 +146,7 @@ impl<'a> UsersRepository<'a> {
 		let db = &self.state.surrealdb_ws;
 		let user = self.query_user_by_id(id).await?;
 		if user.is_deleted {
-			bail!("User already deleted");
+			bail!("User not found");
 		}
 		let record_key = get_id(&user.id)?;
 		let record: Option<UsersSchema> = db

imphnen-iam/src/v1/users/users_schema.rs

@@ -24,19 +24,25 @@ pub struct UsersSchema {
 impl Default for UsersSchema {
 	fn default() -> Self {
 		Self {
-			id: Thing::from(("app_users", "dummy")),
-			fullname: "".into(),
-			email: "".into(),
-			password: "".into(),
+			id: make_thing(
+				&ResourceEnum::Users.to_string(),
+				&Uuid::new_v4().to_string(),
+			),
+			fullname: String::new(),
+			email: String::new(),
+			password: hash_password("").unwrap(),
 			avatar: None,
-			phone_number: "".into(),
+			phone_number: String::new(),
 			is_active: false,
 			is_deleted: false,
 			gender: None,
 			birthdate: None,
-			role: Thing::from(("app_roles", "dummy")),
-			created_at: "".into(),
-			updated_at: "".into(),
+			role: make_thing(
+				&ResourceEnum::Roles.to_string(),
+				"5713cb37-dc02-4e87-8048-d7a41d352059",
+			),
+			created_at: get_iso_date(),
+			updated_at: get_iso_date(),
 		}
 	}
 }
@@ -56,7 +62,7 @@ impl UsersSchema {
 			password: dto.password,
 			created_at: dto.created_at,
 			updated_at: dto.updated_at,
-			role: make_thing(&ResourceEnum::Roles.to_string(), &dto.role.id.to_string()),
+			role: make_thing(&ResourceEnum::Roles.to_string(), &dto.role.id.id.to_raw()),
 		}
 	}
 

imphnen-libs/Cargo.toml

@@ -14,3 +14,5 @@ lettre.workspace = true
 chrono.workspace = true
 surrealdb.workspace = true
 jsonwebtoken.workspace = true
+dotenvy.workspace = true
+

imphnen-libs/src/axum/mod.rs

@@ -1,15 +1,17 @@
-use crate::{Env, surrealdb_init_mem, surrealdb_init_ws};
+use crate::{load_env, surrealdb_init_mem, surrealdb_init_ws, Env};
 use axum::{Router, serve};
 use imphnen_entities::{SurrealMemClient, SurrealWsClient};
 use log::{debug, error, info};
 use std::{future::Future, net::SocketAddr};
 use tokio::net::TcpListener;
 
+
 pub async fn axum_init<F, Fut>(router_fn: F)
 where
 	F: FnOnce(SurrealWsClient, SurrealMemClient) -> Fut,
 	Fut: Future<Output = Router>,
 {
+	load_env();
 	let env = Env::new();
 	info!("Environment loaded with port: {}", env.port);
 

imphnen-libs/src/enviroment/mod.rs

@@ -1,5 +1,9 @@
 use std::env;
 
+pub fn load_env() {
+	dotenvy::dotenv().ok();
+}
+
 pub struct Env {
 	pub port: u16,
 	pub access_token_secret: String,
@@ -23,45 +27,122 @@ pub struct Env {
 }
 
 impl Env {
+	#[must_use]
 	pub fn new() -> Self {
 		Self {
 			port: env::var("PORT")
-				.unwrap_or_else(|_| "3000".to_string())
+				.unwrap_or_else(|_| {
+					println!("INFO: PORT is not set, using default '3000'.");
+					"3000".to_string()
+				})
 				.parse()
 				.unwrap_or(3000),
-			access_token_secret: env::var("ACCESS_TOKEN_SECRET")
-				.unwrap_or_else(|_| "default_access_secret".to_string()),
-			refresh_token_secret: env::var("REFRESH_TOKEN_SECRET")
-				.unwrap_or_else(|_| "default_refresh_secret".to_string()),
-			surrealdb_url: env::var("SURREALDB_URL")
-				.unwrap_or_else(|_| "http://localhost:8000".to_string()),
-			surrealdb_username: env::var("SURREALDB_USERNAME")
-				.unwrap_or_else(|_| "root".to_string()),
-			surrealdb_password: env::var("SURREALDB_PASSWORD")
-				.unwrap_or_else(|_| "password".to_string()),
-			surrealdb_namespace: env::var("SURREALDB_NAMESPACE")
-				.unwrap_or_else(|_| "namespace".to_string()),
-			surrealdb_dbname: env::var("SURREALDB_DBNAME")
-				.unwrap_or_else(|_| "database".to_string()),
-			smtp_email: env::var("SMTP_EMAIL")
-				.unwrap_or_else(|_| "no-reply@example.com".to_string()),
-			smtp_password: env::var("SMTP_PASSWORD")
-				.unwrap_or_else(|_| "default_smtp_password".to_string()),
-			smtp_name: env::var("SMTP_NAME").unwrap_or_else(|_| "MyApp SMTP".to_string()),
-			smtp_host: env::var("SMTP_HOST")
-				.unwrap_or_else(|_| "smtp.gmail.com".to_string()),
-			redisdb_url: env::var("REDISDB_URL")
-				.unwrap_or_else(|_| "localhost".to_string()),
-			fe_url: env::var("FE_URL").unwrap_or_else(|_| "http://localhost".to_string()),
-			rust_env: env::var("RUST_ENV").unwrap_or_else(|_| "development".to_string()),
-			minio_endpoint: env::var("MINIO_ENDPOINT")
-				.unwrap_or_else(|_| "http://localhost:9000".to_string()),
-			minio_bucket_name: env::var("MINIO_BUCKET_NAME")
-				.unwrap_or_else(|_| "default_bucket".to_string()),
-			minio_access_key: env::var("MINIO_ACCESS_KEY")
-				.unwrap_or_else(|_| "minio_access".to_string()),
-			minio_secret_key: env::var("MINIO_SECRET_KEY")
-				.unwrap_or_else(|_| "minio_secret".to_string()),
+
+			rust_env: env::var("RUST_ENV").unwrap_or_else(|_| {
+				println!("INFO: RUST_ENV is not set, using default 'development'.");
+				"development".to_string()
+			}),
+
+			access_token_secret: env::var("ACCESS_TOKEN_SECRET").unwrap_or_else(|_| {
+				println!("WARNING: ACCESS_TOKEN_SECRET is not set, using fallback!");
+				"default_access_secret".to_string()
+			}),
+
+			refresh_token_secret: env::var("REFRESH_TOKEN_SECRET").unwrap_or_else(|_| {
+				println!("WARNING: REFRESH_TOKEN_SECRET is not set, using fallback!");
+				"default_refresh_secret".to_string()
+			}),
+
+			surrealdb_url: env::var("SURREALDB_URL").unwrap_or_else(|_| {
+				println!(
+					"WARNING: SURREALDB_URL is not set, using fallback 'http://localhost:8000'!"
+				);
+				"http://localhost:8000".to_string()
+			}),
+
+			surrealdb_username: env::var("SURREALDB_USERNAME").unwrap_or_else(|_| {
+				println!("WARNING: SURREALDB_USERNAME is not set, using fallback 'root'!");
+				"root".to_string()
+			}),
+
+			surrealdb_password: env::var("SURREALDB_PASSWORD").unwrap_or_else(|_| {
+				println!("WARNING: SURREALDB_PASSWORD is not set, using fallback!");
+				"password".to_string()
+			}),
+
+			surrealdb_namespace: env::var("SURREALDB_NAMESPACE").unwrap_or_else(|_| {
+				println!(
+					"WARNING: SURREALDB_NAMESPACE is not set, using fallback 'namespace'!"
+				);
+				"namespace".to_string()
+			}),
+
+			surrealdb_dbname: env::var("SURREALDB_DBNAME").unwrap_or_else(|_| {
+				println!("WARNING: SURREALDB_DBNAME is not set, using fallback 'database'!");
+				"database".to_string()
+			}),
+
+			smtp_email: env::var("SMTP_EMAIL").unwrap_or_else(|_| {
+				println!(
+					"WARNING: SMTP_EMAIL is not set, using fallback 'no-reply@example.com'!"
+				);
+				"no-reply@example.com".to_string()
+			}),
+
+			smtp_password: env::var("SMTP_PASSWORD").unwrap_or_else(|_| {
+				println!("WARNING: SMTP_PASSWORD is not set, using fallback!");
+				"default_smtp_password".to_string()
+			}),
+
+			smtp_name: env::var("SMTP_NAME").unwrap_or_else(|_| {
+				println!("WARNING: SMTP_NAME is not set, using fallback 'MyApp SMTP'!");
+				"MyApp SMTP".to_string()
+			}),
+
+			smtp_host: env::var("SMTP_HOST").unwrap_or_else(|_| {
+				println!("WARNING: SMTP_HOST is not set, using fallback 'smtp.gmail.com'!");
+				"smtp.gmail.com".to_string()
+			}),
+
+			redisdb_url: env::var("REDISDB_URL").unwrap_or_else(|_| {
+				println!("WARNING: REDISDB_URL is not set, using fallback 'localhost'!");
+				"localhost".to_string()
+			}),
+
+			fe_url: env::var("FE_URL").unwrap_or_else(|_| {
+				println!("WARNING: FE_URL is not set, using fallback 'http://localhost'!");
+				"http://localhost".to_string()
+			}),
+
+			minio_endpoint: env::var("MINIO_ENDPOINT").unwrap_or_else(|_| {
+				println!(
+					"WARNING: MINIO_ENDPOINT is not set, using fallback 'http://localhost:9000'!"
+				);
+				"http://localhost:9000".to_string()
+			}),
+
+			minio_bucket_name: env::var("MINIO_BUCKET_NAME").unwrap_or_else(|_| {
+				println!(
+					"WARNING: MINIO_BUCKET_NAME is not set, using fallback 'default_bucket'!"
+				);
+				"default_bucket".to_string()
+			}),
+
+			minio_access_key: env::var("MINIO_ACCESS_KEY").unwrap_or_else(|_| {
+				println!("WARNING: MINIO_ACCESS_KEY is not set, using fallback!");
+				"minio_access".to_string()
+			}),
+
+			minio_secret_key: env::var("MINIO_SECRET_KEY").unwrap_or_else(|_| {
+				println!("WARNING: MINIO_SECRET_KEY is not set, using fallback!");
+				"minio_secret".to_string()
+			}),
 		}
 	}
 }
+
+impl Default for Env {
+	fn default() -> Self {
+		Self::new()
+	}
+}

imphnen-libs/src/surrealdb/mod.rs

@@ -1,17 +1,20 @@
 use super::Env;
-use crate::{SurrealMemClient, SurrealWsClient};
+use crate::SurrealMemClient;
 use surrealdb::engine::local::Mem;
-use surrealdb::engine::remote::ws::{Client, Ws};
+use surrealdb::engine::any;
 use surrealdb::opt::auth::Root;
 use surrealdb::{Result, Surreal};
+use crate::enviroment::load_env;
 
 pub mod resource;
 pub use resource::*;
 
-pub async fn surrealdb_init_ws() -> Result<SurrealWsClient> {
+pub async fn surrealdb_init_ws() -> Result<Surreal<any::Any>> {
+	load_env();
 	let env = Env::new();
-	let db = Surreal::<Client>::init();
-	db.connect::<Ws>(env.surrealdb_url.clone()).await?;
+	let db = any::connect(&env.surrealdb_url).await?;
+	
+
 	db.signin(Root {
 		username: &env.surrealdb_username,
 		password: &env.surrealdb_password,

imphnen-libs/src/surrealdb/resource.rs

@@ -7,10 +7,13 @@ pub enum ResourceEnum {
 	GachaItems,
 	GachaClaims,
 	GachaRolls,
+	GachaCredits,
 	Users,
 	Roles,
 	Permissions,
 	RolesPermissions,
+	Events,
+	Testimonials,
 }
 
 impl fmt::Display for ResourceEnum {
@@ -25,6 +28,9 @@ impl fmt::Display for ResourceEnum {
 			ResourceEnum::GachaItems => "app_gacha_items",
 			ResourceEnum::GachaClaims => "app_gacha_claims",
 			ResourceEnum::GachaRolls => "app_gacha_rolls",
+			ResourceEnum::GachaCredits => "app_gacha_credits",
+			ResourceEnum::Events => "app_events",
+			ResourceEnum::Testimonials => "app_testimonials",
 		};
 		write!(f, "{}", str)
 	}

imphnen-middleware/src/permissions_middleware/mod.rs

@@ -50,16 +50,13 @@ where
 	type Response = S::Response;
 	type Error = S::Error;
 	type Future = BoxFuture<'static, Result<Self::Response, Self::Error>>;
-
 	fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
 		self.inner.poll_ready(cx)
 	}
-
 	fn call(&mut self, req: Request<Body>) -> Self::Future {
 		let mut inner = self.inner.clone();
 		let app_state = self.app_state.clone();
 		let permissions = self.permissions.clone();
-
 		Box::pin(async move {
 			let headers = req.headers();
 			let email = match extract_email(headers) {
@@ -71,7 +68,6 @@ where
 					));
 				}
 			};
-
 			let auth_repo = AuthRepository::new(&app_state);
 			let user = match auth_repo.query_get_stored_user(email).await {
 				Ok(user) => user,
@@ -82,20 +78,17 @@ where
 					));
 				}
 			};
-
 			let user_permissions: Vec<String> =
 				user.role.permissions.into_iter().map(|p| p.name).collect();
 			let allowed = permissions
 				.iter()
 				.all(|p| user_permissions.contains(&p.to_string()));
-
 			if !allowed {
 				return Ok(common_response(
 					StatusCode::FORBIDDEN,
 					"You don't have the required permissions",
 				));
 			}
-
 			inner.call(req).await
 		})
 	}

imphnen-utils/src/bind_filter.rs

@@ -1,8 +1,9 @@
-use surrealdb::{engine::remote::ws::Client, method::Query};
+use surrealdb::method::Query;
+use surrealdb::engine::any;
 
 pub fn bind_filter_value(
-	query: Query<'_, Client>,
+	query: Query<'_, any::Any>,
 	val: String,
-) -> Query<'_, Client> {
+) -> Query<'_, any::Any> {
 	query.bind(("filter", val)) // langsung string aja, udah cukup
 }

imphnen-utils/src/mock_test.rs

@@ -1,13 +1,14 @@
 use crate::AppState;
-use surrealdb::{
-	Surreal,
-	engine::{local::Mem, remote::ws::Ws},
-	opt::auth::Root,
-};
+use imphnen_libs::enviroment::load_env;
+use surrealdb::engine::any;
+use surrealdb::{Surreal, engine::local::Mem, opt::auth::Root};
+use super::Env;
 
 pub async fn create_mock_app_state() -> AppState {
+	load_env();
+	let env = Env::new();
 	let db_mem = Surreal::new::<Mem>(()).await.unwrap();
-	let db_ws = Surreal::new::<Ws>("localhost:8000").await.unwrap();
+	let db_ws = any::connect(&env.surrealdb_url).await.unwrap();
 	db_mem.use_ns("test").use_db("test").await.unwrap();
 	db_ws
 		.signin(Root {

imphnen-utils/src/query_builder.rs

@@ -1,7 +1,7 @@
 use imphnen_libs::MetaRequestDto;
-use surrealdb::engine::remote::ws::Client;
 use surrealdb::method::Query;
 use surrealdb::sql::Thing;
+use surrealdb::engine::any;
 
 pub struct ListQueryBuilder {
 	resource: String,
@@ -241,7 +241,7 @@ impl DetailQueryBuilder {
 		)
 	}
 
-	pub fn apply_bindings<'q>(&self, query: Query<'q, Client>) -> Query<'q, Client> {
+	pub fn apply_bindings<'q>(&self, query: Query<'q, any::Any>) -> Query<'q, any::Any> {
 		if let (Some(_), Some(value)) = (&self.where_field, &self.where_value) {
 			query.bind(("value", value.clone()))
 		} else {

imphnen-utils/src/query_list.rs

@@ -1,78 +1,117 @@
-use super::{ListQueryBuilder, bind_filter_value};
 use crate::{CountResult, MetaRequestDto, MetaResponseDto, ResponseListSuccessDto};
 use anyhow::Result;
 use serde::{Serialize, de::DeserializeOwned};
-use surrealdb::{Surreal, engine::remote::ws::Client};
+use surrealdb::Surreal;
+use surrealdb::engine::any;
 
-pub async fn query_list_with_meta<T>(
-	db: &Surreal<Client>,
-	table: &str,
-	meta: &MetaRequestDto,
+pub struct QueryListBuilder<'a> {
+	db: &'a Surreal<any::Any>,
+	table: &'a str,
+	meta: &'a MetaRequestDto,
 	conditions: Vec<String>,
-	custom_select: Option<String>,
-	search_field: &str,
-	select_fields: Option<Vec<&str>>,
-	fetch_fields: Option<Vec<&str>>,
-) -> Result<ResponseListSuccessDto<Vec<T>>>
-where
-	T: DeserializeOwned + Serialize,
-{
-	let page = meta.page.unwrap_or(1).max(1);
-	let per_page = meta.per_page.unwrap_or(10).max(1);
-	let start = (page - 1) * per_page;
+	search_field: String,
+	select_fields: Option<Vec<&'a str>>,
+	fetch_fields: Option<Vec<&'a str>>,
+}
 
-	let sql = custom_select.unwrap_or_else(|| {
-		ListQueryBuilder::from_meta(
+impl<'a> QueryListBuilder<'a> {
+	pub fn new(
+		db: &'a Surreal<any::Any>,
+		table: &'a str,
+		meta: &'a MetaRequestDto,
+	) -> Self {
+		Self {
+			db,
 			table,
 			meta,
-			search_field,
-			select_fields,
-			fetch_fields,
+			conditions: vec![],
+			search_field: "name".to_string(),
+			select_fields: None,
+			fetch_fields: None,
+		}
+	}
+
+	pub fn search_field(mut self, field: &'a str) -> Self {
+		self.search_field = field.to_string();
+		self
+	}
+
+	pub fn select_fields(mut self, fields: Vec<&'a str>) -> Self {
+		self.select_fields = Some(fields);
+		self
+	}
+
+	pub fn fetch_fields(mut self, fields: Vec<&'a str>) -> Self {
+		self.fetch_fields = Some(fields);
+		self
+	}
+
+	pub fn with_condition(mut self, condition: &str) -> Self {
+		self.conditions.push(condition.to_string());
+		self
+	}
+
+	pub async fn build<T>(self) -> Result<ResponseListSuccessDto<Vec<T>>>
+	where
+		T: DeserializeOwned + Serialize,
+	{
+		let page = self.meta.page.unwrap_or(1).max(1);
+		let per_page = self.meta.per_page.unwrap_or(10).max(1);
+		let start = (page - 1) * per_page;
+
+		let sql = crate::ListQueryBuilder::from_meta(
+			self.table,
+			self.meta,
+			&self.search_field,
+			self.select_fields,
+			self.fetch_fields,
 		)
-		.build()
-	});
+		.build();
 
-	let mut query_exec = db.query(sql);
-	if let Some(search) = &meta.search {
-		if !search.is_empty() {
-			query_exec = query_exec.bind(("search", search.to_lowercase().clone()));
+		let mut query_exec = self.db.query(sql);
+		if let Some(search) = &self.meta.search {
+			if !search.is_empty() {
+				query_exec = query_exec.bind(("search", search.to_lowercase()));
+			}
 		}
-	}
-	if let Some(filter_val) = &meta.filter {
-		query_exec = bind_filter_value(query_exec, filter_val.clone());
-	}
-	query_exec = query_exec
-		.bind(("per_page", per_page))
-		.bind(("start", start));
-
-	let raw: Vec<T> = query_exec.await?.take(0)?;
-
-	let mut count_query = db.query(format!(
-		"SELECT count() FROM {} {}",
-		table,
-		if conditions.is_empty() {
-			String::new()
-		} else {
-			format!("WHERE {}", conditions.join(" AND "))
+		if let Some(filter_val) = &self.meta.filter {
+			query_exec = crate::bind_filter_value(query_exec, filter_val.clone());
 		}
-	));
-	if let Some(search) = &meta.search {
-		if !search.is_empty() {
-			count_query = count_query.bind(("search", search.clone()));
-		}
-	}
-	if let Some(filter_val) = &meta.filter {
-		count_query = bind_filter_value(count_query, filter_val.clone());
-	}
-	let count_result: Vec<CountResult> = count_query.await?.take(0)?;
-	let total = count_result.first().map(|c| c.count);
+		query_exec = query_exec
+			.bind(("per_page", per_page))
+			.bind(("start", start));
 
-	Ok(ResponseListSuccessDto {
-		data: raw,
-		meta: Some(MetaResponseDto {
-			page: Some(page),
-			per_page: Some(per_page),
-			total,
-		}),
-	})
+		let raw: Vec<T> = query_exec.await?.take(0)?;
+
+		let mut count_query = self.db.query(format!(
+			"SELECT count() FROM {} {}",
+			self.table,
+			if self.conditions.is_empty() {
+				"".into()
+			} else {
+				format!("WHERE {}", self.conditions.join(" AND "))
+			}
+		));
+
+		if let Some(search) = &self.meta.search {
+			if !search.is_empty() {
+				count_query = count_query.bind(("search", search.clone()));
+			}
+		}
+		if let Some(filter_val) = &self.meta.filter {
+			count_query = crate::bind_filter_value(count_query, filter_val.clone());
+		}
+
+		let count_result: Vec<CountResult> = count_query.await?.take(0)?;
+		let total = count_result.first().map(|c| c.count);
+
+		Ok(ResponseListSuccessDto {
+			data: raw,
+			meta: Some(MetaResponseDto {
+				page: Some(page),
+				per_page: Some(per_page),
+				total,
+			}),
+		})
+	}
 }

tests/src/iam/auth/auth_controller_test.rs

@@ -1,667 +0,0 @@
-use crate::{
-	AuthOtpSchema, AuthRepository, OtpManager, ResourceEnum, RolesRepository,
-	UsersRepository, auth::auth_router, create_mock_app_state, create_test_user,
-	encode_refresh_token,
-};
-use axum::{Extension, http::StatusCode};
-use axum_test::TestServer;
-use serde_json::json;
-use surrealdb::Uuid;
-
-#[tokio::test]
-async fn test_login_should_fail_with_invalid_user() {
-	let state = create_mock_app_state().await;
-	let app = axum::Router::new()
-		.nest("/v1/auth", auth_router())
-		.layer(Extension(state));
-	let server = TestServer::new(app).unwrap();
-	let payload = json!({
-		"email": "nonexistent@example.com",
-		"password": "wrongpassword"
-	});
-	let res = server.post("/v1/auth/login").json(&payload).await;
-	assert_eq!(res.status_code(), StatusCode::UNAUTHORIZED);
-	let body = res.text();
-	println!("🧪 Response Body: {}", body);
-}
-
-#[tokio::test]
-async fn test_login_should_fail_with_wrong_password() {
-	let state = create_mock_app_state().await;
-	let app = axum::Router::new()
-		.nest("/v1/auth", auth_router())
-		.layer(Extension(state.clone()));
-	let server = TestServer::new(app).unwrap();
-	let repo = UsersRepository::new(&state);
-	let role_repo = RolesRepository::new(&state);
-	let role_id = role_repo
-		.query_role_by_name("Student".to_string())
-		.await
-		.unwrap()
-		.id;
-	let mut user = create_test_user("user@example.com", "User Satu", true, &role_id);
-	user.password = crate::hash_password("correctpassword").unwrap();
-	repo.query_create_user(user).await.unwrap();
-	let payload = json!({
-		"email": "user@example.com",
-		"password": "wrongpassword"
-	});
-	let res = server.post("/v1/auth/login").json(&payload).await;
-	assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
-	let body = res.text();
-	println!("🧪 Wrong password: {}", body);
-}
-
-#[tokio::test]
-async fn test_login_should_fail_if_user_not_active() {
-	let state = create_mock_app_state().await;
-	let app = axum::Router::new()
-		.nest("/v1/auth", auth_router())
-		.layer(Extension(state.clone()));
-	let server = TestServer::new(app).unwrap();
-	let repo = UsersRepository::new(&state);
-	let role_repo = RolesRepository::new(&state);
-	let role_id = role_repo
-		.query_role_by_name("Student".to_string())
-		.await
-		.unwrap()
-		.id;
-	let mut user = create_test_user(
-		"inactive-again@example.com",
-		"Inactive User",
-		false,
-		&role_id,
-	);
-	user.password = crate::hash_password("secret").unwrap();
-	repo.query_create_user(user).await.unwrap();
-	let payload = json!({
-		"email": "inactive-again@example.com",
-		"password": "secret"
-	});
-	let res = server.post("/v1/auth/login").json(&payload).await;
-	dbg!(res.text());
-	assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
-	let body = res.text();
-	println!("🧪 Not active user: {}", body);
-}
-
-#[tokio::test]
-async fn test_login_should_succeed() {
-	let state = create_mock_app_state().await;
-	let app = axum::Router::new()
-		.nest("/v1/auth", auth_router())
-		.layer(Extension(state.clone()));
-	let server = TestServer::new(app).unwrap();
-	let repo = UsersRepository::new(&state);
-	let role_repo = RolesRepository::new(&state);
-	let role_id = role_repo
-		.query_role_by_name("Student".to_string())
-		.await
-		.unwrap()
-		.id;
-	let mut user =
-		create_test_user("active@example.com", "Active User", true, &role_id);
-	user.password = crate::hash_password("secret").unwrap();
-	repo.query_create_user(user).await.unwrap();
-	let payload = json!({
-		"email": "active@example.com",
-		"password": "secret"
-	});
-	let res = server.post("/v1/auth/login").json(&payload).await;
-	assert_eq!(res.status_code(), StatusCode::OK);
-	let json = res.json::<serde_json::Value>();
-	assert!(json["data"]["token"]["access_token"].is_string());
-	assert!(json["data"]["user"]["email"] == "active@example.com");
-}
-
-#[tokio::test]
-async fn test_login_should_fail_if_payload_empty() {
-	let state = create_mock_app_state().await;
-	let app = axum::Router::new()
-		.nest("/v1/auth", auth_router())
-		.layer(Extension(state));
-	let server = TestServer::new(app).unwrap();
-	let payload = json!({});
-	let res = server.post("/v1/auth/login").json(&payload).await;
-	assert_eq!(res.status_code(), StatusCode::UNPROCESSABLE_ENTITY);
-}
-
-#[tokio::test]
-async fn test_login_should_fail_if_password_empty() {
-	let state = create_mock_app_state().await;
-	let app = axum::Router::new()
-		.nest("/v1/auth", auth_router())
-		.layer(Extension(state));
-	let server = TestServer::new(app).unwrap();
-	let payload = json!({
-			"email": "test@test.com",
-			"password": ""
-	});
-	let res = server.post("/v1/auth/login").json(&payload).await;
-	assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
-}
-
-#[tokio::test]
-async fn test_login_should_fail_if_email_not_valid() {
-	let state = create_mock_app_state().await;
-	let app = axum::Router::new()
-		.nest("/v1/auth", auth_router())
-		.layer(Extension(state));
-	let server = TestServer::new(app).unwrap();
-	let payload = json!({
-			"email": "test",
-			"password": "test123"
-	});
-	let res = server.post("/v1/auth/login").json(&payload).await;
-	assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
-}
-
-#[tokio::test]
-async fn test_register_should_succeed() {
-	let state = create_mock_app_state().await;
-	let app = axum::Router::new()
-		.nest("/v1/auth", auth_router())
-		.layer(Extension(state.clone()));
-	let server = TestServer::new(app).unwrap();
-	let random_email = format!("validuser+{}@example.com", Uuid::new_v4());
-	let payload = json!({
-		"email": random_email,
-		"password": "Validpass1!",
-		"fullname": "Valid User",
-		"student_type": "regular",
-		"phone_number": "0812345678",
-		"reffered_by": "Facebook",
-		"refferal_code": "KFNB"
-	});
-	let res = server.post("/v1/auth/register").json(&payload).await;
-	assert_eq!(res.status_code(), StatusCode::CREATED);
-}
-
-#[tokio::test]
-async fn test_register_should_fail_if_email_already_taken() {
-	let state = create_mock_app_state().await;
-	let app = axum::Router::new()
-		.nest("/v1/auth", auth_router())
-		.layer(Extension(state.clone()));
-	let server = TestServer::new(app).unwrap();
-	let repo = UsersRepository::new(&state);
-	let role_repo = RolesRepository::new(&state);
-	let role_id = role_repo
-		.query_role_by_name("Student".to_string())
-		.await
-		.unwrap()
-		.id;
-	let mut user =
-		create_test_user("duplicate@example.com", "User Exists", false, &role_id);
-	user.password = crate::hash_password("secret").unwrap();
-	repo.query_create_user(user).await.unwrap();
-	let payload = json!({
-		"fullname": "User Exists",
-		"email": "duplicate@example.com",
-		"password": "secret",
-		"student_type": "general",
-		"phone_number": "081234567890",
-		"referral_code": null,
-		"referred_by": null
-	});
-	let res = server.post("/v1/auth/register").json(&payload).await;
-	assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
-}
-
-#[tokio::test]
-async fn test_register_should_fail_if_email_invalid() {
-	let state = create_mock_app_state().await;
-	let app = axum::Router::new()
-		.nest("/v1/auth", auth_router())
-		.layer(Extension(state));
-	let server = TestServer::new(app).unwrap();
-	let payload = json!({
-		"fullname": "Invalid Email",
-		"email": "invalid-email",
-		"password": "secret",
-		"student_type": "general",
-		"phone_number": "081234567890",
-		"referral_code": null,
-		"referred_by": null
-	});
-	let res = server.post("/v1/auth/register").json(&payload).await;
-	assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
-}
-
-#[tokio::test]
-async fn test_register_should_fail_if_password_empty() {
-	let state = create_mock_app_state().await;
-	let app = axum::Router::new()
-		.nest("/v1/auth", auth_router())
-		.layer(Extension(state));
-	let server = TestServer::new(app).unwrap();
-
-	let payload = json!({
-		"fullname": "No Password",
-		"email": "nopass@example.com",
-		"password": "",
-		"student_type": "general",
-		"phone_number": "081234567890",
-		"referral_code": null,
-		"referred_by": null
-	});
-	let res = server.post("/v1/auth/register").json(&payload).await;
-	assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
-}
-
-#[tokio::test]
-async fn test_register_should_fail_if_payload_empty() {
-	let state = create_mock_app_state().await;
-	let app = axum::Router::new()
-		.nest("/v1/auth", auth_router())
-		.layer(Extension(state));
-	let server = TestServer::new(app).unwrap();
-	let payload = json!({});
-	let res = server.post("/v1/auth/register").json(&payload).await;
-	assert_eq!(res.status_code(), StatusCode::UNPROCESSABLE_ENTITY);
-}
-
-#[tokio::test]
-async fn test_send_otp_should_succeed() {
-	let state = create_mock_app_state().await;
-	let app = axum::Router::new()
-		.nest("/v1/auth", auth_router())
-		.layer(Extension(state));
-	let server = TestServer::new(app).unwrap();
-	let payload = json!({
-		"email": "user@example.com"
-	});
-	let res = server.post("/v1/auth/send-otp").json(&payload).await;
-	assert_eq!(res.status_code(), StatusCode::OK);
-	let json = res.json::<serde_json::Value>();
-	assert_eq!(json["message"], "OTP resent successfully");
-}
-
-#[tokio::test]
-async fn test_send_otp_should_fail_if_email_empty() {
-	let state = create_mock_app_state().await;
-	let app = axum::Router::new()
-		.nest("/v1/auth", auth_router())
-		.layer(Extension(state));
-	let server = TestServer::new(app).unwrap();
-	let payload = json!({ "email": "" });
-	let res = server.post("/v1/auth/send-otp").json(&payload).await;
-	assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
-	let json = res.json::<serde_json::Value>();
-	assert_eq!(json["message"], "Email cannot be empty, Email not valid");
-}
-
-#[tokio::test]
-async fn test_send_otp_should_fail_with_invalid_email_format() {
-	let state = create_mock_app_state().await;
-	let app = axum::Router::new()
-		.nest("/v1/auth", auth_router())
-		.layer(Extension(state));
-	let server = TestServer::new(app).unwrap();
-
-	let payload = json!({ "email": "not-an-email" });
-	let res = server.post("/v1/auth/send-otp").json(&payload).await;
-	assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
-	let json = res.json::<serde_json::Value>();
-	assert_eq!(json["message"], "Email not valid");
-}
-
-#[tokio::test]
-async fn test_send_otp_should_fail_if_payload_empty() {
-	let state = create_mock_app_state().await;
-	let app = axum::Router::new()
-		.nest("/v1/auth", auth_router())
-		.layer(Extension(state));
-	let server = TestServer::new(app).unwrap();
-	let payload = json!({});
-	let res = server.post("/v1/auth/send-otp").json(&payload).await;
-	assert_eq!(res.status_code(), StatusCode::UNPROCESSABLE_ENTITY);
-}
-
-#[tokio::test]
-async fn test_send_otp_should_fail_if_otp_store_fails() {
-	let mut state = create_mock_app_state().await;
-	state.surrealdb_mem = surrealdb::Surreal::new::<surrealdb::engine::local::Mem>(())
-		.await
-		.expect("failed to create mock surrealdb_mem");
-	let app = axum::Router::new()
-		.nest("/v1/auth", auth_router())
-		.layer(Extension(state));
-	let server = TestServer::new(app).unwrap();
-	let payload = serde_json::json!({ "email": "fail-store@example.com" });
-	let res = server.post("/v1/auth/send-otp").json(&payload).await;
-	assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
-	let body = res.text();
-	assert!(
-		body.contains("Specify a namespace to use") || body.contains("Failed store otp"),
-		"Expected namespace setup error or store failure, got: {body}"
-	);
-}
-
-#[tokio::test]
-async fn test_forgot_password_should_succeed() {
-	let state = create_mock_app_state().await;
-	let app = axum::Router::new()
-		.nest("/v1/auth", auth_router())
-		.layer(Extension(state.clone()));
-	let server = TestServer::new(app).unwrap();
-	let role_repo = RolesRepository::new(&state);
-	let role_id = role_repo
-		.query_role_by_name("Student".to_string())
-		.await
-		.unwrap()
-		.id;
-	let mut user =
-		create_test_user("forgot@example.com", "Forgot User", true, &role_id);
-	user.password = crate::hash_password("secret").unwrap();
-	let user_repo = UsersRepository::new(&state);
-	user_repo.query_create_user(user).await.unwrap();
-	let payload = json!({ "email": "forgot@example.com" });
-	let res = server.post("/v1/auth/forgot").json(&payload).await;
-	dbg!(res.text());
-	assert_eq!(res.status_code(), StatusCode::OK);
-	let body = res.text();
-	assert!(
-		body.contains("Reset Password request send"),
-		"Unexpected response: {body}"
-	);
-}
-
-#[tokio::test]
-async fn test_forgot_password_should_fail_if_user_not_found() {
-	let state = create_mock_app_state().await;
-	let app = axum::Router::new()
-		.nest("/v1/auth", auth_router())
-		.layer(Extension(state));
-	let server = TestServer::new(app).unwrap();
-	let payload = json!({ "email": "notfound@example.com" });
-	let res = server.post("/v1/auth/forgot").json(&payload).await;
-	assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
-	let body = res.text();
-	assert!(
-		body.contains("User not found"),
-		"Expected 'User not found', got: {body}"
-	);
-}
-
-#[tokio::test]
-async fn test_forgot_password_should_fail_if_email_invalid() {
-	let state = create_mock_app_state().await;
-	let app = axum::Router::new()
-		.nest("/v1/auth", auth_router())
-		.layer(Extension(state));
-	let server = TestServer::new(app).unwrap();
-	let payload = json!({ "email": "" });
-	let res = server.post("/v1/auth/forgot").json(&payload).await;
-	assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
-	let body = res.text();
-	assert!(
-		body.contains("Email not valid") || body.contains("User not found"),
-		"Expected email error, got: {body}"
-	);
-}
-
-#[tokio::test]
-async fn test_refresh_should_succeed() {
-	let state = create_mock_app_state().await;
-	let app = axum::Router::new()
-		.nest("/v1/auth", auth_router())
-		.layer(Extension(state));
-	let server = TestServer::new(app).unwrap();
-	let valid_token = encode_refresh_token("refreshme@example.com".into()).unwrap();
-	let payload = json!({
-		"refresh_token": valid_token
-	});
-	let res = server.post("/v1/auth/refresh").json(&payload).await;
-	assert_eq!(res.status_code(), StatusCode::OK);
-	let body = res.json::<serde_json::Value>();
-	assert!(body["data"]["access_token"].is_string());
-	assert!(body["data"]["refresh_token"].is_string());
-}
-
-#[tokio::test]
-async fn test_refresh_should_fail_with_invalid_token() {
-	let state = create_mock_app_state().await;
-	let app = axum::Router::new()
-		.nest("/v1/auth", auth_router())
-		.layer(Extension(state));
-	let server = TestServer::new(app).unwrap();
-	let payload = json!({
-		"refresh_token": "invalid.token.value"
-	});
-	let res = server.post("/v1/auth/refresh").json(&payload).await;
-	assert_eq!(res.status_code(), StatusCode::UNAUTHORIZED);
-	let body = res.text();
-	assert!(body.contains("Invalid refresh token"));
-}
-
-#[tokio::test]
-async fn test_refresh_should_fail_with_empty_payload() {
-	let state = create_mock_app_state().await;
-	let app = axum::Router::new()
-		.nest("/v1/auth", auth_router())
-		.layer(Extension(state));
-	let server = TestServer::new(app).unwrap();
-	let payload = json!({});
-	let res = server.post("/v1/auth/refresh").json(&payload).await;
-	assert_eq!(res.status_code(), StatusCode::UNPROCESSABLE_ENTITY);
-}
-
-#[tokio::test]
-async fn test_verify_email_should_succeed() {
-	let state = create_mock_app_state().await;
-	let server = TestServer::new(
-		axum::Router::new()
-			.nest("/v1/auth", auth_router())
-			.layer(Extension(state.clone())),
-	)
-	.unwrap();
-	let role_repo = RolesRepository::new(&state);
-	let role_id = role_repo
-		.query_role_by_name("Student".to_string())
-		.await
-		.unwrap()
-		.id;
-	let user = create_test_user("verify@example.com", "Verify User", false, &role_id);
-	let otp = OtpManager::generate_otp();
-	let user_repo = UsersRepository::new(&state);
-	let auth_repo = AuthRepository::new(&state);
-	user_repo.query_create_user(user.clone()).await.unwrap();
-	auth_repo
-		.query_store_otp(user.email.clone(), otp)
-		.await
-		.unwrap();
-	let payload = json!({
-		"email": user.email,
-		"otp": otp
-	});
-	let res = server.post("/v1/auth/verify-email").json(&payload).await;
-	assert_eq!(res.status_code(), StatusCode::OK);
-	let body = res.text();
-	assert!(body.contains("Email verified successfully"));
-}
-
-#[tokio::test]
-async fn test_verify_email_should_fail_with_wrong_otp() {
-	let state = create_mock_app_state().await;
-	let server = TestServer::new(
-		axum::Router::new()
-			.nest("/v1/auth", auth_router())
-			.layer(Extension(state.clone())),
-	)
-	.unwrap();
-	let role_repo = RolesRepository::new(&state);
-	let role_id = role_repo
-		.query_role_by_name("Student".to_string())
-		.await
-		.unwrap()
-		.id;
-	let user = create_test_user("wrongotp@example.com", "Wrong OTP", false, &role_id);
-	let otp = OtpManager::generate_otp();
-	let user_repo = UsersRepository::new(&state);
-	let auth_repo = AuthRepository::new(&state);
-	user_repo.query_create_user(user.clone()).await.unwrap();
-	auth_repo
-		.query_store_otp(user.email.clone(), otp)
-		.await
-		.unwrap();
-	let payload = json!({
-		"email": user.email,
-		"otp": 999_999
-	});
-	let res = server.post("/v1/auth/verify-email").json(&payload).await;
-	assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
-	let body = res.text();
-	assert!(body.contains("Failed to verify OTP"));
-}
-
-#[tokio::test]
-async fn test_verify_email_should_fail_if_otp_expired() {
-	let state = create_mock_app_state().await;
-	let server = TestServer::new(
-		axum::Router::new()
-			.nest("/v1/auth", auth_router())
-			.layer(Extension(state.clone())),
-	)
-	.unwrap();
-	let role_repo = RolesRepository::new(&state);
-	let role_id = role_repo
-		.query_role_by_name("Student".to_string())
-		.await
-		.unwrap()
-		.id;
-	let user = create_test_user("expired@example.com", "Expired OTP", false, &role_id);
-	let user_repo = UsersRepository::new(&state);
-	user_repo.query_create_user(user.clone()).await.unwrap();
-	use chrono::{Duration, Utc};
-	let expired_otp = AuthOtpSchema {
-		otp: 123456,
-		expires_at: Utc::now() - Duration::minutes(1),
-	};
-	let _: Option<AuthOtpSchema> = state
-		.surrealdb_mem
-		.create((ResourceEnum::OtpCache.to_string(), user.email.clone()))
-		.content(expired_otp)
-		.await
-		.unwrap();
-	let payload = json!({
-		"email": user.email,
-		"otp": 123456
-	});
-	let res = server.post("/v1/auth/verify-email").json(&payload).await;
-	assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
-	let body = res.text();
-	assert!(body.contains("OTP expired"));
-}
-
-#[tokio::test]
-async fn test_verify_email_should_fail_with_empty_payload() {
-	let state = create_mock_app_state().await;
-	let server = TestServer::new(
-		axum::Router::new()
-			.nest("/v1/auth", auth_router())
-			.layer(Extension(state)),
-	)
-	.unwrap();
-	let res = server.post("/v1/auth/verify-email").json(&json!({})).await;
-	assert_eq!(res.status_code(), StatusCode::UNPROCESSABLE_ENTITY);
-}
-
-#[tokio::test]
-async fn test_new_password_should_succeed() {
-	let state = create_mock_app_state().await;
-	let server = TestServer::new(
-		axum::Router::new()
-			.nest("/v1/auth", auth_router())
-			.layer(Extension(state.clone())),
-	)
-	.unwrap();
-	let email = "resetme@example.com";
-	let repo = UsersRepository::new(&state);
-	let role_repo = RolesRepository::new(&state);
-	let role_id = role_repo
-		.query_role_by_name("Student".to_string())
-		.await
-		.unwrap()
-		.id;
-	let mut user = create_test_user(email, "Reset User", true, &role_id);
-	user.password = crate::hash_password("oldpass123!").unwrap();
-	repo.query_create_user(user).await.unwrap();
-	let token = crate::encode_reset_password_token(email.to_string()).unwrap();
-	let payload = json!({
-		"token": token,
-		"password": "Newpass123!"
-	});
-	let res = server.post("/v1/auth/new-password").json(&payload).await;
-	assert_eq!(res.status_code(), StatusCode::OK);
-	let body = res.text();
-	assert!(body.contains("Success update password user"));
-}
-
-#[tokio::test]
-async fn test_new_password_should_fail_if_token_is_empty() {
-	let state = create_mock_app_state().await;
-	let server = TestServer::new(
-		axum::Router::new()
-			.nest("/v1/auth", auth_router())
-			.layer(Extension(state)),
-	)
-	.unwrap();
-	let payload = json!({
-		"token": "",
-		"password": "Newpass123!"
-	});
-	let res = server.post("/v1/auth/new-password").json(&payload).await;
-	assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
-	let body = res.text();
-	assert!(
-		body.contains("Invalid or missing token"),
-		"Gagal deteksi token kosong: {body}"
-	);
-}
-
-#[tokio::test]
-async fn test_new_password_should_fail_if_password_is_weak() {
-	let state = create_mock_app_state().await;
-	let server = TestServer::new(
-		axum::Router::new()
-			.nest("/v1/auth", auth_router())
-			.layer(Extension(state)),
-	)
-	.unwrap();
-	let email = "weakpass@example.com";
-	let token = crate::encode_reset_password_token(email.to_string()).unwrap();
-	let payload = json!({
-		"token": token,
-		"password": "123"
-	});
-	let res = server.post("/v1/auth/new-password").json(&payload).await;
-	assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
-	let body = res.text();
-	assert!(
-		body.contains("Password must have at least")
-			|| body.contains("Password must include"),
-		"Pesan error nggak sesuai: {body}"
-	);
-}
-
-#[tokio::test]
-async fn test_new_password_should_fail_if_user_not_found() {
-	let state = create_mock_app_state().await;
-	let server = TestServer::new(
-		axum::Router::new()
-			.nest("/v1/auth", auth_router())
-			.layer(Extension(state)),
-	)
-	.unwrap();
-	let token =
-		crate::encode_reset_password_token("ghost@example.com".into()).unwrap();
-	let payload = json!({
-		"token": token,
-		"password": "Validpass123!"
-	});
-	let res = server.post("/v1/auth/new-password").json(&payload).await;
-	assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
-	let body = res.text();
-	assert!(body.contains("User not found"));
-}

tests/src/iam/auth/auth_repository_test.rs

@@ -2,13 +2,14 @@
 mod auth_repository_test {
 	use crate::{
 		AuthOtpSchema, AuthRepository, ResourceEnum, UsersRepository, UsersSchema,
-		create_mock_app_state, get_iso_date, make_thing,
+		create_mock_app_state, generate_unique_email, get_iso_date, get_role_id,
+		make_thing,
 	};
 	use chrono::{Duration, Utc};
-	use imphnen_iam::{RolesDetailQueryDto, UsersDetailQueryDto};
+	use imphnen_iam::{AppState, RolesDetailQueryDto, UsersDetailQueryDto};
 	use surrealdb::Uuid;
 
-	fn create_mock_user(email: &str) -> UsersSchema {
+	async fn create_mock_user(state: &AppState, email: &str) -> UsersSchema {
 		UsersSchema {
 			id: make_thing("app_users", &Uuid::new_v4().to_string()),
 			email: email.to_string(),
@@ -20,7 +21,7 @@ mod auth_repository_test {
 			is_active: true,
 			gender: None,
 			birthdate: None,
-			role: make_thing("roles", "user"),
+			role: make_thing("app_roles", &get_role_id(state).await),
 			created_at: get_iso_date(),
 			updated_at: get_iso_date(),
 		}
@@ -30,10 +31,13 @@ mod auth_repository_test {
 	async fn test_store_and_get_user() {
 		let app_state = create_mock_app_state().await;
 		let repo = AuthRepository::new(&app_state);
-		let user = create_mock_user("forgot@example.com");
+		let email = generate_unique_email("forgot");
+		let user = create_mock_user(&app_state, &email).await;
 		let user_repo = UsersRepository::new(&app_state);
+		let create_user = user_repo.query_create_user(user.clone()).await;
+		assert!(create_user.is_ok());
 		let user_data = user_repo
-			.query_user_by_email("forgot@example.com".to_string())
+			.query_user_by_email(email.to_string())
 			.await
 			.unwrap();
 		let store = repo.query_store_user(user_data.clone()).await;

tests/src/iam/auth/mod.rs

@@ -1,4 +1,2 @@
 #[cfg(test)]
-pub mod auth_controller_test;
-#[cfg(test)]
 pub mod auth_repository_test;

tests/src/iam/permissions/mod.rs

@@ -1,4 +1,2 @@
 #[cfg(test)]
-pub mod permissions_controller_test;
-#[cfg(test)]
 pub mod permissions_repository_test;

tests/src/iam/permissions/permissions_controller_test.rs

@@ -1,171 +0,0 @@
-use crate::{
-	create_mock_app_state, permissions_router,
-	v1::{
-		permissions_dto::PermissionsRequestDto,
-		permissions_repository::PermissionsRepository,
-	},
-	AppState,
-};
-use axum::{http::StatusCode, Extension, Router};
-use axum_test::TestServer;
-
-pub fn create_test_app(state: AppState) -> TestServer {
-	let app = Router::new()
-		.nest("/v1/permissions", permissions_router())
-		.layer(Extension(state));
-	TestServer::new(app).unwrap()
-}
-
-async fn create_dummy_permission(
-	repo: &PermissionsRepository<'_>,
-	name: &str,
-) -> String {
-	let dto = crate::v1::permissions_schema::PermissionsSchema {
-		name: name.into(),
-		..Default::default()
-	};
-	let _ = repo.query_create_permission(dto.clone()).await.unwrap();
-	let found = repo.query_permission_by_name(name.into()).await.unwrap();
-	found.id.id.to_raw()
-}
-
-async fn delete_dummy_permission(repo: &PermissionsRepository<'_>, id: String) {
-	let _ = repo.query_delete_permission(id).await;
-}
-
-#[tokio::test]
-async fn test_create_permission_should_return_201() {
-	let state = create_mock_app_state().await;
-	let repo = PermissionsRepository::new(&state);
-	let server = create_test_app(state.clone());
-	let payload = PermissionsRequestDto {
-		name: "Create Permission".into(),
-	};
-	let res = server.post("/v1/permissions/create").json(&payload).await;
-	dbg!(res.text());
-	assert_eq!(res.status_code(), StatusCode::CREATED);
-	let id = repo
-		.query_permission_by_name(payload.name.clone())
-		.await
-		.unwrap()
-		.id
-		.id
-		.to_raw();
-	delete_dummy_permission(&repo, id).await;
-}
-
-#[tokio::test]
-async fn test_get_permission_list_should_return_200() {
-	let state = create_mock_app_state().await;
-	let server = create_test_app(state);
-	let res = server.get("/v1/permissions?page=1&per_page=10").await;
-	dbg!(res.text());
-	assert_eq!(res.status_code(), StatusCode::OK);
-}
-
-#[tokio::test]
-async fn test_get_permission_by_id_should_return_200() {
-	let state = create_mock_app_state().await;
-	let repo = PermissionsRepository::new(&state);
-	let id = create_dummy_permission(&repo, "Get Permission").await;
-	let server = create_test_app(state.clone());
-	let res = server.get(&format!("/v1/permissions/detail/{}", id)).await;
-	dbg!(res.text());
-	assert_eq!(res.status_code(), StatusCode::OK);
-	delete_dummy_permission(&repo, id).await;
-}
-
-#[tokio::test]
-async fn test_update_permission_should_return_200() {
-	let state = create_mock_app_state().await;
-	let repo = PermissionsRepository::new(&state);
-	let id = create_dummy_permission(&repo, "To Update").await;
-	let server = create_test_app(state.clone());
-	let payload = PermissionsRequestDto {
-		name: "Updated Permission".into(),
-	};
-	let res = server
-		.put(&format!("/v1/permissions/update/{}", id.clone()))
-		.json(&payload)
-		.await;
-	dbg!(res.text());
-	assert_eq!(res.status_code(), StatusCode::OK);
-	delete_dummy_permission(&repo, id).await;
-}
-
-#[tokio::test]
-async fn test_delete_permission_should_return_200() {
-	let state = create_mock_app_state().await;
-	let repo = PermissionsRepository::new(&state);
-	let id = create_dummy_permission(&repo, "To Delete").await;
-	let server = create_test_app(state);
-	let res = server
-		.delete(&format!("/v1/permissions/delete/{}", id))
-		.await;
-	dbg!(res.text());
-	assert_eq!(res.status_code(), StatusCode::OK);
-}
-
-#[tokio::test]
-async fn test_create_duplicate_permission_should_return_409() {
-	let state = create_mock_app_state().await;
-	let repo = PermissionsRepository::new(&state);
-	let name = "Duplicate Permission";
-	let id = create_dummy_permission(&repo, name).await;
-	let server = create_test_app(state.clone());
-	let payload = PermissionsRequestDto { name: name.into() };
-	let res = server.post("/v1/permissions/create").json(&payload).await;
-	assert_eq!(res.status_code(), StatusCode::CONFLICT);
-	delete_dummy_permission(&repo, id).await;
-}
-
-#[tokio::test]
-async fn test_delete_nonexistent_permission_should_return_404() {
-	let state = create_mock_app_state().await;
-	let server = create_test_app(state);
-	let res = server.delete("/v1/permissions/delete/nonexistent-id").await;
-	assert_eq!(res.status_code(), StatusCode::NOT_FOUND);
-}
-
-#[tokio::test]
-async fn test_create_permission_with_empty_name_should_return_400() {
-	let state = create_mock_app_state().await;
-	let server = create_test_app(state);
-	let payload = PermissionsRequestDto { name: "".into() };
-	let res = server.post("/v1/permissions/create").json(&payload).await;
-	dbg!(res.text());
-	assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
-}
-
-#[tokio::test]
-async fn test_update_nonexistent_permission_should_return_404() {
-	let state = create_mock_app_state().await;
-	let server = create_test_app(state);
-	let payload = PermissionsRequestDto {
-		name: "Nonexistent".into(),
-	};
-	let res = server
-		.put("/v1/permissions/update/non-exist")
-		.json(&payload)
-		.await;
-	dbg!(res.text());
-	assert_eq!(res.status_code(), StatusCode::NOT_FOUND);
-}
-
-#[tokio::test]
-async fn test_get_permission_by_invalid_id_should_return_404() {
-	let state = create_mock_app_state().await;
-	let server = create_test_app(state);
-	let res = server.get("/v1/permissions/detail/invalid-id").await;
-	dbg!(res.text());
-	assert_eq!(res.status_code(), StatusCode::NOT_FOUND);
-}
-
-#[tokio::test]
-async fn test_get_permission_list_with_invalid_pagination_should_return_400() {
-	let state = create_mock_app_state().await;
-	let server = create_test_app(state);
-	let res = server.get("/v1/permissions?page=abc&per_page=xyz").await;
-	dbg!(res.text());
-	assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
-}

tests/src/iam/roles/mod.rs

@@ -1,4 +1,2 @@
 #[cfg(test)]
-pub mod roles_controller_test;
-#[cfg(test)]
 pub mod roles_repository_test;

tests/src/iam/roles/roles_controller_test.rs

@@ -1,174 +0,0 @@
-use crate::AppState;
-use crate::{
-	RolesRequestCreateDto, RolesRequestUpdateDto, create_mock_app_state, roles_router,
-	v1::roles_repository::RolesRepository,
-};
-use axum::Extension;
-use axum::Router;
-use axum::http::StatusCode;
-use axum_test::TestServer;
-
-pub fn create_test_app(state: AppState) -> TestServer {
-	let app = Router::new()
-		.nest("/v1/roles", roles_router())
-		.layer(Extension(state));
-
-	TestServer::new(app).unwrap()
-}
-
-async fn delete_dummy_role(state: AppState, id: String) {
-	let repo = RolesRepository::new(&state);
-	let _ = repo.query_delete_role(id).await;
-}
-
-#[tokio::test]
-async fn test_get_role_list_should_return_200() {
-	let state = create_mock_app_state().await;
-	let app = axum::Router::new()
-		.nest("/v1/roles", roles_router())
-		.layer(axum::Extension(state.clone()));
-	let server = TestServer::new(app).unwrap();
-	let res = server.get("/v1/roles?page=1&per_page=10").await;
-	assert_eq!(res.status_code(), StatusCode::OK);
-}
-
-#[tokio::test]
-async fn test_post_create_role_should_return_201() {
-	let state = create_mock_app_state().await;
-	let app = axum::Router::new()
-		.nest("/v1/roles", roles_router())
-		.layer(axum::Extension(state.clone()));
-	let server = TestServer::new(app).unwrap();
-	let payload = RolesRequestCreateDto {
-		name: "Test Role #1".into(),
-		permissions: vec![],
-	};
-	let res = server.post("/v1/roles/create").json(&payload).await;
-	let repo = RolesRepository::new(&state);
-	assert_eq!(res.status_code(), StatusCode::CREATED);
-	let id = repo
-		.query_role_by_name(payload.name.clone())
-		.await
-		.unwrap()
-		.id;
-	delete_dummy_role(state, id).await;
-}
-
-#[tokio::test]
-async fn test_put_update_role_should_return_200() {
-	let state = create_mock_app_state().await;
-	let repo = RolesRepository::new(&state);
-	let _ = repo
-		.query_create_role(RolesRequestCreateDto {
-			name: "Role To Update".into(),
-			permissions: vec![],
-		})
-		.await
-		.unwrap();
-	let existing = repo
-		.query_role_by_name("Role To Update".into())
-		.await
-		.unwrap();
-	let id = existing.id.clone();
-	let server = create_test_app(state.clone());
-	let payload = RolesRequestUpdateDto {
-		name: Some("Updated Role".into()),
-		permissions: Some(vec![]),
-		overwrite: None,
-	};
-	let res = server
-		.put(&format!("/v1/roles/update/{}", id))
-		.json(&payload)
-		.await;
-	dbg!(res.text());
-	assert_eq!(res.status_code(), StatusCode::OK);
-	let id = repo
-		.query_role_by_name(payload.name.clone().unwrap())
-		.await
-		.unwrap()
-		.id;
-	delete_dummy_role(state.clone(), id).await;
-}
-
-#[tokio::test]
-async fn test_delete_role_should_return_200() {
-	let state = create_mock_app_state().await;
-	let repo = RolesRepository::new(&state);
-	let _ = repo
-		.query_create_role(RolesRequestCreateDto {
-			name: "Role To Delete".into(),
-			permissions: vec![],
-		})
-		.await
-		.unwrap();
-	let existing = repo
-		.query_role_by_name("Role To Delete".into())
-		.await
-		.unwrap();
-	let id = existing.id;
-	let server = create_test_app(state);
-	let res = server.delete(&format!("/v1/roles/delete/{}", id)).await;
-	dbg!(res.text());
-	assert_eq!(res.status_code(), StatusCode::OK);
-}
-
-#[tokio::test]
-async fn test_post_create_role_with_empty_name_should_return_400() {
-	let state = create_mock_app_state().await;
-	let server = create_test_app(state);
-	let payload = RolesRequestCreateDto {
-		name: "".into(),
-		permissions: vec![],
-	};
-	let res = server.post("/v1/roles/create").json(&payload).await;
-	dbg!(res.text());
-	assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
-}
-
-#[tokio::test]
-async fn test_put_update_nonexistent_role_should_return_404() {
-	let state = create_mock_app_state().await;
-	let server = create_test_app(state);
-	let payload = RolesRequestUpdateDto {
-		name: Some("Does Not Exist".into()),
-		permissions: Some(vec![]),
-		overwrite: None,
-	};
-	let res = server
-		.put("/v1/roles/update/nonexistent-id")
-		.json(&payload)
-		.await;
-	dbg!(res.text());
-	assert_eq!(res.status_code(), StatusCode::NOT_FOUND);
-}
-
-#[tokio::test]
-async fn test_delete_nonexistent_role_should_return_404() {
-	let state = create_mock_app_state().await;
-	let server = create_test_app(state);
-	let res = server.delete("/v1/roles/delete/nonexistent-id").await;
-	dbg!(res.text());
-	assert_eq!(res.status_code(), StatusCode::NOT_FOUND);
-}
-
-#[tokio::test]
-async fn test_get_role_list_with_invalid_page_params_should_return_400() {
-	let state = create_mock_app_state().await;
-	let server = create_test_app(state);
-	let res = server.get("/v1/roles?page=abc&per_page=xyz").await;
-	dbg!(res.text());
-	assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
-}
-
-#[tokio::test]
-async fn test_create_duplicate_role_should_return_409() {
-	let state = create_mock_app_state().await;
-	let server = create_test_app(state);
-	let payload = RolesRequestCreateDto {
-		name: "Admin".into(),
-		permissions: vec![],
-	};
-	let res = server.post("/v1/roles/create").json(&payload).await;
-	dbg!(res.text());
-	assert_eq!(res.status_code(), StatusCode::CONFLICT);
-}

tests/src/iam/roles/roles_repository_test.rs

@@ -10,7 +10,10 @@ use crate::{
 	},
 };
 use surrealdb::Uuid;
-use surrealdb::sql::Thing;
+
+fn generate_unique_name(prefix: &str) -> String {
+	format!("{}_{}", prefix, Uuid::new_v4())
+}
 
 #[tokio::test]
 async fn test_query_create_role_should_succeed() {
@@ -19,15 +22,15 @@ async fn test_query_create_role_should_succeed() {
 	let role_repo = RolesRepository::new(&state);
 	let perm_id = Uuid::new_v4().to_string();
 	let permission = PermissionsSchema {
-		id: Thing::from((ResourceEnum::Permissions.to_string(), perm_id.clone())),
-		name: "Read Quiz".into(),
+		id: make_thing(&ResourceEnum::Permissions.to_string(), &perm_id.clone()),
+		name: generate_unique_name("read_quiz"),
 		is_deleted: false,
 		created_at: Some(get_iso_date()),
-		updated_at: None,
+		updated_at: Some(get_iso_date()),
 	};
 	perm_repo.query_create_permission(permission).await.unwrap();
 	let payload = RolesRequestCreateDto {
-		name: "Student".into(),
+		name: generate_unique_name("user"),
 		permissions: vec![perm_id.clone()],
 	};
 	let result = role_repo.query_create_role(payload).await;
@@ -38,27 +41,29 @@ async fn test_query_create_role_should_succeed() {
 async fn test_query_role_by_name_should_return_data() {
 	let state = create_mock_app_state().await;
 	let role_repo = RolesRepository::new(&state);
+	let name = generate_unique_name("viewer");
 	let payload = RolesRequestCreateDto {
-		name: "Viewer".into(),
+		name: name.clone(),
 		permissions: vec![],
 	};
 	role_repo.query_create_role(payload.clone()).await.unwrap();
-	let role = role_repo.query_role_by_name("Viewer".into()).await.unwrap();
-	assert_eq!(role.name, "Viewer");
+	let role = role_repo.query_role_by_name(name.clone()).await.unwrap();
+	assert_eq!(role.name, name.clone());
 }
 
 #[tokio::test]
 async fn test_query_role_by_id_should_return_data() {
 	let state = create_mock_app_state().await;
 	let role_repo = RolesRepository::new(&state);
+	let name = generate_unique_name("tester");
 	let payload = RolesRequestCreateDto {
-		name: "Tester".into(),
+		name: name.clone(),
 		permissions: vec![],
 	};
 	role_repo.query_create_role(payload.clone()).await.unwrap();
-	let role = role_repo.query_role_by_name("Tester".into()).await.unwrap();
+	let role = role_repo.query_role_by_name(name.clone()).await.unwrap();
 	let result = role_repo.query_role_by_id(role.id).await.unwrap();
-	assert_eq!(result.name, "Tester");
+	assert_eq!(result.name, name.clone());
 }
 
 #[tokio::test]
@@ -69,7 +74,7 @@ async fn test_query_update_role_should_update_name_and_permissions() {
 	let original_perm_id = Uuid::new_v4().to_string();
 	let original_perm = PermissionsSchema {
 		id: make_thing(&ResourceEnum::Permissions.to_string(), &original_perm_id),
-		name: "Original Permission".into(),
+		name: generate_unique_name("original_permission"),
 		is_deleted: false,
 		created_at: Some(crate::get_iso_date()),
 		updated_at: None,
@@ -78,13 +83,14 @@ async fn test_query_update_role_should_update_name_and_permissions() {
 		.query_create_permission(original_perm)
 		.await
 		.unwrap();
+	let role_upadate_name = generate_unique_name("role_for_update");
 	let create_payload = RolesRequestCreateDto {
-		name: "Role For Update".into(),
+		name: role_upadate_name.clone(),
 		permissions: vec![original_perm_id.clone()],
 	};
 	repo.query_create_role(create_payload).await.unwrap();
 	let existing_role = repo
-		.query_role_by_name("Role For Update".into())
+		.query_role_by_name(role_upadate_name.clone())
 		.await
 		.unwrap();
 	let existing_role_id = existing_role.id.clone();
@@ -96,9 +102,10 @@ async fn test_query_update_role_should_update_name_and_permissions() {
 		created_at: Some(crate::get_iso_date()),
 		updated_at: None,
 	};
+	let new_role_name = generate_unique_name("updated_role_name");
 	perm_repo.query_create_permission(new_perm).await.unwrap();
 	let update_payload = RolesRequestUpdateDto {
-		name: Some("Updated Role Name".into()),
+		name: Some(new_role_name.clone()),
 		permissions: Some(vec![new_perm_id.clone()]),
 		overwrite: None,
 	};
@@ -110,22 +117,20 @@ async fn test_query_update_role_should_update_name_and_permissions() {
 		.query_role_by_id(existing_role_id.clone())
 		.await
 		.unwrap();
-	assert_eq!(updated.name, "Updated Role Name");
+	assert_eq!(updated.name, new_role_name.clone());
 }
 
 #[tokio::test]
 async fn test_query_delete_role_should_soft_delete() {
 	let state = create_mock_app_state().await;
 	let role_repo = RolesRepository::new(&state);
+	let name = generate_unique_name("temporary");
 	let payload = RolesRequestCreateDto {
-		name: "Temporary".into(),
+		name: name.clone(),
 		permissions: vec![],
 	};
 	role_repo.query_create_role(payload.clone()).await.unwrap();
-	let role = role_repo
-		.query_role_by_name("Temporary".into())
-		.await
-		.unwrap();
+	let role = role_repo.query_role_by_name(name.clone()).await.unwrap();
 	let result = role_repo.query_delete_role(role.id.clone()).await;
 	assert!(result.is_ok());
 	let deleted = role_repo.query_role_by_id(role.id).await;
@@ -179,15 +184,13 @@ async fn test_query_role_by_name_should_fail_if_not_found() {
 async fn test_query_delete_role_should_fail_if_already_deleted() {
 	let state = create_mock_app_state().await;
 	let role_repo = RolesRepository::new(&state);
+	let name = generate_unique_name("soft_delete_test");
 	let payload = RolesRequestCreateDto {
-		name: "SoftDeleteTest".into(),
+		name: name.clone(),
 		permissions: vec![],
 	};
 	role_repo.query_create_role(payload.clone()).await.unwrap();
-	let role = role_repo
-		.query_role_by_name("SoftDeleteTest".into())
-		.await
-		.unwrap();
+	let role = role_repo.query_role_by_name(name.clone()).await.unwrap();
 	role_repo.query_delete_role(role.id.clone()).await.unwrap();
 	let result = role_repo.query_delete_role(role.id);
 	assert!(result.await.is_err());

tests/src/iam/users/mod.rs

@@ -1,4 +1,2 @@
 #[cfg(test)]
-pub mod users_controller_test;
-#[cfg(test)]
 pub mod users_repository_test;

tests/src/iam/users/users_controller_test.rs

@@ -1,602 +0,0 @@
-use crate::{
-	RolesEnum, RolesRepository, UsersActiveInactiveRequestDto, UsersCreateRequestDto,
-	UsersRepository, UsersUpdateRequestDto, users_router,
-};
-use axum::{Extension, http::StatusCode};
-use axum_test::TestServer;
-use imphnen_utils::create_mock_app_state;
-use surrealdb::Uuid;
-
-#[tokio::test]
-async fn test_get_user_list_should_return_200() {
-	let state = create_mock_app_state().await;
-	let app = axum::Router::new()
-		.nest("/v1/users", users_router())
-		.layer(Extension(state));
-	let server = TestServer::new(app).unwrap();
-	let res = server.get("/v1/users?page=1&per_page=10").await;
-	let status = res.status_code();
-	assert_eq!(status, StatusCode::OK);
-}
-
-#[tokio::test]
-async fn test_list_users_should_fail_with_invalid_per_page() {
-	let state = create_mock_app_state().await;
-	let app = axum::Router::new()
-		.nest("/v1/users", users_router())
-		.layer(Extension(state));
-	let server = TestServer::new(app).unwrap();
-	let res = server.get("/v1/users?page=1&per_page=0").await;
-	assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
-}
-
-#[tokio::test]
-async fn test_list_users_should_fail_with_invalid_page() {
-	let state = create_mock_app_state().await;
-	let app = axum::Router::new()
-		.nest("/v1/users", users_router())
-		.layer(Extension(state));
-	let server = TestServer::new(app).unwrap();
-	let res = server.get("/v1/users?page=0&per_page=10").await;
-	dbg!(res.text());
-	dbg!(res.status_code());
-	assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
-}
-
-#[tokio::test]
-async fn test_list_users_should_ignore_invalid_sort_field() {
-	let state = create_mock_app_state().await;
-	let app = axum::Router::new()
-		.nest("/v1/users", users_router())
-		.layer(Extension(state));
-	let server = TestServer::new(app).unwrap();
-	let res = server
-		.get("/v1/users?page=1&per_page=10&sort_by=invalid_field")
-		.await;
-	assert_eq!(res.status_code(), StatusCode::OK);
-}
-
-#[tokio::test]
-async fn test_list_users_with_search_no_match_should_return_empty() {
-	let state = create_mock_app_state().await;
-	let app = axum::Router::new()
-		.nest("/v1/users", users_router())
-		.layer(Extension(state));
-	let server = TestServer::new(app).unwrap();
-	let res = server
-		.get("/v1/users?page=1&per_page=10&search=nonexistinguserxyz")
-		.await;
-	let body: serde_json::Value = res.json();
-	assert_eq!(res.status_code(), StatusCode::OK);
-	assert_eq!(body["data"].as_array().unwrap().len(), 0);
-}
-
-#[tokio::test]
-async fn test_list_users_should_return_empty_on_invalid_filter() {
-	let state = create_mock_app_state().await;
-	let app = axum::Router::new()
-		.nest("/v1/users", users_router())
-		.layer(Extension(state));
-	let server = TestServer::new(app).unwrap();
-	let res = server
-		.get("/v1/users?page=1&per_page=10&filter_by=is_active&filter=maybe")
-		.await;
-	let body: serde_json::Value = res.json();
-	assert_eq!(res.status_code(), StatusCode::OK);
-	assert_eq!(body["data"].as_array().unwrap().len(), 0);
-}
-
-#[tokio::test]
-async fn test_get_user_list_with_search_should_return_200() {
-	let state = create_mock_app_state().await;
-	let app = axum::Router::new()
-		.nest("/v1/users", users_router())
-		.layer(Extension(state));
-	let server = TestServer::new(app).unwrap();
-	let res = server
-		.get("/v1/users?page=1&per_page=10&search=maulana")
-		.await;
-	let status = res.status_code();
-	dbg!(res.text());
-	assert_eq!(status, StatusCode::OK);
-}
-
-#[tokio::test]
-async fn test_create_user_should_return_201() {
-	let state = create_mock_app_state().await;
-	let role_repo = RolesRepository::new(&state);
-	let role = role_repo
-		.query_role_by_name(RolesEnum::User.to_string())
-		.await
-		.unwrap();
-	let role_id = role.id;
-	let app = axum::Router::new()
-		.nest("/v1/users", users_router())
-		.layer(Extension(state));
-	let server = TestServer::new(app).unwrap();
-	let payload = UsersCreateRequestDto {
-		fullname: "Create Data #1".into(),
-		email: format!("test-{}@create.com", Uuid::new_v4()).into(),
-		role_id,
-		password: "Password1!".into(),
-		phone_number: "081234567890".into(),
-		is_active: true,
-	};
-	let res = server.post("/v1/users/create").json(&payload).await;
-	assert_eq!(res.status_code(), StatusCode::CREATED);
-}
-
-#[tokio::test]
-async fn test_get_user_detail_should_return_200() {
-	let state = create_mock_app_state().await;
-	let role_repo = RolesRepository::new(&state);
-	let role = role_repo
-		.query_role_by_name(RolesEnum::User.to_string())
-		.await
-		.unwrap();
-	let role_id = role.id;
-	let repo = UsersRepository::new(&state);
-	let app = axum::Router::new()
-		.nest("/v1/users", users_router())
-		.layer(Extension(state.clone()));
-	let server = TestServer::new(app).unwrap();
-	let payload = UsersCreateRequestDto {
-		fullname: "Detail User".into(),
-		email: "detail@test.com".into(),
-		role_id,
-		password: "Password1!".into(),
-		phone_number: "081234567890".into(),
-		is_active: true,
-	};
-	server.post("/v1/users/create").json(&payload).await;
-	let user = repo.query_user_by_email(payload.email).await.unwrap();
-	let user_id = user.id.id.to_raw();
-	let res = server.get(&format!("/v1/users/detail/{}", user_id)).await;
-	assert_eq!(res.status_code(), StatusCode::OK);
-}
-
-#[tokio::test]
-async fn test_delete_user_should_return_200() {
-	let state = create_mock_app_state().await;
-	let role_repo = RolesRepository::new(&state);
-	let role = role_repo
-		.query_role_by_name(RolesEnum::User.to_string())
-		.await
-		.expect("Failed to get role");
-	let repo = UsersRepository::new(&state);
-	let app = axum::Router::new()
-		.nest("/v1/users", users_router())
-		.layer(Extension(state.clone()));
-	let server = TestServer::new(app).unwrap();
-	let payload = UsersCreateRequestDto {
-		fullname: "Test Delete Me".into(),
-		email: "test@delete-me.com".into(),
-		password: "Password1!".into(),
-		role_id: role.id.clone(),
-		phone_number: "081234567890".into(),
-		is_active: true,
-	};
-	let create_res = server.post("/v1/users/create").json(&payload).await;
-	assert_eq!(create_res.status_code(), StatusCode::CREATED);
-	let detail_res = repo.query_user_by_email(payload.email.clone()).await;
-	assert!(detail_res.is_ok(), "User not found after creation");
-	let user = detail_res.unwrap();
-	let user_id_for_delete = user.id.id.to_raw();
-	let delete_res = server
-		.delete(&format!("/v1/users/delete/{}", user_id_for_delete))
-		.await;
-	assert_eq!(delete_res.status_code(), StatusCode::OK);
-}
-
-#[tokio::test]
-async fn test_activate_user_should_return_200() {
-	let state = create_mock_app_state().await;
-	let role_repo = RolesRepository::new(&state);
-	let role = role_repo
-		.query_role_by_name(RolesEnum::User.to_string())
-		.await
-		.unwrap();
-	let role_id = role.id;
-	let repo = UsersRepository::new(&state);
-	let app = axum::Router::new()
-		.nest("/v1/users", users_router())
-		.layer(Extension(state.clone()));
-	let server = TestServer::new(app).unwrap();
-	let payload = UsersCreateRequestDto {
-		fullname: "Inactive User".into(),
-		email: format!("inactive-{}@test.com", Uuid::new_v4()).into(),
-		password: "Password1!".into(),
-		role_id,
-		phone_number: "081234567890".into(),
-		is_active: false,
-	};
-	let res_create = server.post("/v1/users/create").json(&payload).await;
-	dbg!(res_create.text());
-	let user = repo.query_user_by_email(payload.email).await.unwrap();
-	dbg!(user.fullname);
-	let user_id = user.id.id.to_raw();
-	let res = server
-		.put(&format!("/v1/users/activate/{}", user_id))
-		.json(&UsersActiveInactiveRequestDto { is_active: true })
-		.await;
-	dbg!(res.text());
-	assert_eq!(res.status_code(), StatusCode::OK);
-}
-
-#[tokio::test]
-async fn test_update_user_should_return_200() {
-	let state = create_mock_app_state().await;
-	let role_repo = RolesRepository::new(&state);
-	let role = role_repo
-		.query_role_by_name(RolesEnum::User.to_string())
-		.await
-		.unwrap();
-	let role_id = role.id.clone();
-	let repo = UsersRepository::new(&state);
-	let app = axum::Router::new()
-		.nest("/v1/users", users_router())
-		.layer(Extension(state.clone()));
-	let server = TestServer::new(app).unwrap();
-	let unique_email = format!("update_{}@test.com", Uuid::new_v4());
-	let payload = UsersCreateRequestDto {
-		fullname: "Old Name".into(),
-		email: unique_email.clone(),
-		password: "Password1!".into(),
-		role_id: role_id.clone(),
-		phone_number: "081234567890".into(),
-		is_active: true,
-	};
-	let create_res = server.post("/v1/users/create").json(&payload).await;
-	assert_eq!(create_res.status_code(), StatusCode::CREATED);
-	let user = repo.query_user_by_email(unique_email).await.unwrap();
-	let user_id = user.id.id.to_raw();
-	let update_payload = UsersUpdateRequestDto {
-		fullname: "Updated Name".into(),
-		email: payload.email.clone(),
-		phone_number: "081234567890".into(),
-		role_id: user.role.id.id.to_raw(),
-		is_active: true,
-		gender: Some("Laki-laki".into()),
-		birthdate: Some("2000-01-01".into()),
-		avatar: None,
-	};
-	let res = server
-		.put(&format!("/v1/users/update/{}", user_id))
-		.json(&update_payload)
-		.await;
-	let status = res.status_code();
-	let body = res.text();
-	assert_eq!(status, StatusCode::OK, "Response body: {}", body);
-}
-
-#[tokio::test]
-async fn test_create_user_should_fail_if_email_taken() {
-	let state = create_mock_app_state().await;
-	let role_repo = RolesRepository::new(&state);
-	let role = role_repo
-		.query_role_by_name(RolesEnum::User.to_string())
-		.await
-		.unwrap();
-	let role_id = role.id.clone();
-	let app = axum::Router::new()
-		.nest("/v1/users", users_router())
-		.layer(Extension(state.clone()));
-	let server = TestServer::new(app).unwrap();
-	let email = format!("test_{}@example.com", Uuid::new_v4());
-	let payload = UsersCreateRequestDto {
-		fullname: "User Satu".into(),
-		email: email.clone(),
-		password: "Password1!".into(),
-		role_id,
-		phone_number: "081234567890".into(),
-		is_active: true,
-	};
-	let res1 = server.post("/v1/users/create").json(&payload).await;
-	assert_eq!(res1.status_code(), StatusCode::CREATED);
-	let res2 = server.post("/v1/users/create").json(&payload).await;
-	let body2 = res2.text();
-	assert_eq!(res2.status_code(), StatusCode::BAD_REQUEST);
-	assert!(body2.contains("User already exists"));
-}
-
-#[tokio::test]
-async fn test_get_user_detail_should_fail_if_not_found() {
-	let state = create_mock_app_state().await;
-	let app = axum::Router::new()
-		.nest("/v1/users", users_router())
-		.layer(Extension(state));
-	let server = TestServer::new(app).unwrap();
-	let res = server.get("/v1/users/detail/non-existent-id").await;
-	assert_eq!(res.status_code(), StatusCode::NOT_FOUND);
-	let body = res.text();
-	assert!(body.contains("User not found"));
-}
-
-#[tokio::test]
-async fn test_delete_user_should_fail_if_already_deleted() {
-	let state = create_mock_app_state().await;
-	let role_repo = RolesRepository::new(&state);
-	let role = role_repo
-		.query_role_by_name(RolesEnum::User.to_string())
-		.await
-		.unwrap();
-	let role_id = role.id.clone();
-	let repo = UsersRepository::new(&state);
-	let app = axum::Router::new()
-		.nest("/v1/users", users_router())
-		.layer(Extension(state.clone()));
-	let server = TestServer::new(app).unwrap();
-	let payload = UsersCreateRequestDto {
-		fullname: "To Be Deleted".into(),
-		email: "delete-me@example.com".into(),
-		role_id,
-		password: "Password1!".into(),
-		phone_number: "081234567890".into(),
-		is_active: true,
-	};
-	server.post("/v1/users/create").json(&payload).await;
-	let user = repo.query_user_by_email(payload.email).await.unwrap();
-	let id = user.id.id.to_raw();
-	let res1 = server.delete(&format!("/v1/users/delete/{}", id)).await;
-	assert_eq!(res1.status_code(), StatusCode::OK);
-	let res2 = server.delete(&format!("/v1/users/delete/{}", id)).await;
-	assert_eq!(res2.status_code(), StatusCode::BAD_REQUEST);
-	let body = res2.text();
-	assert!(body.contains("User already deleted"));
-}
-
-#[tokio::test]
-async fn test_update_user_should_fail_if_user_not_found() {
-	let state = create_mock_app_state().await;
-	let role_repo = RolesRepository::new(&state);
-	let role = role_repo
-		.query_role_by_name(RolesEnum::User.to_string())
-		.await
-		.unwrap();
-	let role_id = role.id.clone();
-	let app = axum::Router::new()
-		.nest("/v1/users", users_router())
-		.layer(Extension(state));
-	let server = TestServer::new(app).unwrap();
-	let update_payload = UsersUpdateRequestDto {
-		fullname: "Does Not Exist".into(),
-		email: "nonexistent@test.com".into(),
-		phone_number: "081234567890".into(),
-		role_id,
-		is_active: true,
-		gender: Some("Laki-laki".into()),
-		birthdate: Some("2000-01-01".into()),
-		avatar: None,
-	};
-	let res = server
-		.put("/v1/users/update/non-existent-id")
-		.json(&update_payload)
-		.await;
-	assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
-	let body = res.text();
-	assert!(body.contains("User not found"));
-}
-
-#[tokio::test]
-async fn test_activate_user_should_fail_if_user_not_found() {
-	let state = create_mock_app_state().await;
-	let app = axum::Router::new()
-		.nest("/v1/users", users_router())
-		.layer(Extension(state));
-	let server = TestServer::new(app).unwrap();
-	let payload = UsersActiveInactiveRequestDto { is_active: true };
-	let res = server
-		.put("/v1/users/activate/non-existent-id")
-		.json(&payload)
-		.await;
-	assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
-	let body = res.text();
-	assert!(body.contains("User not found"));
-}
-
-#[tokio::test]
-async fn test_create_user_should_fail_if_payload_invalid() {
-	let state = create_mock_app_state().await;
-	let app = axum::Router::new()
-		.nest("/v1/users", users_router())
-		.layer(Extension(state));
-	let server = TestServer::new(app).unwrap();
-	let invalid_payload = serde_json::json!({});
-	let res = server.post("/v1/users/create").json(&invalid_payload).await;
-	assert_eq!(res.status_code(), StatusCode::UNPROCESSABLE_ENTITY);
-}
-
-#[tokio::test]
-async fn test_list_users_should_fail_with_invalid_pagination() {
-	let state = create_mock_app_state().await;
-	let app = axum::Router::new()
-		.nest("/v1/users", users_router())
-		.layer(Extension(state));
-	let server = TestServer::new(app).unwrap();
-	let res = server.get("/v1/users?page=0&per_page=0").await;
-	assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
-	let body = res.text();
-	assert!(
-		body.contains("Invalid pagination") || body.contains("per_page"),
-		"Expected pagination error, got: {body}"
-	);
-}
-
-#[tokio::test]
-async fn test_list_users_should_fallback_on_invalid_order() {
-	let state = create_mock_app_state().await;
-	let app = axum::Router::new()
-		.nest("/v1/users", users_router())
-		.layer(Extension(state));
-	let server = TestServer::new(app).unwrap();
-	let res = server
-		.get("/v1/users?page=1&per_page=10&sort_by=email&order=invalid")
-		.await;
-	assert_eq!(res.status_code(), StatusCode::OK);
-}
-
-#[tokio::test]
-async fn test_list_users_with_invalid_filter_by_should_return_empty() {
-	let state = create_mock_app_state().await;
-	let app = axum::Router::new()
-		.nest("/v1/users", users_router())
-		.layer(Extension(state));
-	let server = TestServer::new(app).unwrap();
-	let res = server
-		.get("/v1/users?page=1&per_page=10&filter_by=unknown_field&filter=value")
-		.await;
-	assert_eq!(res.status_code(), StatusCode::OK);
-	let body: serde_json::Value = res.json();
-	assert_eq!(body["data"].as_array().unwrap().len(), 0);
-}
-
-#[tokio::test]
-async fn test_user_detail_should_fail_with_invalid_id_format() {
-	let state = create_mock_app_state().await;
-	let app = axum::Router::new()
-		.nest("/v1/users", users_router())
-		.layer(Extension(state));
-	let server = TestServer::new(app).unwrap();
-	let res = server.get("/v1/users/detail/!@#invalid-id").await;
-	assert_eq!(res.status_code(), StatusCode::NOT_FOUND);
-	let body = res.text();
-	assert!(body.contains("User not found") || body.contains("not found"));
-}
-
-#[tokio::test]
-async fn test_user_detail_should_fail_if_user_not_found() {
-	let state = create_mock_app_state().await;
-	let app = axum::Router::new()
-		.nest("/v1/users", users_router())
-		.layer(Extension(state));
-	let server = TestServer::new(app).unwrap();
-	let res = server.get("/v1/users/detail/random-id-123456").await;
-	assert_eq!(res.status_code(), StatusCode::NOT_FOUND);
-	let body = res.text();
-	assert!(body.contains("User not found"));
-}
-
-#[tokio::test]
-async fn test_user_detail_should_fail_if_user_is_soft_deleted() {
-	let state = create_mock_app_state().await;
-	let role_repo = RolesRepository::new(&state);
-	let role = role_repo
-		.query_role_by_name(RolesEnum::User.to_string())
-		.await
-		.unwrap();
-	let role_id = role.id.clone();
-	let repo = UsersRepository::new(&state);
-	let app = axum::Router::new()
-		.nest("/v1/users", users_router())
-		.layer(Extension(state.clone()));
-	let server = TestServer::new(app).unwrap();
-	let payload = UsersCreateRequestDto {
-		role_id,
-		fullname: "Soft Deleted".into(),
-		email: "softdeleted@test.com".into(),
-		password: "Password1!".into(),
-		phone_number: "081234567890".into(),
-		is_active: true,
-	};
-	server.post("/v1/users/create").json(&payload).await;
-	let user = repo.query_user_by_email(payload.email).await.unwrap();
-	let user_id = user.id.id.to_raw();
-	let _ = repo.query_delete_user(user_id.clone()).await.unwrap();
-	let res = server.get(&format!("/v1/users/detail/{}", user_id)).await;
-	dbg!(res.text());
-	assert_eq!(res.status_code(), StatusCode::NOT_FOUND);
-	let body = res.text();
-	assert!(body.contains("User not found"));
-}
-
-#[tokio::test]
-async fn test_update_user_should_fail_if_user_is_deleted() {
-	let state = create_mock_app_state().await;
-	let role_repo = RolesRepository::new(&state);
-	let role = role_repo
-		.query_role_by_name(RolesEnum::User.to_string())
-		.await
-		.unwrap();
-	let role_id = role.id.clone();
-	let repo = UsersRepository::new(&state);
-	let app = axum::Router::new()
-		.nest("/v1/users", users_router())
-		.layer(Extension(state.clone()));
-	let server = TestServer::new(app).unwrap();
-	let payload = UsersCreateRequestDto {
-		role_id: role_id.clone(),
-		fullname: "To Be Deleted".into(),
-		email: "deleteduser@test.com".into(),
-		password: "Password1!".into(),
-		phone_number: "081234567890".into(),
-		is_active: true,
-	};
-	server.post("/v1/users/create").json(&payload).await;
-	let user = repo.query_user_by_email(payload.email).await.unwrap();
-	let user_id = user.id.id.to_raw();
-	let _ = repo.query_delete_user(user_id.clone()).await.unwrap();
-	let update_payload = UsersUpdateRequestDto {
-		role_id: role_id.clone(),
-		fullname: "Should Fail".into(),
-		email: "deleteduser@test.com".into(),
-		phone_number: "081234567890".into(),
-		is_active: true,
-		gender: Some("Laki-laki".into()),
-		birthdate: Some("2000-01-01".into()),
-		avatar: None,
-	};
-	let res = server
-		.put(&format!("/v1/users/update/{}", user_id))
-		.json(&update_payload)
-		.await;
-	assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
-	let body = res.text();
-	assert!(body.contains("User already deleted"));
-}
-
-#[tokio::test]
-async fn test_update_user_should_fail_if_payload_invalid() {
-	let state = create_mock_app_state().await;
-	let role_repo = RolesRepository::new(&state);
-	let role = role_repo
-		.query_role_by_name(RolesEnum::User.to_string())
-		.await
-		.unwrap();
-	let role_id = role.id.clone();
-	let repo = UsersRepository::new(&state);
-	let app = axum::Router::new()
-		.nest("/v1/users", users_router())
-		.layer(Extension(state.clone()));
-	let server = TestServer::new(app).unwrap();
-	let payload = UsersCreateRequestDto {
-		fullname: "Invalid Payload".into(),
-		email: "invalid@test.com".into(),
-		role_id: role_id.clone(),
-		password: "Password1!".into(),
-		phone_number: "081234567890".into(),
-		is_active: true,
-	};
-	server.post("/v1/users/create").json(&payload).await;
-	let user = repo.query_user_by_email(payload.email).await.unwrap();
-	let user_id = user.id.id.to_raw();
-	let update_payload = UsersUpdateRequestDto {
-		fullname: "".into(),
-		email: "invalid@test.com".into(),
-		phone_number: "081234567890".into(),
-		is_active: true,
-		role_id: role_id.clone(),
-		gender: Some("Laki-laki".into()),
-		birthdate: Some("2000-01-01".into()),
-		avatar: None,
-	};
-	let res = server
-		.put(&format!("/v1/users/update/{}", user_id))
-		.json(&update_payload)
-		.await;
-	assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
-	let body = res.text();
-	assert!(
-		body.contains("Fullname") || body.contains("at least have 2 character"),
-		"Gagal validasi fullname: {body}"
-	);
-}

tests/src/iam/users/users_repository_test.rs

@@ -1,31 +1,18 @@
-use crate::{MetaRequestDto, UsersRepository};
-use crate::{RolesRepository, create_mock_app_state, create_test_user};
-
-async fn get_role_id(state: &crate::AppState) -> String {
-	RolesRepository::new(state)
-		.query_role_by_name("Student".into())
-		.await
-		.expect("Role not found")
-		.id
-}
+use crate::{MetaRequestDto, UsersRepository, generate_unique_email, get_role_id};
+use crate::{create_mock_app_state, create_test_user};
 
 #[tokio::test]
 async fn test_create_and_get_user() {
 	let app_state = create_mock_app_state().await;
 	let repo = UsersRepository::new(&app_state);
-	let user = create_test_user(
-		"testuser@example.com",
-		"Test User",
-		true,
-		&get_role_id(&app_state).await,
-	);
+	let email = generate_unique_email("testuser");
+	let user =
+		create_test_user(&email, "Test User", true, &get_role_id(&app_state).await);
 	let create_result = repo.query_create_user(user.clone()).await;
 	assert!(create_result.is_ok());
-	let fetched = repo
-		.query_user_by_email("testuser@example.com".into())
-		.await;
+	let fetched = repo.query_user_by_email(email.clone().into()).await;
 	assert!(fetched.is_ok());
-	assert_eq!(fetched.unwrap().email, "testuser@example.com");
+	assert_eq!(fetched.unwrap().email, email.clone());
 }
 
 #[tokio::test]
@@ -88,7 +75,7 @@ async fn test_query_user_list_basic() {
 async fn test_query_delete_user() {
 	let app_state = create_mock_app_state().await;
 	let repo = UsersRepository::new(&app_state);
-	let email = "deleteuser@example.com";
+	let email = &generate_unique_email("deleteuser");
 	let user =
 		create_test_user(email, "Delete User", true, &get_role_id(&app_state).await);
 	repo.query_create_user(user.clone()).await.unwrap();
@@ -100,9 +87,7 @@ async fn test_query_delete_user() {
 		.query_delete_user(user_detail.id.id.to_raw().clone())
 		.await;
 	assert!(delete_result.is_ok());
-	let fetch_result = repo
-		.query_user_by_email(user_detail.id.id.to_raw().clone())
-		.await;
+	let fetch_result = repo.query_user_by_email(user_detail.email.clone()).await;
 	assert!(fetch_result.is_err());
 }
 
@@ -127,7 +112,7 @@ async fn test_delete_user_twice_should_fail_on_second_attempt() {
 	assert!(first.is_ok());
 	let second = repo.query_delete_user(user.id.id.to_raw()).await;
 	assert!(second.is_err());
-	assert_eq!(second.unwrap_err().to_string(), "User already deleted");
+	assert_eq!(second.unwrap_err().to_string(), "User not found");
 }
 
 #[tokio::test]

tests/src/lib.rs

@@ -1,5 +1,28 @@
+use ::surrealdb::Uuid;
 pub use imphnen_entities::*;
 pub use imphnen_iam::*;
 
 #[cfg(test)]
 pub mod iam;
+
+pub fn generate_unique_email(prefix: &str) -> String {
+	format!("{}_{}@example.com", prefix, Uuid::new_v4())
+}
+
+pub async fn get_role_id(state: &crate::AppState) -> String {
+	let repo = RolesRepository::new(state);
+	if let Ok(existing) = repo.query_role_by_name("User".into()).await {
+		return existing.id;
+	}
+	let _ = repo
+		.query_create_role(RolesRequestCreateDto {
+			name: "User".into(),
+			permissions: vec![],
+		})
+		.await;
+	repo
+		.query_role_by_name("User".into())
+		.await
+		.expect("Role not found after creation")
+		.id
+}