Documentation Generator, Design Patterns — Minggu terakhir Sprint 3

Apa yang sudah dilakukan

Dalam minggu terakhir penutupan sprint 3 ini, saya sudah melakukan beberapa hal dalam minggu terakhir ini diantaranya adalah:

• Mendengarkan technology sharing yang sangat keren dan bermanfaat dari teman-teman pada kelas minggu lalu. Melalui hal tersebut saya menjadi tertarik untuk mencoba menerapkan Socket.io mungkin dalam project lainnya. Firebase juga sangat menarik untuk digunakan dan dikembangkan dalam aplikasi yang ada.
• Membuat module untuk mengirimkan e-mail. Pada dasarnya saya menggunakan module yang sudah ada yaitu berasal dari nodemailer. Yang saya lakukan adalah mengimplementasikan nodemailer dalam sebuah module yang siap digunakan dalam module fungsi ketika melakukan set password.
• Selain itu, saya mendapatkan story untuk menyelesaikan CRUD Employee, dalam kasus ini, saya menambahkan beberapa fungsi baru dalam module Employee. Selain itu saya juga melengkapi tampilan antar muka yang diperlukan dan membuat unit testing untuk setiap fungsi yang ada :D
• Selain hal diatas, dalam minggu ini saya belajar beberapa hal baru seperti jsDOC, yang akan saya jelaskan lebih lanjut pada blog berikut.

Documentation Generator

Berbicara mengenai dokumentasi, tentu saja sebagai programmer yang baik harus bisa mendokumentasikan segala informasi terkait dengan program yang sudah dibuat. Memang tidak ada definisi dokumentasi seperti apa yang baik dan harusnya dibuat oleh seorang programmer, tetapi dalam kasus documentation generator, sudah ada beberapa orang yang mencetuskan untuk membuat generator (otomatis akan menghasilkan) dokumentasi untuk kode yang sudah dibuat. Langsung saja kita berkenalan dengan JSDoc.

JSDoc 3 is an API documentation generator for JavaScript, similar to Javadoc or phpDocumentor. You add documentation comments directly to your source code, right alongside the code itself. The JSDoc tool will scan your source code and generate an HTML documentation website for you. ~ http://usejsdoc.org/about-getting-started.html

Seperti yang sudah tertulis diatas, JSDoc akan membantu kita dalam menghasilkan dokumentasi yang mudah dilihat dengan format web. Langsung saja mari kita mulai bagaimana cara penggunaannya.

Untuk melakukan instalasi, caranya cukup mudah, silahkan mengetikkan kode berikut:

npm install jsdoc

Setelah berhasil menginstall JSDoc, maka langkah selanjutnya adalah dengan mengetikkan dokumentasi yang sesuai pada module Javascript kita. Berikut adalah contoh dokumentasi yang saya buat.

/**
* Module handler untuk employee
* @module handler/semployee
*/
/**
* Menggunakan utils/date untuk parsing tanggal
*/
var date = require('../utils/date');
/**
* Menggunakan model dalam kasus ini menggunakan Employee model
*/
var model = require('../models');
/**
* Sequelize untuk memanggil fungsi model yang menggunakan sequelize
*/
var Sequelize = require('sequelize');
/**
* fungsi yang di export
*/
module.exports = {
   /**
   * Menampilkan halaman create employee
   * @param {Object} req - Akan berisi request dari router
   * @param {Object} res - Akan berisi result dari request
   */
   viewCreateEmployee: function(req, res) {
      res.render('employee-create', {
         message: req.flash('message')
      });
   },
   
   /**
   * Menampilkan halaman list employee   
   * Menggunakan model Employee untuk query semua employee yang ada
   * @param {Object} req - Akan berisi request dari router
   * @param {Object} res - Akan berisi result dari request
   */
   viewListEmployee: function(req, res) {
      model.Employee.findAll()
         .then(function(employees) {
            res.render('employee-list', {
               employees: employees,
               message: req.flash('message')
            });
         });
   },

Setelah itu, cukup jalankan perintah berikut:

jsdoc namafile.js

Maka akan dihasilkan sebuah folder out yang didalamnya terdapat file HTML yang ketika diakses akan memperlihatkan hasil sebagai berikut.

Fundamental Node.js Design Patterns

Ketika berbicara mengenai design patterns kita akan memikirkan tentang singletons, observers atau factories.

Apa itu design pattern?

A design pattern is a general, reusable solution to a commonly occurring problem.

Singletons

Pattern singleton melakukan restriksi jumlah instantiasi dari sebuah kelas menjadi satu. Membuat singleton dalam Node.js cukup mudah, sebagaimana kode require membantu kita. Berikut adalah contohnya.

//area.js
var PI = Math.PI;
function circle (radius) {  
  return radius * radius * PI;
}
module.exports.circle = circle;

Berapa kali kita menggunakan module ini, kita hanya cukup memanggilnya saja kembali dengan kode require .

var areaCalc = require('./area');
console.log(areaCalc.circle(5));

Karena itu, singleton adalah design pattern paling umum yang sering digunakan terutama pada module dalam NPM.

Observers

Sebuah object yang mengelola beberapa dependents/observers dan memberikan notifikasi kepada mereka untuk melakukan perubahan state. Untuk melakukan implementasi observer pattern, dipanggil EventEmitter.

// MyFancyObservable.js
var util = require('util');  
var EventEmitter = require('events').EventEmitter;
function MyFancyObservable() {  
  EventEmitter.call(this);
}
util.inherits(MyFancyObservable, EventEmitter);

Setelah itu, kita sudah membuat objek yang observable. Selanjutnya kita tinggal menambahkan fungsionalitasnya.

MyFancyObservable.prototype.hello = function (name) {  
  this.emit('hello', name);
};

Setelah ini, objek observable kita bisa emit sebuah event, misalnya:

var MyFancyObservable = require('MyFancyObservable');  
var observable = new MyFancyObservable();
observable.on('hello', function (name) {  
  console.log(name);
});
observable.hello('john');

Factories

Patten factory adalah pattern yang menciptakan dan tidak membutuhkan pembuatan constructor tetapi membutuhkan interface generic untuk membuat objek. Pattern ini sangat berguna ketika pembuatan proses kompleks.

function MyClass (options) {  
  this.options = options;
}
function create(options) {  
  // modify the options here if you want
  return new MyClass(options);
}
module.exports.create = create;

Factories juga membuat test menjadi lebih mudah, dimana kita bisa menginject module yang menggunakan pattern ini.

Dependency Injection

Dependency injection is a software design pattern in which one or more dependencies (or services) are injected, or passed by reference, into a dependent object.

Dalam contoh berikut, kita membuat UserModel yang menggunakan dependeny database.

function userModel (options) {  
  var db;
  if (!options.db) {
    throw new Error('Options.db is required');
  }
  db = options.db;
  return {
    create: function (done) {
      db.query('INSERT ...', done);
    }
  }
}
module.exports = userModel;

Kita bisa membuat instance dari UserModel dengan:

var db = require('./db');
var userModel = require('User')({  
  db: db
});

Hal ini membanti dalam hal mempermudah testing, dimana kita bisa dengan mudah menginject instance kedalam model.