28. Membuat Resolver untuk Menambahkan User Baru: Panduan Lengkap dan Praktis

Resolver adalah jantung dari GraphQL API. Mereka bertugas “menyambungkan” request dari client ke logic business backend, termasuk database dan service lain. Salah satu use-case paling fundamental dalam pengembangan aplikasi modern adalah menambahkan user baru—entah untuk aplikasi SaaS, e-commerce, atau platform komunitas. Dalam artikel ke-28 dari seri belajar GraphQL dan backend engineering ini, saya akan mengulas step-by-step cara membangun sebuah resolver untuk menambah user baru. Tutorial ini diiringi kode sumber praktis, simulasi request, diagram alur data, serta tips best practice dari pengalaman langsung.

Mengapa Resolver untuk User Sangat Penting?

Penambahan user adalah entry point hampir semua aplikasi. Tidak hanya soal menyimpan data ke database, proses ini melibatkan validasi, hashing password, handling error, hingga notifikasi. Dengan pattern resolver, semua ini bisa dikustomisasi sesuai kebutuhan, tetap terstruktur, dan mudah di-maintain.

Skema User dan Setup Environment

Asumsikan kita menggunakan Node.js, Express, dan graphql serta database MongoDB dengan ODM Mongoose.

Contoh skema GraphQL User:

type User {
  id: ID!
  username: String!
  email: String!
  createdAt: String!
}

input AddUserInput {
  username: String!
  email: String!
  password: String!
}

type Mutation {
  addUser(input: AddUserInput!): User!
}

Model MongoDB dengan Mongoose

Sebelum masuk ke resolver, kita setup model mongoose berikut:

// models/User.js
const mongoose = require('mongoose');

const userSchema = new mongoose.Schema({
  username: { type: String, unique: true },
  email:    { type: String, unique: true },
  password: { type: String },
  createdAt:{ type: Date, default: Date.now }
});

module.exports = mongoose.model('User', userSchema);

Resolver Fungsional: Step by Step

Mari kita breakdown prosesnya dalam langkah-langkah berikut.

1. Menerima Input

Resolver menerima argumen input dari mutation GraphQL:

mutation {
  addUser(input: {
    username: "johndoe",
    email: "john@example.com",
    password: "securepass123"
  }) {
    id
    username
    email
    createdAt
  }
}

2. Validasi Data

Lakukan validasi sederhana—cek apakah username & email sudah unik, dan password minimal 6 karakter.

3. Hash Password

Gunakan bcrypt untuk menjaga keamanan password.

4. Simpan ke Database

Simpan record baru ke MongoDB.

5. Return Data User (Tanpa Password!)

Struktur Resolver-nya

// resolvers/userResolver.js
const User = require('../models/User');
const bcrypt = require('bcrypt');

module.exports = {
  Mutation: {
    addUser: async (_, { input }) => {
      const { username, email, password } = input;
      
      // 1. Validasi input
      if (!username || !email || !password) 
        throw new Error('Semua field wajib diisi.');

      if (password.length < 6)
        throw new Error('Password minimal 6 karakter.');

      // 2. Cek duplikasi email/username
      const existUser = await User.findOne({ $or: [ { email }, { username } ] });
      if (existUser) throw new Error('User sudah terdaftar.');

      // 3. Hash password
      const hashedPwd = await bcrypt.hash(password, 10);

      // 4. Simpan user baru
      const user = new User({
        username,
        email,
        password: hashedPwd
      });

      await user.save();

      // 5. Kembalikan user tanpa password
      return {
        id: user._id,
        username: user.username,
        email: user.email,
        createdAt: user.createdAt.toISOString()
      };
    }
  }
};

Diagram Alur Proses Resolver

Berikut diagram alur data dari user mendaftar hingga data disimpan, menggunakan mermaid:

flowchart TD
  A[Client Mengirim AddUser Mutation] --> B[GraphQL Server Menerima Input]
  B --> C{Validasi Input}
  C -- Tidak Valid --> D[Return Error Ke Client]
  C -- Valid --> E[Cek Duplikasi di Database]
  E -- User Ada --> D
  E -- Tidak Ada --> F[Hash Password]
  F --> G[Simpan User Baru ke DB]
  G --> H[Kembalikan Data User]
  H --> I[Client Mendapat Data User]

Simulasi: Percakapan Client dan Server

Mari kita lihat ilustrasi dialog antara client dan server:

Tips Best Practice

Beberapa tips tambahan dari pengalaman saya:

Kustomisasi Advanced

Di production, biasanya flow addUser dikembangkan lebih lanjut dengan:

• Email verifikasi: Kirim email konfirmasi untuk aktivasi akun
• Rate limiting: Batasi pembuatan user per IP untuk mencegah spam
• Integrasi SSO: Tambahkan SSO Google, Apple, dsb
• Async jobs: Kirim email via queue (misal pakai Bull, RabbitMQ)

Kesimpulan

Membuat resolver GraphQL untuk menambah user adalah pondasi utama dalam pengembangan backend modern. Dengan pendekatan modular—mulai validasi input, hash password, sampai error handling—kita dapat memastikan proses onboarding user yang aman dan terstruktur.

Kunci dari artikel ini:

• Resolver = Jembatan antara GraphQL dan logic backend
• Selalu lakukan validasi & proteksi data sensitif
• Bangun reusable pattern dari awal.
• Kembangkan sesuai kebutuhan bisnis & keamanan.

Semoga langkah-langkah di atas jadi referensi buat Anda membangun backend yang scalable dan secure! Selamat bereksperimen, tinggalkan komentar jika ada pertanyaan atau insight tambahan.

Referensi Lanjut:

• GraphQL.org: Resolvers
• bcrypt npm
• Validasi input dengan Joi

Terima kasih sudah membaca! 🚀👨‍💻