fastify-multi-db-query-builder

Fastify DB Query Builder

Query Builder untuk Fastify yang dapat mengkonversi query ke format yang sesuai dengan database engine yang digunakan (MongoDB atau SQL via Knex).

Instalasi

npm install fastify-multi-db-query-builder

Registrasi Plugin

const fastify = require('fastify')();

// Registrasi plugin
fastify.register(require('fastify-multi-db-query-builder'), {
  decoratorName: 'queryBuilder', // default
  dbEngine: 'pg', // default, bisa 'mongodb', 'mysql', 'sqlite', 'mssql'
  dbDecorator: 'pg' // default, nama decorator untuk database
});

Cara Penggunaan yang Benar

1. Menggunakan fastify.db() sebagai Function

// Cara 1: fastify.db() tanpa parameter
const users = await fastify.db()
  .from('users')
  .select('id', 'name', 'email')
  .where('status', 'active')
  .get();

// Cara 2: fastify.db() dengan table name
const users = await fastify.db('users')
  .select('id', 'name', 'email')
  .where('status', 'active')
  .get();

2. Helper Methods

// Query untuk SQL database
const sqlUsers = await fastify.db.sql('users')
  .where('status', 'active')
  .get();

// Query untuk MongoDB
const mongoUsers = await fastify.db.mongo('users')
  .where('status', 'active')
  .get();

// Query dengan engine default
const defaultUsers = await fastify.db.query('users')
  .where('status', 'active')
  .get();

3. Contoh Penggunaan dalam Hook

fastify.addHook('preHandler', async (request, reply) => {
  const apiKey = request.headers['x-api-token'];
  const appKey = request.headers['x-app-key'];
  
  // Menggunakan fastify.db() untuk query
  const app = await fastify.db('d_application')
    .where('uid_user_system', apiKey)
    .where('app_key', appKey)
    .first();
  
  if (!app) {
    return reply.status(401).send({ status: false, message: 'Invalid API key' });
  }
  
  request.app = app;
});

4. Helper Functions

async function getApp(fastify, apiKey, appKey) {
  return await fastify.db('d_application')
    .where('uid_user_system', apiKey)
    .where('app_key', appKey)
    .first();
}

async function getUser(fastify, userId) {
  return await fastify.db('users')
    .where('id', userId)
    .first();
}

async function getPackage(fastify, packageId) {
  if (process.env.DB_ENGINE === 'mongodb') {
    return await fastify.mongoose.Packages.findById(packageId).lean();
  }
  return await fastify.db('packages')
    .where('id', packageId)
    .first();
}

Penggunaan Global (Tanpa Fastify)

Library ini juga dapat digunakan secara global tanpa harus selalu mendaftarkan Knex/Mongoose terlebih dahulu. Berikut adalah berbagai cara penggunaannya:

1. Global Registration

const { QueryBuilder } = require('fastify-multi-db-query-builder');
const KnexAdapter = require('fastify-multi-db-query-builder/lib/adapters/knexAdapter');
const MongoAdapter = require('fastify-multi-db-query-builder/lib/adapters/mongoAdapter');

// Setup Knex secara global
const knex = require('knex')({
  client: 'pg',
  connection: {
    host: 'localhost',
    user: 'postgres',
    password: 'password',
    database: 'testdb'
  }
});

// Mendaftarkan Knex secara global
KnexAdapter.registerGlobal(knex, 'db');

// Setup Mongoose secara global
const mongoose = require('mongoose');
MongoAdapter.registerGlobal(mongoose, 'default');

// Sekarang bisa menggunakan QueryBuilder tanpa fastify
const mockFastify = {};

// Query SQL
const sqlBuilder = new QueryBuilder(mockFastify, { dbEngine: 'pg' });
const users = await sqlBuilder
  .from('users')
  .select('id', 'name', 'email')
  .where('status', 'active')
  .get();

// Query MongoDB
const mongoBuilder = new QueryBuilder(mockFastify, { dbEngine: 'mongodb' });
const mongoUsers = await mongoBuilder
  .from('users')
  .select('name', 'email', 'status')
  .where('status', 'active')
  .get();

2. Environment Variables

// Set environment variables
process.env.DB_CLIENT = 'pg';
process.env.DB_HOST = 'localhost';
process.env.DB_PORT = '5432';
process.env.DB_USER = 'postgres';
process.env.DB_PASSWORD = 'password';
process.env.DB_NAME = 'testdb';
process.env.MONGO_URI = 'mongodb://localhost:27017/testdb';

const mockFastify = {};

// Query SQL menggunakan environment variables
const sqlBuilder = new QueryBuilder(mockFastify, { dbEngine: 'pg' });
const users = await sqlBuilder
  .from('users')
  .select('id', 'name')
  .where('status', 'active')
  .get();

// Query MongoDB menggunakan environment variables
const mongoBuilder = new QueryBuilder(mockFastify, { dbEngine: 'mongodb' });
const mongoUsers = await mongoBuilder
  .from('users')
  .select('name', 'email')
  .where('status', 'active')
  .get();

3. Config Registration

// Mendaftarkan konfigurasi database
KnexAdapter.registerConfig({
  client: 'pg',
  connection: {
    host: 'localhost',
    user: 'postgres',
    password: 'password',
    database: 'testdb'
  }
}, 'main');

MongoAdapter.registerConfig({
  uri: 'mongodb://localhost:27017/testdb',
  options: {
    useNewUrlParser: true,
    useUnifiedTopology: true
  }
}, 'main');

const mockFastify = {
  dbConfig: global.dbConfigs?.main,
  mongoConfig: global.mongoConfigs?.main
};

// Query SQL menggunakan config
const sqlBuilder = new QueryBuilder(mockFastify, { dbEngine: 'pg' });
const users = await sqlBuilder
  .from('users')
  .select('id', 'name')
  .where('status', 'active')
  .get();

// Query MongoDB menggunakan config
const mongoBuilder = new QueryBuilder(mockFastify, { dbEngine: 'mongodb' });
const mongoUsers = await mongoBuilder
  .from('users')
  .select('name', 'email')
  .where('status', 'active')
  .get();

4. Mixed Approach (SQL + MongoDB)

// Setup Knex untuk SQL
const knex = require('knex')({
  client: 'pg',
  connection: {
    host: 'localhost',
    user: 'postgres',
    password: 'password',
    database: 'testdb'
  }
});

// Setup Mongoose untuk MongoDB
const mongoose = require('mongoose');
await mongoose.connect('mongodb://localhost:27017/testdb');

// Mendaftarkan keduanya secara global
KnexAdapter.registerGlobal(knex, 'main');
MongoAdapter.registerGlobal(mongoose, 'main');

const mockFastify = {};

// Query SQL
const sqlBuilder = new QueryBuilder(mockFastify, { dbEngine: 'pg' });
const sqlUsers = await sqlBuilder
  .from('users')
  .select('id', 'name', 'email')
  .where('status', 'active')
  .limit(5)
  .get();

// Query MongoDB
const mongoBuilder = new QueryBuilder(mockFastify, { dbEngine: 'mongodb' });
const mongoUsers = await mongoBuilder
  .from('users')
  .select('name', 'email', 'status')
  .where('status', 'active')
  .limit(5)
  .get();

// Insert data ke SQL
const newSqlUser = await sqlBuilder
  .from('users')
  .insert({
    name: 'John Doe',
    email: '[e-mail]',
    status: 'active'
  });

// Insert data ke MongoDB
const newMongoUser = await mongoBuilder
  .from('users')
  .insert({
    name: 'Jane Doe',
    email: '[e-mail]',
    status: 'active',
    createdAt: new Date()
  });

Fitur

• ✅ Mendukung MongoDB dan SQL database (PostgreSQL, MySQL, SQLite, MSSQL) melalui Knex
• ✅ API yang konsisten untuk semua database engine
• ✅ Konversi otomatis query ke format yang sesuai
• ✅ Mendukung operasi dasar CRUD (Create, Read, Update, Delete)
• ✅ Plugin Fastify yang mudah digunakan
• ✅ Helper methods untuk database yang berbeda
• ✅ Penggunaan global tanpa Fastify
• ✅ Auto-initialization dari environment variables
• ✅ Config registration untuk setup yang fleksibel
• ✅ fastify.db() sebagai function

Cara Penggunaan

1. Query Builder Dasar

// Menggunakan query builder dengan engine default
const users = await fastify.queryBuilder()
  .from('users')
  .where('status', 'active')
  .get();

// Menggunakan query builder dengan engine tertentu
const mongoUsers = await fastify.queryBuilder({ dbEngine: 'mongodb' })
  .from('users')
  .where('status', 'active')
  .get();

2. Helper Methods

// Query untuk SQL database (PostgreSQL, MySQL, SQLite, MSSQL)
const sqlUsers = await fastify.db.sql('users')
  .where('status', 'active')
  .get();

// Query untuk MongoDB
const mongoUsers = await fastify.db.mongo('users')
  .where('status', 'active')
  .get();

// Query dengan engine default
const defaultUsers = await fastify.db.query('users')
  .where('status', 'active')
  .get();

3. Query dengan Engine Tertentu

// Mendapatkan query builder dengan engine tertentu
const pgQuery = fastify.getQueryBuilder('pg');
const mongoQuery = fastify.getQueryBuilder('mongodb');

const users = await pgQuery.from('users').get();
const mongoUsers = await mongoQuery.from('users').get();

API Reference

Query Builder Methods

from(tableName)

Menentukan tabel atau koleksi yang akan digunakan.

fastify.queryBuilder().from('users')

where(field, operator, value)

Menambahkan kondisi where.

// Format 1: where(field, value)
fastify.queryBuilder().from('users').where('status', 'active')

// Format 2: where(field, operator, value)
fastify.queryBuilder().from('users').where('age', '>', 18)

// Format 3: where({field1: value1, field2: value2})
fastify.queryBuilder().from('users').where({status: 'active', age: 18})

whereIn(field, values)

Menambahkan kondisi where dengan operator IN.

fastify.queryBuilder().from('users').whereIn('role', ['admin', 'user'])

whereNotIn(field, values)

Menambahkan kondisi where dengan operator NOT IN.

fastify.queryBuilder().from('users').whereNotIn('role', ['admin'])

whereLike(field, value)

Menambahkan kondisi where dengan operator LIKE.

fastify.queryBuilder().from('users').whereLike('name', '%john%')

select(...fields)

Menentukan field yang akan diambil.

fastify.queryBuilder().from('users').select('id', 'name', 'email')

orderBy(field, direction)

Mengurutkan hasil query.

fastify.queryBuilder().from('users').orderBy('created_at', 'desc')

limit(limit)

Membatasi jumlah hasil.

fastify.queryBuilder().from('users').limit(10)

skip(skip) / offset(offset)

Melewati sejumlah hasil.

fastify.queryBuilder().from('users').skip(20)
// atau
fastify.queryBuilder().from('users').offset(20)

Execution Methods

get()

Mengeksekusi query dan mendapatkan semua hasil.

const users = await fastify.queryBuilder().from('users').get()

first()

Mengeksekusi query dan mendapatkan hasil pertama.

const user = await fastify.queryBuilder().from('users').where('id', 1).first()

insert(data)

Menyisipkan data baru.

// Menyisipkan satu data
const newUser = await fastify.queryBuilder().from('users').insert({
  name: 'John Doe',
  email: '[e-mail]'
})

// Menyisipkan banyak data
const newUsers = await fastify.queryBuilder().from('users').insert([
  { name: 'John Doe', email: '[e-mail]' },
  { name: 'Jane Doe', email: '[e-mail]' }
])

update(data)

Memperbarui data.

const updatedCount = await fastify.queryBuilder()
  .from('users')
  .where('id', 1)
  .update({ name: 'John Updated' })

delete()

Menghapus data.

const deletedCount = await fastify.queryBuilder()
  .from('users')
  .where('id', 1)
  .delete()

count(field)

Menghitung jumlah data.

const userCount = await fastify.queryBuilder()
  .from('users')
  .where('status', 'active')
  .count()

toSQL() (hanya untuk SQL database)

Mendapatkan query SQL.

const sql = fastify.queryBuilder()
  .from('users')
  .where('status', 'active')
  .toSQL()
console.log(sql) // SELECT * FROM "users" WHERE "status" = 'active'

Konfigurasi

Query Builder akan menggunakan konfigurasi database yang sudah ada di aplikasi:

• Untuk MongoDB, menggunakan koneksi Mongoose yang sudah terdaftar di Fastify
• Untuk SQL database, menggunakan koneksi Knex yang sudah terdaftar di Fastify

Environment Variables

# Database engine default
DB_ENGINE=pg # atau mongodb, mysql, sqlite, mssql

# Knex decorator name (jika menggunakan Knex)
DB_DECORATOR=db

Contoh Penggunaan dalam Route

// Route untuk mendapatkan semua user
fastify.get('/users', async (request, reply) => {
  try {
    const users = await fastify.queryBuilder()
      .from('users')
      .select('id', 'name', 'email')
      .where('status', 'active')
      .orderBy('created_at', 'desc')
      .limit(10)
      .get();

    return { success: true, data: users };
  } catch (error) {
    reply.code(500);
    return { success: false, error: error.message };
  }
});

// Route untuk membuat user baru
fastify.post('/users', async (request, reply) => {
  try {
    const userData = request.body;
    
    const newUser = await fastify.queryBuilder()
      .from('users')
      .insert(userData);

    reply.code(201);
    return { success: true, data: newUser };
  } catch (error) {
    reply.code(500);
    return { success: false, error: error.message };
  }
});

Dependencies

Library ini memerlukan dependencies berikut:

• fastify (peer dependency)
• knex (untuk SQL database)
• mongoose (untuk MongoDB)

License

MIT