Monity – Finance Tracker

a) Framework vs Raw PHP:

• Raw PHP: Semua ditulis sendiri — routing, koneksi DB, validasi, keamanan. Lebih fleksibel tapi lambat dikembangkan dan rentan bug.
• Laravel: Menyediakan struktur bawaan MVC, ORM (Eloquent), routing, middleware, autentikasi, migrasi DB, dan lainnya secara siap pakai.

b) 3 Keuntungan Laravel:

1. Eloquent ORM — query database menggunakan method PHP tanpa SQL manual, type-safe.
2. Artisan CLI — generate controller, model, migration dengan satu perintah (php artisan make:model Product -mcr).
3. Security built-in — CSRF protection, SQL injection prevention, bcrypt hashing sudah disediakan secara default.

c) MVC untuk fitur "Daftar Produk":

// Model: app/Models/Product.php
class Product extends Model {
    protected $fillable = ['name', 'price', 'stock'];
}

// Controller: app/Http/Controllers/ProductController.php
class ProductController extends Controller {
    public function index() {
        $products = Product::orderBy('name')->paginate(10);
        return view('products.index', compact('products'));
    }
}

// Route: routes/web.php
Route::get('/products', [ProductController::class, 'index']);

// View: resources/views/products/index.blade.php
@foreach($products as $p)
    <tr><td>{{ $p->name }}</td><td>{{ $p->price }}</td></tr>
@endforeach
{{ $products->links() }}   {{-- Pagination otomatis --}}

a) Middleware adalah lapisan yang berjalan sebelum request masuk ke controller. Digunakan untuk autentikasi, otorisasi, logging, dsb.

b) Middleware EnsureApproved:

// app/Http/Middleware/EnsureApproved.php
namespace App\Http\Middleware;
use Closure;
use Illuminate\Http\Request;

class EnsureApproved {
    public function handle(Request $request, Closure $next) {
        // Cek sudah login
        if (!auth()->check()) {
            return redirect('/login');
        }
        // Cek status approved
        if (auth()->user()->status !== 'approved') {
            abort(403, 'Akun belum disetujui admin.');
        }
        return $next($request); // Lanjut ke controller
    }
}

c) Daftarkan di Route:

// routes/web.php
Route::get('/dashboard/admin', [AdminController::class, 'index'])
    ->middleware(['auth', 'ensure.approved']);

// bootstrap/app.php (Laravel 11) atau Kernel.php (Laravel 10)
->withMiddleware(function (Middleware $middleware) {
    $middleware->alias(['ensure.approved' => EnsureApproved::class]);
})

a) 4 Pilar OOP:

• Encapsulation: Property disembunyikan (private/protected), diakses via getter/setter. Contoh: $order->getTotal() bukan $order->total secara langsung.
• Inheritance: Class anak mewarisi class induk. Contoh: OnlineOrder extends Order.
• Polymorphism: Method yang sama berperilaku beda di class berbeda. Contoh: calculateShipping() beda di OnlineOrder vs StoreOrder.
• Abstraction: Menyembunyikan detail implementasi. Contoh: interface/abstract class Payable dengan method pay().

b) Class Order dengan Enkapsulasi:

class Order {
    private int $id;
    private array $items = [];
    private float $total = 0;
    private string $status = 'pending';

    public function __construct(int $id) {
        $this->id = $id;
    }

    public function addItem(string $name, float $price, int $qty): void {
        $this->items[] = compact('name', 'price', 'qty');
        $this->total += $price * $qty;
    }

    public function getTotal(): float { return $this->total; }
    public function getStatus(): string { return $this->status; }
    public function approve(): void { $this->status = 'approved'; }
}

c) Class OnlineOrder (Inheritance):

class OnlineOrder extends Order {
    private string $shippingAddress;
    private string $courier;

    public function __construct(int $id, string $address, string $courier) {
        parent::__construct($id); // Panggil constructor induk
        $this->shippingAddress = $address;
        $this->courier = $courier;
    }

    public function calculateShipping(): float {
        // Override: ongkir khusus online order
        return $this->courier === 'JNE' ? 15000 : 20000;
    }

    public function getFinalTotal(): float {
        return $this->getTotal() + $this->calculateShipping();
    }
}

a) 5 Produk Terlaris:

SELECT
    p.product_name,
    p.product_code,
    SUM(od.qty)   AS total_terjual,
    SUM(od.total) AS total_pendapatan
FROM order_details od
JOIN products p ON od.product_id = p.id
GROUP BY p.id, p.product_name, p.product_code
ORDER BY total_terjual DESC
LIMIT 5;

b) Total Pendapatan per Bulan 2025:

SELECT
    MONTH(tgl_order)      AS bulan,
    MONTHNAME(tgl_order)  AS nama_bulan,
    COUNT(id_order)       AS jumlah_order,
    SUM(grand_total)      AS total_pendapatan
FROM orders
WHERE YEAR(tgl_order) = 2025
GROUP BY MONTH(tgl_order), MONTHNAME(tgl_order)
ORDER BY bulan;

c) Order Detail + Nama Produk:

SELECT
    o.id_order,
    o.customer,
    o.tgl_order,
    p.product_name,
    od.qty,
    od.harga_saat_beli,
    od.total
FROM order_details od
JOIN orders  o ON od.id_order    = o.id_order
JOIN products p ON od.product_id = p.id
ORDER BY o.tgl_order DESC;

a) Migration Laravel:

// database/migrations/xxxx_create_product_reviews_table.php
public function up(): void {
    Schema::create('product_reviews', function (Blueprint $table) {
        $table->id();
        $table->foreignId('product_id')
              ->constrained('products')
              ->onDelete('cascade');
        $table->foreignId('user_id')
              ->constrained('users')
              ->onDelete('cascade');
        $table->tinyInteger('rating')
              ->unsigned()
              ->comment('Nilai 1-5');
        $table->text('review_text')->nullable();
        $table->timestamps(); // created_at + updated_at otomatis
    });
}

public function down(): void {
    Schema::dropIfExists('product_reviews');
}

b) Artisan Commands:

php artisan make:migration create_product_reviews_table
php artisan migrate

c) Perbedaan Perintah Migrate:

• migrate — Jalankan semua migrasi yang belum dijalankan (aman, non-destruktif).
• migrate:rollback — Batalkan batch migrasi terakhir (jalankan method down()).
• migrate:fresh — Hapus semua tabel lalu jalankan ulang semua migrasi dari awal. ⚠️ Data hilang! Hanya untuk development.

a) Kompleksitas Waktu:

• O(1) — Konstan, tidak bergantung jumlah data. Contoh: akses produk lewat ID di array asosiatif ($products[$id]).
• O(n) — Linear, sebanding jumlah data. Contoh: loop seluruh daftar produk untuk cari nama (foreach).
• O(n²) — Kuadratik, sangat lambat untuk data besar. Contoh: nested loop membandingkan semua produk satu per satu (bubble sort manual).

b) Cache Produk di Laravel:

// Cache selama 10 menit
$products = Cache::remember('all_products', 600, function () {
    return Product::orderBy('name')->get();
});

// Hapus cache saat ada update produk
Cache::forget('all_products');

// Atau gunakan cache tags (Redis)
Cache::tags(['products'])->remember('product_list', 600, fn() =>
    Product::all()
);

c) Binary Search PHP:

function binarySearch(array $sortedProducts, string $keyword): int {
    $low  = 0;
    $high = count($sortedProducts) - 1;

    while ($low <= $high) {
        $mid  = intdiv($low + $high, 2);
        $name = strtolower($sortedProducts[$mid]['name']);
        $kw   = strtolower($keyword);

        if ($name === $kw)     return $mid;   // Ketemu
        elseif ($name < $kw)  $low  = $mid + 1;
        else                  $high = $mid - 1;
    }
    return -1; // Tidak ditemukan
}
// Kompleksitas: O(log n) — jauh lebih efisien dari O(n)

a) Penyebab Error:

• Tabel order_details belum ada di database production, padahal sudah ada di local.
• Kemungkinan: migrasi belum dijalankan (php artisan migrate) di server production, atau file migrasi tidak ikut di-deploy.

b) Langkah Debugging Sistematis:

1. Baca log error lengkap: storage/logs/laravel.log atau tail -f storage/logs/laravel.log.
2. Cek apakah tabel ada di DB production: SHOW TABLES; (MySQL) atau \dt (PostgreSQL).
3. Cek status migrasi: php artisan migrate:status.
4. Jalankan migrasi yang pending: php artisan migrate --force.
5. Verifikasi dengan hit endpoint lagi dan pantau log.

c) Error Handling yang Baik:

public function getOrderDetails(int $orderId): JsonResponse {
    try {
        $details = OrderDetail::with('product')
            ->where('id_order', $orderId)
            ->get();

        if ($details->isEmpty()) {
            return response()->json(
                ['message' => 'Tidak ada detail order ditemukan'],
                404
            );
        }

        return response()->json(['data' => $details]);

    } catch (\Illuminate\Database\QueryException $e) {
        // Tangkap error spesifik DB
        Log::error('DB Error getOrderDetails', [
            'order_id' => $orderId,
            'message'  => $e->getMessage(),
        ]);
        return response()->json(
            ['error' => 'Terjadi kesalahan database'],
            500
        );
    }
}

a) 5 Prinsip UX:

1. Visibility of Status — Selalu tampilkan status sistem (loading spinner, "berhasil ditambahkan").
2. Consistency — Warna, ikon, tombol konsisten di seluruh halaman.
3. Error Prevention — Validasi form sebelum submit, konfirmasi sebelum hapus.
4. Efficiency — Fitur search, filter, dan paginasi agar user cepat temukan produk.
5. Aesthetic & Minimalist — Tampilkan info esensial saja; hindari informasi berlebihan.

b) Tabel Responsif (Pure CSS):

<style>
.table-wrap { overflow-x: auto; -webkit-overflow-scrolling: touch; }
table { width: 100%; border-collapse: collapse; min-width: 500px; }
th, td { padding: 10px 14px; border-bottom: 1px solid #e2e8f0; text-align: left; }
@media (max-width: 600px) {
    /* Stack layout untuk mobile */
    table, thead, tbody, th, td, tr { display: block; }
    td::before { content: attr(data-label); font-weight: 700; }
}
</style>
<div class="table-wrap"> <table> ... </table> </div>

c) Feedback Visual: Setiap aksi user harus mendapat respons visual segera (<100ms). Contoh: tombol berubah warna + teks "Ditambahkan!" saat klik "Tambah ke Keranjang", counter keranjang berubah angka, dan toast notification muncul. Tanpa feedback, user akan klik berkali-kali (double submit) karena tidak tahu aksinya berhasil.

a) Authentication vs Authorization:

• Authentication (Autentikasi): Memverifikasi identitas — "Siapa kamu?" Contoh: proses login dengan email + password.
• Authorization (Otorisasi): Memverifikasi hak akses — "Boleh apa kamu?" Contoh: hanya admin yang boleh hapus produk, meski user sudah login.

b) CSRF Protection Laravel:

• Laravel generate token unik per session dan menyimpannya di cookie XSRF-TOKEN.
• Setiap form POST/PUT/DELETE harus menyertakan @csrf (blade) yang menghasilkan hidden input token.
• Middleware VerifyCsrfToken membandingkan token di request dengan token session. Jika tidak cocok → 419 error.

{{-- Blade form --}}
<form method="POST" action="/orders">
    @csrf   {{-- <input type="hidden" name="_token" value="..." /> --}}
    ...
</form>

c) Simpan Password + Register/Login:

// Register: hash password sebelum simpan
public function register(Request $request) {
    $request->validate([
        'email'    => 'required|email|unique:users',
        'password' => 'required|min:8|confirmed',
    ]);
    $user = User::create([
        'name'     => $request->name,
        'email'    => $request->email,
        'password' => Hash::make($request->password), // bcrypt
    ]);
    Auth::login($user);
    return redirect('/dashboard');
}

// Login: verifikasi dengan Hash::check
public function login(Request $request) {
    $credentials = $request->only('email', 'password');
    if (Auth::attempt($credentials, $request->boolean('remember'))) {
        $request->session()->regenerate(); // Cegah session fixation
        return redirect()->intended('/dashboard');
    }
    return back()->withErrors(['email' => 'Kredensial tidak valid.']);
}

a) Jenis Test di Laravel:

• Unit Test: Menguji satu fungsi/method terisolasi, tanpa database/HTTP. Contoh: test fungsi calculateTotal().
• Integration Test: Menguji interaksi antar komponen (misal model + database). Menggunakan DB testing dengan RefreshDatabase.
• Feature Test: Menguji satu fitur end-to-end dari HTTP request hingga response. Paling umum di Laravel.

b) Feature Test untuk POST /orders:

use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\TestCase;

class OrderTest extends TestCase {
    use RefreshDatabase;

    // Skenario 1: Berhasil buat order
    public function test_user_can_create_order(): void {
        $user = User::factory()->create();
        $product = Product::factory()->create(['price' => 50000]);

        $response = $this->actingAs($user)->postJson('/orders', [
            'items' => [['product_id' => $product->id, 'qty' => 2]],
        ]);

        $response->assertStatus(201)
                 ->assertJsonPath('data.status', 'pending');
        $this->assertDatabaseHas('orders', ['customer' => $user->name]);
    }

    // Skenario 2: Gagal - belum login
    public function test_unauthenticated_cannot_create_order(): void {
        $response = $this->postJson('/orders', [
            'items' => [['product_id' => 1, 'qty' => 1]],
        ]);

        $response->assertStatus(401);
    }
}

c) Test-Driven Development (TDD): Pendekatan di mana test ditulis sebelum kode implementasi. Siklus: Red (tulis test yang gagal) → Green (tulis kode minimal agar test lulus) → Refactor (perbaiki kode tanpa mengubah fungsionalitas). TDD sebaiknya diterapkan pada fitur kritis (autentikasi, payment, logic bisnis utama), namun bisa terlalu lambat untuk prototyping awal atau UI yang sering berubah.

Monity adalah aplikasi personal finance tracker berbasis web yang membantu pengguna mencatat dan memantau keuangan pribadi mereka.

Fitur utama:

• Pencatatan transaksi (pemasukan & pengeluaran) dengan kategori otomatis
• Manajemen multi-rekening (bank, e-wallet, kas)
• Dashboard ringkasan dengan grafik tren 6 bulan
• AI Insight dari Google Gemini — analisis pola pengeluaran otomatis
• Autentikasi aman (email/password + Google OAuth)

Teknologi: Next.js 14 (App Router), TypeScript, Drizzle ORM, PostgreSQL (Supabase), NextAuth.js v5, Google Gemini AI, Tailwind CSS, Framer Motion, Zod, React Query.

Saya memilih Next.js 14 karena beberapa alasan teknis:

• Full-stack dalam satu project — API route (route.ts) dan halaman UI ada di tempat yang sama, tidak perlu backend terpisah.
• App Router & Server Components — rendering dilakukan di server untuk performa lebih baik dan SEO-friendly.
• TypeScript-first — cocok dikombinasikan dengan Drizzle ORM dan Zod untuk type safety end-to-end.
• Ekosistem React yang matang — banyak library (Framer Motion, React Query, Recharts) yang terintegrasi baik.

Dibanding Laravel (PHP), Next.js lebih cocok untuk aplikasi real-time dengan UI interaktif karena berbasis React.

Saya menggunakan Drizzle ORM dengan postgres.js untuk koneksi ke PostgreSQL di Supabase. Koneksi dikonfigurasi di src/lib/db/index.ts:

import { drizzle } from "drizzle-orm/postgres-js";
import postgres from "postgres";
import * as schema from "./schema";

// Connection string dari environment variable
const sql = postgres(process.env.DATABASE_URL!, {
    prepare: false  // wajib untuk Supabase Transaction Pool mode
});

// Instance tunggal db, dipakai di semua API route
export const db = drizzle(sql, { schema });

Kenapa prepare: false? Karena Supabase menggunakan Transaction Pooler yang tidak mendukung prepared statements.

Schema tabel dibuat di src/lib/db/schema.ts menggunakan TypeScript, lalu di-push ke DB dengan npx drizzle-kit push.

Saya menggunakan NextAuth.js v5 yang mendukung dua metode login:

1. Email & Password — Password di-hash dengan bcryptjs sebelum disimpan ke DB. Saat login, hash dibandingkan menggunakan bcrypt.compare().
2. Google OAuth — User bisa login dengan akun Google. NextAuth menangani seluruh alur OAuth secara otomatis.

Session disimpan di tabel session (database strategy). Setiap API route di-protect dengan pengecekan session:

const session = await auth();
if (!session?.user?.id) {
    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
}

Untuk proteksi halaman, saya menggunakan middleware di middleware.ts yang mengecek session sebelum request sampai ke halaman dashboard.

OOP (Object-Oriented Programming) adalah paradigma yang mengorganisir kode dalam bentuk objek dengan properti dan method. 4 pilarnya: Encapsulation, Inheritance, Polymorphism, Abstraction.

Di Monity (TypeScript), OOP diwujudkan dengan:

• Interface — blueprint/kontrak tipe data, misalnya FinancialSummary di src/lib/ai/gemini.ts.
• Class — new GoogleGenerativeAI(apiKey) untuk instantiasi objek Gemini AI.
• Encapsulation via Zod — validasi data tersembunyi di dalam schema, tidak bisa bypass dari luar.
• Type Inference — typeof transactions.$inferSelect menghasilkan tipe otomatis dari schema database.

// Interface = kontrak data (seperti abstract class PHP)
export interface FinancialSummary {
    totalIncome: number;
    totalExpense: number;
    topExpenseCategories: { category: string; amount: number }[];
}

// Class instantiation
const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY!);
const model = genAI.getGenerativeModel({ model: "gemini-2.5-flash-lite" });

Saya melakukan validasi di dua lapisan:

1. Frontend (React Hook Form) — validasi real-time saat user mengisi form, sebelum data dikirim ke server.
2. Backend (Zod) — validasi di API route sebelum data diproses atau disimpan ke database. Ini lapisan keamanan utama.

// src/lib/validations.ts — Zod schema
export const createTransactionSchema = z.object({
    accountId: z.string().min(1, "Akun wajib dipilih"),
    type:      z.enum(["income", "expense"]),
    amount:    z.coerce.number().positive("Nominal harus lebih dari 0"),
    transactionDate: z.coerce.date(),
    categoryId:  z.string().optional(),
    description: z.string().optional(),
});

// Di API route — validasi sebelum insert
const parsed = createTransactionSchema.safeParse(body);
if (!parsed.success) {
    return NextResponse.json({ error: "Validation failed" }, { status: 400 });
}

Dengan Zod, pesan error otomatis muncul dan tipe data sudah tervalidasi. Tidak ada cara bypass validasi dari client.

Saya menerapkan error handling berlapis:

• try/catch di setiap API route — semua operasi async dibungkus try/catch.
• HTTP Status Code yang tepat — 400 (validasi gagal), 401 (belum login), 404 (data tidak ada), 409 (konflik data), 500 (server error).
• console.error untuk logging — error dicatat di server log untuk debugging.
• Frontend toast notification — user mendapat pesan yang informatif sesuai response API.

try {
    const parsed = createTransactionSchema.safeParse(body);
    if (!parsed.success)
        return NextResponse.json({ error: "Validation failed" }, { status: 400 });

    // ... proses bisnis

    return NextResponse.json({ transaction: result }, { status: 201 });

} catch (error) {
    console.error("Transaction create error:", error); // Log ke server
    return NextResponse.json({ error: "Terjadi kesalahan server" }, { status: 500 });
}

Migrasi database adalah proses mengubah struktur database (tambah tabel, kolom, relasi) secara terversi dan terkontrol, bukan manual lewat GUI.

Di Monity, saya menggunakan Drizzle Kit. Alurnya:

1. Ubah schema TypeScript di src/lib/db/schema.ts
2. Jalankan npx drizzle-kit generate → generate file SQL migrasi di folder drizzle/
3. Jalankan npx drizzle-kit push → apply langsung ke Supabase PostgreSQL

Keuntungannya: schema tersimpan di kode (version control), perubahan bisa di-rollback, dan konsisten di semua environment (local, production).

-- File drizzle/0000_smiling_blue_blade.sql (di-generate otomatis)
CREATE TABLE "transaction" (
    "id"           TEXT PRIMARY KEY NOT NULL,
    "user_id"      TEXT NOT NULL REFERENCES "user"(id) ON DELETE CASCADE,
    "account_id"   TEXT NOT NULL REFERENCES "finance_account"(id) ON DELETE CASCADE,
    "amount"       NUMERIC(15, 2) NOT NULL,
    "created_at"   TIMESTAMP DEFAULT now() NOT NULL
);

Saya menggunakan Drizzle ORM query builder yang menghasilkan SQL asli secara type-safe. Di src/app/api/transactions/route.ts:

// TypeScript / Drizzle ORM
const result = await db.query.transactions.findMany({
    where: and(
        eq(transactions.userId, session.user.id),
        gte(transactions.transactionDate, startDate),  // >= tanggal awal
        lte(transactions.transactionDate, endDate),    // <= tanggal akhir
        type ? eq(transactions.type, type) : undefined // filter income/expense
    ),
    with: {
        account:  true,  // LEFT JOIN ke tabel finance_account
        category: true,  // LEFT JOIN ke tabel category
    },
    orderBy: [desc(transactions.transactionDate)],  // sort descending
    limit:  50,   // maksimal 50 per halaman
    offset: page * 50, // paginasi
});

SQL yang di-generate setara dengan:

SELECT t.*, a.name as account_name, c.name as category_name
FROM "transaction" t
LEFT JOIN "finance_account" a ON t.account_id = a.id
LEFT JOIN "category" c ON t.category_id = c.id
WHERE t.user_id = $1
  AND t.transaction_date >= $2
  AND t.transaction_date <= $3
ORDER BY t.transaction_date DESC
LIMIT 50 OFFSET 0;

Saya mengintegrasikan Google Gemini AI (model gemini-2.5-flash-lite) untuk fitur Financial Insight. Ada 3 jenis insight:

• monthly_summary — ringkasan keuangan bulanan (total income, expense, saldo).
• spending_alert — peringatan jika pengeluaran bulan ini naik signifikan dibanding bulan lalu.
• saving_tip — tips menabung berdasarkan pola pengeluaran kategori terbesar.

Cara kerjanya: data transaksi dikumpulkan → diformat menjadi summary → dikirim ke Gemini sebagai prompt → Gemini menghasilkan teks insight dalam Bahasa Indonesia → insight disimpan di tabel insight dan ditampilkan di dashboard.

// src/lib/ai/gemini.ts
const model = genAI.getGenerativeModel({ model: "gemini-2.5-flash-lite" });
const prompt = `Kamu adalah asisten keuangan pribadi...
Data keuangan bulan ini: ${JSON.stringify(summary)}
Berikan insight singkat dalam Bahasa Indonesia...`;
const result = await model.generateContent(prompt);
const text   = result.response.text();

Proyek menggunakan struktur Next.js App Router yang modular — setiap folder punya tanggung jawab yang jelas (Separation of Concerns):

src/
├── app/
│   ├── (auth)/          ← Halaman Login & Register
│   ├── (dashboard)/     ← Dashboard, Transaksi, Akun, Insight
│   └── api/             ← REST API handlers (route.ts)
│       ├── transactions/
│       ├── accounts/
│       ├── insights/
│       └── auth/
├── components/
│   ├── layout/          ← Sidebar, Navbar
│   ├── dashboard/       ← Widget summary, chart
│   ├── transactions/    ← Form, list transaksi
│   └── ui/              ← Button, Modal, Dialog (reusable)
└── lib/
    ├── db/              ← Schema Drizzle + koneksi
    ├── ai/              ← Gemini integration
    ├── auth/            ← NextAuth config
    ├── hooks/           ← Custom React hooks
    ├── validations.ts   ← Semua Zod schema
    └── utils.ts         ← Helper functions

Keuntungan: mudah ditemukan, mudah di-maintain, dan setiap bagian bisa diuji secara terpisah.

Keamanan diterapkan di beberapa lapisan:

1. Password hashing — bcryptjs dengan salt rounds 10. Password tidak pernah disimpan plain text.
2. Session-based auth — NextAuth.js mengelola session di server; token tidak terekspos ke client.
3. Row-level security — setiap query selalu memfilter by user_id dari session yang terverifikasi, bukan dari input client.
4. Zod validation — mencegah SQL injection dan data malformasi dari input user.
5. Environment variables — semua secret (DB URL, API key) ada di .env, tidak di-hardcode dan tidak di-commit ke git.
6. HTTPS (Supabase) — koneksi database terenkripsi TLS/SSL.

// Setiap query selalu scope ke user yang login
const transactions = await db.query.transactions.findMany({
    where: eq(transactions.userId, session.user.id), // ← WAJIB ada!
});

Saya melakukan pengujian melalui beberapa pendekatan:

1. Zod safeParse() sebagai unit test fungsional — setiap kali schema diubah, validasi langsung diuji dengan input valid dan invalid.
2. Manual API testing — setiap endpoint diuji dengan berbagai skenario: input valid, input invalid, tanpa login, data tidak ditemukan.
3. Browser testing — UI diuji di Chrome, Firefox, dan mobile untuk memastikan responsivitas.

Contoh skenario yang sudah diuji:

• POST /api/transactions dengan amount negatif → 400 Bad Request ✅
• GET /api/transactions tanpa session → 401 Unauthorized ✅
• POST /api/auth/register dengan email yang sama → 409 Conflict ✅
• DELETE /api/accounts/:id → balance rekening lain tidak terpengaruh ✅

Ada beberapa tantangan teknis yang saya hadapi:

1. Sinkronisasi saldo rekening — Saat transaksi dibuat/diupdate/dihapus, saldo rekening harus ikut berubah secara akurat.
   Solusi: Menggunakan SQL expression balance + balanceChange langsung di query UPDATE untuk operasi atomic, bukan read-update terpisah.
2. Supabase Connection Pool — Awalnya error karena prepared statement tidak didukung.
   Solusi: Menambahkan prepare: false di konfigurasi postgres.js.
3. Prompt engineering Gemini AI — Respons AI tidak konsisten formatnya.
   Solusi: Membuat prompt yang sangat spesifik dengan instruksi format output yang jelas dan membatasi panjang output.

Ada beberapa fitur yang ingin saya kembangkan:

• Budget Planning — user bisa set anggaran per kategori per bulan, dengan alert ketika mendekati batas.
• Export laporan — unduh laporan transaksi dalam format PDF atau Excel untuk keperluan pembukuan.
• Transfer antar rekening — fitur transfer yang otomatis mengurangi saldo rekening asal dan menambah saldo rekening tujuan.
• Recurring transaction — transaksi berulang otomatis (gaji bulanan, tagihan rutin).
• Mobile app — versi PWA (Progressive Web App) agar bisa diinstall di smartphone.

Ini menunjukkan bahwa saya memahami kebutuhan pengguna dan punya roadmap pengembangan yang jelas.