DEV Community: Harsh Rastogi

Factory Method In Brief: Design Pattern

Harsh Rastogi — Thu, 13 Oct 2022 08:26:58 +0000

This pattern is a Creational Design Pattern that provides an interface or abstract for creating the type of object in a superclass but allows the subclass to change the type of object that will be created.

It suggests that developers should replace object creation using
the constructor or using the new operator. This sounds strange but an object will be created using only the constructor that is called inside a factory method.

This may look complex at first glance but believe me, it promotes loose coupling and code reuse.

Let's understand with an Example

Problem Statement

Imagine you want to add different logging behavior for different environments of applications i.e Production, Development, Test, and Debug.

In Production: Only loglevel=error|warn is displayed.
In Development: All loglevel=info|error|warn|debug is displayed.
In Debug: Only loglevel=debug must be displayed.

For simplicity let's only work with two environments i.e Production and Development.

Implementation without using a pattern

// Concrete implementation

class Logger is
    env: string

    public method LogError(message: string): void is
        print message

    public method LogInfo(message: string): void is
        if env = ("Development" or "Test" or "Debug") then
            print message

    public method LogWarning(message: string): void is
        print message

    public method LogDebug(message: string): void is
        if env = ("Development" or "Test" or "Debug") then
            print message

// Implementation of Logger
function DoSomeWork(): void is
    ...
    logger = new Logger()
    ...
    var condition = isValid();

    if condition is true then
        logger.LogInfo("Some work is completed");
        return
    ...
    logger.LogError("Unable to complete work")

Implementation of Logger involves so much of if-else or 'if (the same thing can be performed using the switch).

Imagine in the future

Some new environment is added let's say Cloud. So it brings new problems and conditions with it.
- Making developer change implementation of class Logger.
- Updating condition according to it
Business rules changed for logger
- So again developer has to change the internal of Logger

Thus, this implementation is not maintainable and prone to unwanted behavior to occur.

Implementing Factory Method

The developer creates an abstract or interface called Logger and provides the concrete implementation for various subclasses of the common superclass Logger for various environments i.e ProductionLogger, DevelopmentLogger, TestingLogger and DebugLogger.

So each method of the subclass of Logger must contain its implementation and business rules.

I know it's hard to grasp to understand because adds up complexity.

For those who don't understand the UML diagram, it shows the IS-A relationship between the abstract Logger class and subclasses (DevelopmentLogger, TestingLogger etc) such that DevelopmentLogger is a Logger.

The developer creates an interface named ILoggerBuilder. That is responsible to provide an object of type Logger according to the requirement or some logic. the UML diagram shows the IS-A relationship between the abstract Logger class and subclasses (DevelopmentLogger, TestingLogger etc) such that DevelopmentLogger is a Logger.

The developer creates an interface named ILoggerFactory. That is responsible to provide an object of type Logger according to the requirement or some logic.

EnvironmentLoggerFactory implements ILoggerFactory that is responsible for creating an appropriate object of Subclass of Logger according to the environment on which the application is executing or say there is complex logic for building some object;

Let's write some pseudo-code

abstract class Logger is
    public abstract method LogInfo(message: string): void

    public abstract method LogError(message: string): void

    public abstract method LogDebug(message: string): void

    public abstract method LogWarn(message: string): void

class ProductionLogger inherits Logger is
    public method LogInfo(message: string): void is
      // Does Nothing
      return

    public method LogError(message: string): void is
        print message

    public method LogWarn(message: string): void is
        print message

    public method LogDebug(message: string): void is
        // Does Nothing
        return

class DevelopmentLogger inherits Logger is
    public method LogInfo(message: string): void is
      print message

    public method LogError(message: string): void is
        print message

    public method LogWarn(message: string): void is
        print message

    public method LogDebug(message: string): void is
        return

class TestingLogger inherits Logger is
    public method LogInfo(message: string): void is
      // Does Nothing
      return

    public method LogError(message: string): void is
        print message

    public method LogWarn(message: string): void is
        print message

    public method LogDebug(message: string): void is
        // Does Nothing
        return

class DebugLogger inherits Logger is
public method LogInfo(message: string): void is
// Does Nothing
return

    public method LogError(message: string): void is
        // Does Nothing
        return

    public method LogWarn(message: string): void is
        // Does Nothing
        return

    public method LogDebug(message: string): void is
        print message

Now developer adds EnvironmentLoggerFactory that implements ILoggerFactory

interface ILoggerFactory is
  CreateLogger(): Logger

class EnvironmentLoggerFactory implements ILoggerFactory
  public CreateLogger(): Logger is
    env = getCurrentEnv()

    if env
      is "Production" then return new ProductionLogger()
      is "Development" then return new DevelopmentLogger()
      is "Testing" then return new TestingLogger()
      is "Debug" then return new DebugLogger()

    throw new Exception("No logger attached to current environment")

Implementation of Logger

function DoSomeWork(): void is
    ...
    logger = new EnvironmentLoggerFactory().CreateLogger()
    ...
    var condition = isValid();

    if condition is true then
        logger.LogInfo("Some work is completed");
        return
    ...
    logger.LogError("Unable to complete work")

Again imagine the future

Some new environment is added let's say Cloud.
- SOLUTION: Now the developer has to develop a new subclass CloudLogger that inherits Logger.
- Rules can be implemented without thinking that they will break in the development or production environment.
Business rules changed for the logger, for example, all the logs in the cloud must be stored in a database
- SOLUTION: Just implement a concrete class CloudDatabaseLogger that inherits Logger.

Applicability

When developers do not know the exact type of objects that code should work with
- Factory method separates object creation from the code that uses it
- It provides an ease to extending the construction of an object
When the developer wants to save resources by reusing existing objects rather than by rebuilding them
- This can be achieved using caching or memoization

Generic Implementation of Pattern

All the products must be must inherit or implementProduct
Add a factory method inside CreatorFactory that always returns an object of base type Product
Replace all constructor calls in the code with the factory method.

Developer can pass argument inside this factory method to control object creation behavior

Advantages

Avoid tight coupling
Single Responsibility Principal, thus all object creation code is separated, allowing code management easy.
Open/Close Principal, the developer can introduce a new product according to changes without breaking client code.

Conclusion

The factory method is a powerful way to create complex objects it promotes loose coupling, the single responsibility principle, and the open/close principle.

Follow me on GitHub

To know more about this pattern, check this video by Christopher Okhravi

References

Design Patterns: Elements of Reusable Object-Oriented Software

Why I Switched To PNPM?

Harsh Rastogi — Mon, 01 Nov 2021 07:40:00 +0000

Package Manager For Node JS

It is system for that automate the process of adding/upgrading/removing and managing dependencies for a Node JS project

There are many package managers for Node JS

NPM (Node Package Manager)

Most popular package manager for Javascript and also default package manager for Node JS.

Yarn

It was released by Facebook Inc. in 2016. It was create to overcome problems and performance that were in NPM at that time.

PNPM

It is alternative package manager for Node Js for replacement of NPM, but faster and efficient.

Why is better than Yarn and NPM?

Imagine you install a package, Let call it Package_X. Imagine Lodash is one of dependency of Package_X. Now you install diffrent package call it Package_Y which also has Lodash as it dependency. Thus in a single project there two copies of Lodash.

If there are 100 packages using Lodash, you are going to have 100 copies Lodash

PNPM allows yoo to save tons of space

It is faster than both npm and yarn. Because Yarn copies files from cache wheareas pnpm links files into global score.

How PNPM works?

Note that PNPM doesn't flatten the dependency tree

Look how earlier node_modules tree looked like

node_modules/
|  Package_X/
|  | > node_modules/
|  |   | > Package_Z/
|  |       | index.js
|  |       | package.json
|  |   index.js
|  |   package.json
|
|  Package_Y/
|  | > node_modules/
|  |   | > Package_Z/
|  |       | index.js
|  |       | package.json
|  |   index.js
|  |   package.json

This way to managing has some issuse

Deeply nested dependency tree, causing long directory names in system.
Packages are copied and pasted several times when they are required in different dependencies.

But now after update in NPM @version 3, they added flattening so structure look like

node_modules/
|  Package_X/
|  |   index.js
|  |   package.json
|
|  Package_Y/
|  |   index.js
|  |   package.json
|
|  Package_Z/
|  |   index.js
|  |   package.json

But pnpm follow diffrent apporch rather than flattening tree it keeps it same

In /node_modules folder created by pnpm, each package has it's own dependency but dependency tree is never deep as in earlier version of npm. It keeps all dependencies flat with use of Symbolic Links or Junction (in windows)

node_modules/
|  Package_X/
|  | > node_modules/
|  |   | > Package_Z/ -> ../../../Package_Z/1.0.0
|  |   index.js
|  |   package.json
|
|  Package_Y/
|  | > node_modules/
|  |   | > Package_Z/ -> ../../../Package_Z/1.0.0
|  |       | index.js
|  |       | package.json
|  |   index.js
|  |   package.json
|
|  Package_Z/
|  |   index.js
|  |   package.json

Installation

Open terminal
Execute following command

  npm install -g pnpm

  npx pnpm add -g pnpm

Small Project Using pnpm

We are going to build Restfull API that get name of two person and calculate the love percentage between them

Exexute below commands

Create a directory

  mkdir love-api

Initialise it as pnpm project

  pnpm init -y

We are going to use Express for it.
Note pnpm commands is quite similiar to both npm and yarn. We are going to replace npm install [PACKAGE_NAME] with pnpm add [PACKAGE_NAME]

So adding following packages to your projects

Execute below commands

  pnpm add express cors

  pnpm add -D @types/express @types/cors nodemon typescript concurrently

Add these below script to package.json

{
  "build": "tsc",
  "start": "node dist/index.js",
  "dev": "concurrently \"tsc -w\" \"nodemon dist/index.js\""
}

We are going to discuss only about the PNPM side of things only
have look of source code here.

Dont Forget To Follow Me -> Harsh Rastogi

Now to build convert typescript code into javascript

In npm we do npm run build but in pnpm we have to execute

  pnpm build

and to start dev server

  pnpm dev

and to start server in production mode

  pnpm start

Benchmarks

Conclusion

If you are searching that gives you better speed and performance then pnpm is better, I personally suggest you to use pnpm instead of npm and Yarn. If you are not using it then you a chance to try it.

Yarn sends date to Facebook, which don't make yarn suitable in some scenarios. NPM has also security issue that's why there is Yarn now.

In above benchmarks we can see PNPM is better in all aspects.

Happy Coding :)

You Don't Know About Populate

Harsh Rastogi — Sun, 06 Jun 2021 09:23:41 +0000

To Understand populate, you have to understand the relation between collections.

Consider a library where we have

A Collection Of Books which is consist of id, name, author and another informational fields.
A Collection Of Users which is consist of id, name and other stuff
A Collection Of Issue which is consist of user and books, just for now ignore other stuff

Lets Begin

Think of how we can store Issue Collection record

By saving user data and book data

  [
    {
      "user": {
        "name": "John",
        "_id": "65230asa434r345d34kd3wbb",
        "address": "Noida",
        "email": "john@example.com"
      },
      "book": {
        "name": "Harry Potter",
        "_id": "6b6s6a9d6fj87s8978s86s7s",
        "author": "J.K. Rowling",
        "publication": "XYZ"
      }
    }
  ]

the problem with this approach is you end up with collecting duplicate data(User is also present in User collection and same with Books). This makes your database containing duplicate fields and hard to maintain.

But what makes it hard? I will access record fields easily!

My friend, this is hard because imagine if user has updated this email field or, the books field have been edited then we have to update records two times in Issues Collection and Books or User Collection.

To make database redundant, we should move to second approach

By Saving User _id and Book _id in Issues Record

  [
    {
      "user": ObjectId("65230asa434r345d34kd3wbb"),
      "book": ObjectId("6b6s6a9d6fj87s8978s86s7s"),
    }
  ]

with this approach we are storing a reference of user and book in their respective collections.

So How I Get Records? This Looks To Complex!!

My friend, here the populate comes to aid(_Why They called it Populate because finds data with their unique id and replace the ObjectId).

Advantages

Database is not redundant.
Updating records in easy.

Let's Implement This

Create Book and User models

  const { Schema, model } = require('mongoose');

  const userSchema = new Schema({
    name: String,
    address: String,
    email: String,
  });

  const User = model('User', userSchema);

  const { Schema, model } = require('mongoose');

  const bookSchema = new Schema({
    name: String,
    author: String,
    publication: String,
  });

  const Book = model('Book', bookSchema);

Lets add some Documents('same as Records') To Collection

  const john = await User.create({ // User.create() is equivalent to new User().save()
    name: "John",
    address: "Noida",
    email: "john@example.com"
  })

  const harryPotter = await Book.create({
    name: "Harry Potter",
    author: "J.K. Rollings",
    publication: "XYZ"
  })

Now User Issue a book from library

So how we do it?
Here comes the populate to aid

  const { Schema, model, Types } = require('mongoose');

  const issuesSchema = new Schema({
    user: { type: Types.ObjectId, ref: "User" },
    book: { type: Types.ObjectId, ref: "Book" },
  });

  const Issue = model('Issue', issuesSchema);

What the is `type` and `ref`

type: it is property tells to store the ObjectId of that particular document(document is here User or book)
ref: It is a name of collection to find that ObjectId. Here "User" and "Book" are name of collections we created.

Let's Issue A Book

Think John Comes To Library To Issue A Book Harry Potter
To issue a book we have to create a new Issue

const issuedBook = await Issue.create({ user: john, book: harryPotter });

What's going here

Actually, we are saving john._id and harryPotter._id value to issue, in database it's look like

  { // issuedBook 1
     user: "65230asa434r345d34kd3wbb",
     book: "6b6s6a9d6fj87s8978s86s7s",
  }
  { // issuedBook 2
     user: "65230asa45645r4jjjl3434h",
     book: "6b6s6a9h5j3kh7j38fw4j3k2",
  }

This is how we save to refrences to user and books field
There are various ways to save refrences. Check out documentation here

How To Populate Records ?

Now, imagine libarian wants to check all issued book records.
Well this is very simple to implement

  const Issue = require('./models/issue');
  // Import Issue model

  const issuedBooks = await Issue.find({}).populate('user').populate('book').exec()

Let's understand this what does that chain of calls doing

Issue.find({}): This will find all records in Issue Collection. You can set conditions in find
populate('user): parameter 'user' is same of field which we want to populate. populate('user') will find user by thier perspecitve id and replaces user field with actual user data.
populate('book): same as above, replace book id with actual record
exec(): This is very important function call. This will execute above all populate operation. If you forgot to call this. Your field will not be populated.

Note: If During Populate Some Records Are Not Found Then These Records Are Replaced By null

Now issuedBooks value be like

  { // issuedBook 1
     user: {
        name: "John",
        address: "Noida",
        email: "john@example.com",
        _id: "65230asa434r345d34kd3wbb"
     },
     book: {
       name: "Harry Potter",
       author: "J.K. Rollings",
       publication: "XYZ",
       _id: "6b6s6a9d6fj87s8978s86s7s"
     }
  }
  { // issuedBook 2
     user: {
        name: "Peter",
        address: "Delta",
        email: "peter@example.com",
        _id: "65230asa45645r4jjjl3434h"
     },
     book: {
       name: "Invisible Man",
       author: "Ralph Elipson",
       publication: "ABC",
       _id: "6b6s6a9h5j3kh7j38fw4j3k2"
     }
  }

Conclusion

This seems like a useful tool in being able to define a declarative model for what your data should look like as a result of any query. There are some inherent weaknesses to a lack of true “joins”, but the Mongoose API does an elegant job of optimizing these types of queries under the hood by using poplulate.

I’ve only recently begun using this, so if you know something that I don’t and would like to contribute to the discussion for anyone reading this article, feel free to comment below with any critiques, suggestions, random quotes, or song lyrics. Thanks

DEV Community: Harsh Rastogi

Factory Method In Brief: Design Pattern

Problem Statement

Implementation without using a pattern

Implementing Factory Method

Applicability

Generic Implementation of Pattern

Advantages

Conclusion

References

Why I Switched To PNPM?

Why is better than Yarn and NPM?

How PNPM works?

This way to managing has some issuse

Installation

Small Project Using pnpm

Benchmarks

Conclusion

You Don't Know About Populate

Lets Begin

But what makes it hard? I will access record fields easily!

So How I Get Records? This Looks To Complex!!

Advantages

Let's Implement This

Now User Issue a book from library

What the is type and ref

Let's Issue A Book

What's going here

How To Populate Records ?

Conclusion

What the is `type` and `ref`