CODEWITHSUNDEEP
javascriptnode.jsoopdesign-patterns
Amanda Ferrari
Amanda Ferrari

Reputation: 946

Design pattern to choose different database

I have created a class to interact with my database:

class MyDatabase {
  connect() { /* ... */ }
}

And the database has two types of modes: admin and client. I would like to have different classes for each mode:

class MyDatabaseAdmin {}

class MyDatabaseClient {}

Both of them will implement the same interface, but with different underline implementations. I would like to know if there is a design pattern to instantiate the parent MyDatabase choosing one over the other. Something like:

const db = new MyDatabase({ mode: 'admin' })
db.connect() // parent calls MyDatabaseAdmin.connect

I don't need a perfect answer, just some direction to what I should search for.

Thanks.

Upvotes: 0

Views: 618

Answers (2)

jfriend00
jfriend00

Reputation: 707238

If they have no code in common, then they are really just two separate classes. You probably don't even want the admin code to be present in the browser since it can't be used there anyway.

You could have a single factory function that looks at an admin parameter and instantiates the appropriate database object and returns it, but I don't think I even see why you'd bother with that.

Just have each client instantiate the appropriate DB object. If there's any common code, you can have both implementations inherit from a common base and put the common code in the base class.

Right! I forgot to mention, but there are some common code... the connection and authentication is exactly the same, for example. Do you happen to know any design pattern that would perfect fit for this use case? Should I research about Factories?

I think a common base class with inheritance solves the problem here. It gives you a natural place to put the common code without having to include server-side code in the client implementation. The browser implementation and the server implementation would each be a subclass that are present only on their respective platforms. The common base class would be present and used in both places.

You just have the client instantiate the appropriate leaf class and the shared code lives in the base class. If you want to hide the actual class constructors, you can use a factory function (it's just a simple function that looks at conditions and makes an appropriate object for you and returns it), but I'm not sure there's any compelling reason to use a factory function here. You would only include the appropriate leaf class on the platform for which it is intended so there's no place where you might use one or the other in the same code.

Upvotes: 1

Helton Furau
Helton Furau

Reputation: 1

would you consider having only 'users'? then each user could have a 'role' that would be either 'user' or 'admin'. So based on that 'role' you will define the privileges for each user. I find this solution easier for this kind of stuff but let me know if it does not match your case.

Upvotes: 0

Related Questions