DEV Community: Matthieu Blandineau

MongoDB Cheat Sheet

Matthieu Blandineau — Mon, 23 May 2022 11:35:05 +0000

We gathered a list of handy MongoDB and mongosh commands and queries when working with MongoDB databases. Please ping us @ForestAdmin if you’d like to add something to the cheat sheet!

This is the second post from our Cheat Sheets series following the PostgreSQL one.

Getting started with MongoDB

Install MongoDB Shell mongosh

$ mongosh
//OR
$ mongosh "mongodb://localhost:27017"

List MongoDB databases

show dbs

Connect to MongoDB database

use databaseName

Exit MongoDB Shell mongosh

quit()

Managing MongoDB

Check MongoDB version

db.version()

Check if MongoDB is running

$ pgrep -fa -- -D | grep mongo

Restart MongoDB on Linux

db.shutdownServer()
$ sudo systemctl start mongodb

Restart MongoDB on Mac OSX

$ brew services stop mongodb-community@yourMongodbVersionNumber

Restart MongoDB on Windows

Winkey + R
Type "services.msc"
Search "MondoDb"
Click "restart"

Change MongoDB user password

db.changeUserPassword(username, NewPassword)

Exit from mongosh

quit()

Interacting with MongoDB databases

List MongoDB databases

show dbs

Connect or switch to MongoDB database

use databaseName

Create new MongoDB database

use newDatabaseName

Show name of the current database

db.getName()

Delete MongoDB database

db.dropDatabase()

Rename MongoDB database

$ mongodump -d oldDatabaseName path
$ mongorestore -d newDatabaseName path/oldDatabaseName.bson
$ mongosh
use oldDatabaseName
db.dropDatabase()

Interacting with MongoDB collections

List MongoDB collections

show collections

Describe MongoDB collection

db.getCollectionInfos( { name: "collectionName" } )

Describe all collections in MongoDB database

db.getCollectionInfos()

Create MongoDB collection

db.createCollection("collectionName", options)

Delete MongoDB collection

db.collectionName.drop()

Rename MongoDB collection

db.oldCollectionName.renameCollection("newCollectionName")

Interacting with MongoDB indexes

List MongoDB indexes in a collection

db.collectionName.getIndexes()

Create a MongoDB index in a collection

db.collectionName.createIndex(keys, options, commitQuorum)

Create multiple MongoDB indexes in a collection

db.collectionName.createIndexes( [ keyPatterns ], options, commitQuorum )

Delete MongoDB index

db.collectionName.dropIndex("indexName")

Delete all indexes in MongoDB collection

db.collection.dropIndexes()

Rebuild MongoDB indexes

db.collection.reIndex()

Interacting with MongoDB documents

Count documents in a MongoDB collection

db.collectionName.countDocuments()

List all documents in a MongoDB collection

db.collectionName.find().toArray()

Create document in MongoDB

db.collectionName.insertOne(
   <document>
)

Display a document in MongoDB

db.collectionName.find({ "_id": documentID })

Update a document in MongoDB

db.collectionName.updateOne(
    { "_id": documentID },
    <update>
)

Delete a document in MongoDB

db.collectionName.deleteOne({ "_id": documentID })

Replace a document in MongoDB

db.collectionName.replaceOne(
    { "_id": documentID },
    <replacement>
)

Backup and restore MongoDB database

Backup MongoDB database

$ mongodump -d oldDatabaseName path

Restore MongoDB database

$ mongorestore -d newDatabaseName path/oldDatabaseName.bson

Managing roles, users and permissions in MongoDB

List MongoDB roles

db.getRoles(
    {
      rolesInfo: 1
    }
)

Create MongoDB user

db.createUser(
    {
        user: "userName",

        pwd: "userPassword",

        roles:[{role: "roleName" , db:"databaseName"}]
    }
)

Delete MongoDB user

db.dropUser(userName)

Change MongoDB user password

db.changeUserPassword(userName, newPassword)

Need to build admin panels or a GUI tool for MongoDB? Check out Forest Admin for MongoDB

Most popular PostgreSQL GUIs in 2022: the (almost) scientific list

Matthieu Blandineau — Tue, 17 May 2022 12:12:03 +0000

Wjether you're starting with PostgreSQL (in which case you might fancy a cheat sheet) and looking for the best postgres GUI or postgres client to get started, or you're a veteran (in which case ... you might also fancy a cheat sheet!) and you've hit the limit of your current tool — or you just can't stand it anymore, this list is for you. We've compiled the most popular postgreSQL GUIs and clients among your postgres developers peers.

Before we jump in, a few words about the methodology: we started from the list of PostgreSQL clients referenced on the PostgreSQL official wiki. For each client, we looked at the number of occurrences of their name in r/PostgreSQL discussions and comments. Of course, this methodology has some limitations, including: r/PostgreSQL developers are not all the PostgreSQL developers in the world and we only count the postgres clients mentions, not whether a mention is positive or negative. So it's not a list of "best postgres GUIs". But what's a best postgres GUI anyway, as its value will most likely depend on your needs? Let's start

1. pgAdmin

pgAdmin is the most popular PostgreSQL GUI. It is purpose built for Postgres and supports all its features and operations. pgAdmin is open source and also supports Postgres derivative databases such as EDB Postgres Advanced Server. You can test it live here.

pgAdmin supported platforms

You can install pgAdmin on

Linux
macOS
Windows

And then access it locally or over internet via your navigator.

Pros

You can run pgAdmin as a web application, on your computer or on any server, meaning you can use pgAdmin to access and manage distributed Postgres databases, from anywhere.
pgAdmin allows you to create, read and edit all PostgreSQL objects
You can easily rearrange its UI
pgAdmin offers advanced server monitoring capabilities

Cons

pgAdmin isn't as straight forward to install on your desktop as other postgres clients
pgAdmin is more suited for administrating your PostgreSQL than developing on it

pgAdmin pricing: pgAdmin is free and open source

2. DBeaver

DBeaver is a widely used multi database GUI tool, particularly popular among postgreSQL developers. Just like pgAdmin, it's open source. In addition to postgreSQL, it supports MySQL, PostgreSQL, SQLite, Oracle, DB2, SQL Server, Sybase, MS Access, Teradata, Firebird, Apache Hive, Phoenix, Presto, and more.

DBeaver supported platforms

Linux
macOS
Windows

Pros

DBeaver is super easy to install as a desktop application, and to connect to your PostgreSQL database
DBeaver offers a visual query builder to create advanced SQL queries without advanced (or any) knowledge of SQL
It comes with strong data access, search, visualization and edition capabilities
DBeaver also offers a fake data generator to populate your database and test it and the applications built on it

Cons

DBeaver runs locally and is sometimes resource intensive, which can lead to performance issues
And that's pretty much it! Other than that, PostgreSQL DBeaver users haven't expressed strong concerns.

DBeaver pricing: DBeaver is free and open source

3. Postico

Postico is macOS PostgreSQL client for reading data, doing basic manual data entry and editing your database structure.

Postico supported platforms

macOS

Pros

Postico is extremely straight forward to execute basic tasks over your PostgreSQL database
Postico easy to install and to securely connect to your Postgres database

Cons

Postico's strenghts are also its weaknesses: it doesn't offer advanced administration, monitoring or querying capabilities
Postico is only available on macOS

Postico pricing: $39.99 for 1 user, $319.99 for 10 users, free trial with feature limitations but no time limit.

4. DataGrip

DataGrip is a multi database IDE to install locally, that can act as your Postgres GUI and much more. It is developed by JetBrains who are known for their numerous dev tools. On top of Postgres, it supports MySQL, Oracle Database, Redshift, MariaDB, Cassandra, MongoDB and more.

DataGrip supported platforms

Linux
macOS
Windows

Pros

Powerful data viewer and editor
Great and customisable UI
A lot of powerful features to develop on your PostgreSQL database, such as context and schema based code completion, and real-time bug detection in your code (and fix suggestions!).

Cons

DataGrip can be resource intensive
Because it's much more than a Postgres client, DataGrip can be a bit overwhelming for beginners

DataGrip pricing: $89 per year for individual users, $199 per user per year for organisations, with commitment and product packs options.

5. Navicat

Navicat is a GUI focused on database development. As it is multi database, on top of acting as your PostgreSQL GUI, it can connect MySQL, MariaDB, MongoDB, SQL Server, Oracle, PostgreSQL, and SQLite.

Navicat supported platforms

Linux
macOS
iOS
Windows

Pros

Easy and powerful SQL development tools, such as a visual SQL builder, code completion and customisable Code Snippets.
Good database structure visualisation and edition capabilities.
Collaboration feature

Cons

Limited PostgreSQL database administration capabilities

Navicat pricing: $349.99 per year for non commercial usage, $699.99 per year for commercial usage, with different commitment options

6. TablePlus

TablePlus is a database management GUI supporting various databases including MySQL, Redshift, Redis, MongoDB and of course PostgreSQL.

TablePlus supported platforms

Linux
macOS
iOS
iPadOS
Windows

Pros

Clean and intuitive data browsing, querying and editing UI
Various and easy to use security features
Good query editor including autocomplete, highlight syntax, query reformatter and history.

Cons

TablePlus doesn't go deep in any specific area (for instance PostgreSQL development or monitoring). But is it really a con?

TablePlus pricing: from $49 to $99

7. OmniDB

OmniDB is a browser-based app to access and manage various databases such as Oracle and MySQL. And of course, it can act as your PostgreSQL client.

OmniDB supported platforms

Linux
macOS
Windows

Pros

OmniDB supports plugins, so developers can add functionalities to their PostgreSQL GUI
It can be accessed by multiple users from several computers, making it a good option to collaborate on your PostgreSQL databases
OmniDB offers intuitive data editing features such as ability to copy and paste blocks
Good SQL editing with a customisable SQL editor featuring syntax highlight and code completion

Cons

Light documentation especially on the usage of the tool
OmniDB is more complex than a Postico or TablePlus but less advanced than a DataGrip or Navicat. It's a good free option but maybe less complete than DBeaver, which has a better documentation and a seemingly larger community.

OmniDB pricing: free and open source

8. SQuirreL SQL

SquirreL SQL is a Java tool to view the structure of databases, browse their data, issue SQL commands and more. It supports many databases including SQL Server, MySQL, Oracle Database and of course PostgreSQL.

Squirrel SQL Supported platforms

Linux
Mac OS
Windows

Pros

SquirreL SQL supports Java plugins to extend its capabilities

Cons

Configuration is hard for first time users
The interface isn't the most intuitive

SquirreL SQL pricing: free and open source

9. HeidiSQL

HeidiSQL is a client supporting various databases including MariaDB, MySQL and PostgreSQL. It's been built with the goal of being easy to learn.

HeidiSQL supported platforms

Windows

Pros

HeidiSQL is particularly good at managing several databases/servers simultaneously. Not only it can connect to multiple servers, but allows direct exports from one server or database to another and search across all the connected databases from the same server.
HeidiSQL is easy to install as a Windows app.

Cons

Limited to Windows
Users have reported that the tool can be quite buggy
HeidiSQL doesn't provide advanced code debugging features

HeidiSQL pricing: free and open source

10. Shameless plug: Forest Admin

Forest Admin is an admin panel builder that can easily act as your Postgres GUI. It's packaged as a web application, with backend component to install on your servers. Upon installation, Forest Admin introspects your database and automatically creates a GUI including CRUD operations and tables visualisation, as well as functionalities like search, filters, pagination, exports and more. You can then customise it, add your custom actions or data visualisations.

Forest Admin is focused on easing the visualisation and manipulation of your PostgreSQL database data, even by non technical users, from anywhere with an internet connection.

Forest Admin pricing: free for 1 user, then $24 to $48 per user per month, commitment options.

Need to build admin panels or a GUI tool for PostgreSQL? Check out Forest Admin for PostgreSQL

What is a CRUD app and how to build one?

Matthieu Blandineau — Thu, 12 May 2022 12:11:04 +0000

Virtually any application involves users – or other applications it connects with – interacting with data stored in a database. Those interactions can be summarised in four operations: create, read (or view), update and delete. Those are the CRUD operations.

CRUD operations explained

More concretely, what are CRUD operations? Let’s use our community forum as an example.

CRUD operations descriptions and examples

CREATE – Being a forum, it needs to let our users create new topics. When a user opens the topic creation form, fills it and clicks on the "Create topic" button, it will trigger the forum's CREATE function that will create a new "Topic" record with the "title", "content", "tags", etc values in the forum's database

READ – Once the post is created, anyone will be able to read it when browsing on the forum and clicking on it, or directly accessing its URL. Doing so will call the forum's READ function, that will retrieve the topic including its attributes (title, content, tags, etc) from the database. The READ function doesn't modify any information from this topic.

UPDATE – After a user has created a topic, our forum allows them to edit it. Useful if they made a mistake or forgot something. To do so, users can simply click the edit button and modify the values of the different attributes. After they click "Save Edit", the forum's UPDATE function will be called, and change those values accordingly in the database.

DELETE – If for any reason, the user wants to delete their topic, they can click the "delete topic" button,. The forum's DELETE function will be called, and will delete the topic record and its attributes from the database.

This is a simple explanation of CRUD operations on a single type of records. Even basic applications will involve CRUD operations on various types of records, with different users being authorised to perform different operations on different types of records. In our forums examples, a user can CREATE a topic, UPDATE their account, READ comments in a topic, and DELETE a bookmark, while admins can UPDATE users rights or CREATE new forum sections.

CRUD operations, REST and SQL

Now we know what are CRUD operations at a high level. We saw that essentially, CRUD operations are triggered by users' (or automated) actions, and alter or read the database. Usually, in web applications, those CRUD operations will be triggered by users' actions generating calls to a REST API, and will alter or read the database via SQL queries.

The table below describes how CRUD operations map to HTTP methods from REST APIs called to trigger the operations, and to SQL queries performed to alter or read the database:

What is a CRUD app?

A you might have noticed, even for the most basic use case, those CRUD operations aren't enough to achieve any meaningful results by themselves, they interact with other elements. All together, those elements make a CRUD app.

Front-end

The front-end, or User Interface, is what enable users to interact with the application, call the REST API to trigger the CRUD operations and ultimately interact with the database.

Back-end

The back-end is what will translate the REST API calls into SQL queries to perform CRUD operations on your database.

Database

The database is where your data, and where the CRUD operations are ultimately performed via SQL queries.

Role-Based Access Control Activity logs, ...

In addition to the components listed above, that are the essential components of a CRUD app, additional capabilities are required to build a robust app. Indeed, you might want to restrict which users can perform which operations (for instance deleting the entire database), and log every operations performed for debugging or compliance purposes.

Hosting

All the components above have to be hosted somewhere to always be accessible for your and your users.

Now, let's see different options to build a CRUD app.

Building a CRUD app from scratch

An obvious option to build a CRUD app is to build it from scratch. Most likely, if you're thinking about building such an app, it's because you already have a database storing data you want to enable your users to easily visualise or manipulate. So we will assume you already have an up and running database.

While CRUD apps seem fairly basic, developing one requires solid front-end, back-end and database knowledge. In this blog, we won't cover everything in detail but list the main steps to build a CRUD app on top of your database, from scratch, and link to useful resources.

For the sake of the exercise, we'll assume you're using the following popular technologies: React for the front-end, Node.js for the back-end and PostreSQL for your database.

Build your CRUD app front-end

We used this great tutorial "How to Perform CRUD Operations using React, React Hooks, and Axios" as a reference.

Architecture & design: Let's go. As we're starting from an existing database, you already know what data is stored in this database, and how it is structured. So the first you might do is to think about how you want your users to interact with this data, how you want to represent it, and what will the experience look like.
Create your React application
Install the Semantic UI Package for React This package is an UI library providing pre-built components such as buttons, tables and much more.
Create your app first screen
Create your CREATE, READ and UPDATE files for your CREATE, READ and UPDATE component, no need for a new component for DELETE
Build the CREATE, READ, UPDATE and DELETE elements, buttons and logic
Build the CRUD requests to the API (once you've built the API)
Implement forms validation

Build your CRUD app back-end

Once you're done with the front-end, it's time to build what will be the link between the front-end and the database. We used this "Developing a CRUD Node.js Application with PostgreSQL" guide as a reference.

Create your app architecture in Node.js
Configure your app and its connection to your PostgreSQL database
Create the routes for your CRUD operations, including writing the API endpoints for their respective methods, and their respective logic to query the database

Deploy your CRUD app

As we mentioned previously, you need to host your database, back-end and front-end online if you want you and your users to be able to access it anytime from anywhere.

Bonus points: add Role-Based Access Control

From installing the necessary packages to setting up user authentification (both signup and login) and their front-end manifestations to configuring the rights on the routes, implementing RBAC on your CRUD app adds significant amount of development time.

Useful tools to reduce CRUD app development time

As we've seen, developing a basic CRUD app from scratch can take significant time. Fortunately, there are tools to accelerate this process, especially on the backend part. Tools like Hasura or PostgreSQL, depending on your stack, will automatically create APIs based on your database.

Building a CRUD app with a CRUD app builder

Even with tools like Hasura or PostgreSQL, building a CRUD still takes time. Even more so if you need specific capabilities in addition to CRUD operations. To prevent you from reinventing the wheel every-time you need to enable your users to manipulate and visualise the data stored in your database, tools exist to build CRUD apps in minute and allow you to focus on adding advanced logic and functionalities to your applications. Examples include Django Admin or Laravel Nova depending on your stack.

In this blog, we'll see how to build a CRUD app with Forest Admin. We'll assume you're building a CRUD app for a PostgreSQL database.

Install your CRUD app builder

The first step is to install the tool that will help your generate your CRUD app. Using our example Forest Admin with a PostgreSQL database, it only takes a few steps:

Install Forest Admin CLI

$ npm install -g lumber-cli@latest -s

$ forest login

Generate the backend application

$ forest projects:create "CRUDapp" --databaseConnectionURL "postgres://root:password@localhost:5432/myDatabase" --databaseSchema "public" --applicationHost "localhost" --applicationPort "3310"  
$ cd "CRUDapp" 
$ npm install -s

Run your backend application

$ npm start

Build your CRUD app

The catch is that with Forest Admin, you get an up and running CRUD app right after installing it on top of your database. It automatically generates visualisations of your tables, CRUD operations and more, as well as the associated front-end.

You also benefit from built-in Role-Based Access Control, Activity logs and more so you can focus on coding your own business logic, adding custom actions to your new app and customising it.

Click here to learn more about Forest Admin, read the doc or get started now.

PostgreSQL Cheat Sheet

Matthieu Blandineau — Wed, 11 May 2022 08:41:13 +0000

We gathered a list of handy PostgreSQL commands and queries when working with PostgreSQL databases. Please ping us @ForestAdmin if you’d like to add something to the cheat sheet!

Getting started with PostgreSQL

$ sudo su - postgres psql

List postgres databases

\l

Connect to postgres database

\c databaseName

Exit postgreSQL command line utility psql

\q

Managing PostgreSQL

Check PostgreSQL version

SELECT version();

Check if PostgreSQL is installed

$ which psql

Check if PostgreSQL is running

$ pgrep -fa -- -D | grep postgres

Restart PostgreSQL on Linux

# systemctl restart postgresql
// or
# service postgresql restart
// or
# /etc/init.d/postgresql restart
// or
# /sbin/service postgresql restart

Restart PostgreSQL on OSX

# brew services restart postgres
// or
# pg_ctl -D /usr/local/var/postgres -l /usr/local/var/postgres/server.log restart

Restart PostgreSQL on Windows

Winkey + R
Type "services.msc"
Click "restart"

Change PostgreSQL user password

$ sudo -u postgres psql
\password postgres

Exit from psql

\q

Interacting with databases in PostgreSQL

List postgres databases

\l

Connect or switch to postgres database

\c databaseName

Create new postgres database

CREATE DATABASE databaseName

Delete postgres database

DROP DATABASE databaseName

Rename postgres database

ALTER DATABASE old_databaseName TO new_databaseName

Query postgres JSON data

SELECT *
FROM mytable
WHERE myfield @> '{"key1":"valueA"}'

Interacting with tables in PostgreSQL

List postgres tables

\dt

Describe postgres table

\d tableName

Create postgres table

CREATE TABLE tableName( 
    columnName columnType,
    columnName columnType
);

Delete postgres table

DROP TABLE tableName CASCADE

Backup and restore PostgreSQL database

Backup postgres database

$ pg_dump -d databaseName -U userName > backupFile

Restore postgres database

psql databaseName < backupFile

Managing roles and permissions in PostgreSQL

List postgres roles

SELECT rolname FROM pg_roles;

Create postgres user

CREATE USER userName WITH PASSWORD 'userPassword';

Delete postgres user

DROP USER userName;

Change postgres user password

ALTER ROLE userName WITH PASSWORD 'userPassword';

List all assigned roles postgres

SELECT
    r.rolname,
    r.rolsuper,
    r.rolinherit,
    r.rolcreaterole,
    r.rolcreatedb,
    r.rolcanlogin,
    r.rolconnlimit,
    r.rolvaliduntil,
    ARRAY(SELECT b.rolname
        FROM pg_catalog.pg_auth_members m
        JOIN pg_catalog.pg_roles b ON (m.roleid = b.oid)
        WHERE m.member = r.oid) as memberof,
    r.rolreplication
FROM pg_catalog.pg_roles r
ORDER BY 1;

Grant all permissions on postgres database

GRANT ALL PRIVILEGES ON DATABASE databaseName TO userName;

Grant connection permissions on postgres database

GRANT CONNECT ON DATABASE databaseName TO userName;

List permissions for specific role postgres

SELECT table_catalog, table_schema, table_name, privilege_type
FROM   information_schema.table_privileges
WHERE  grantee = userName ORDER BY table_name;

ProstgreSQL psql commands recap

\? List all available psql commands

\h COMMAND Get help on specific command

\l List databases

\c databaseName Connect to database

\dt List tables

\d tableName Describe table

\d+ tableName Describe table with details

\dn List schemas

\df List functions

\dv List views

\du List users

\dy List events

\di List indexes

\q Exit

Need to build admin panels or a GUI tool for PostgreSQL? Check out Forest Admin for PostgreSQL

High-level architecture of a hybrid SaaS solution

Matthieu Blandineau — Tue, 10 May 2022 09:12:13 +0000

Introduction

Forest Admin is a tool that automatically generates admin panels on top of your database, that can then be customised. Because of the privacy and security requirements most developers and organisations rightfully have over their data, we had to build our solution in a way that ensured those requirements were respected in order to provide a viable offer. That's why we decided to go with a hybrid SaaS architecture.

We define a hybrid SaaS solution as a software relying simultaneously on a SaaS part and an on-premise part. The SaaS part is hosted and managed by the vendor, and includes the user interface the users will connect to and interact with via their browser. The on-premise (or self-hosted) part is managed and hosted by the user, and includes the users' data and the vendor provided elements to send and receive the relevant data to and from the user interface.

As discussed in the first paragraph, the main advantage of such an architecture is that the user's data will never be seen by the vendor, and stays within the user's controlled environment. In addition, the user will automatically benefits from updates introduced by the vendor just like with any SaaS solution.

Let's detail this hybrid SaaS architecture, using Forest Admin as an example.

High level hybrid SaaS architecture

In Forest Admin's case, the whole architecture consists of 4 different components as shown below. The user's database, the admin backend, the Forest Admin API server and the Forest Admin UI server.

1. The user's database

The user's database will be the main data source for Forest Admin to generate admin panels, and feed them.

2. Forest admin backend

When a user installs Forest Admin, they generate a node.js application on their local machine. It includes a RESTful API that connects to their database. We call this app the admin backend. It feeds all the data to your admin panel interface.

What it does:

it translates client requests (from the end user browser) into queries to the user's database.
it also provides the Forest Admin API Server with the information needed to build the User Interface. This information includes table names, column names and types, and relationships.

A JSON file called the forestadmin-schema.json carries this metadata within the admin backend.

3. Forest Admin API server

The Forest Admin API Server stores the information to build the user interface. This includes both the database structure (sent by the admin backend) and the UI customization made by the user.

To get more technical, the information stored includes:

Display & Order — Which tables and columns should be displayed or hidden? In what order should the columns appear in the ‘Table’ view?
Collection Settings (permissions) — Are the records in this table read-only? Can they be deleted? Can they be exported in a .csv file?
Widget preferences — Which UI component should be rendered for each column (e.g a file viewer for a column that contains images urls).
Chart configurations — How are the dashboard charts configured and in which position should they appear?

The Forest Admin API Server also manages the Forest Admin app’s logic like user authentication or billing.

4. Forest Admin UI server

The Forest Admin UI server stores static assets. These include HTML documents, CSS stylesheets and JS script files. It provides the UI components needed to build the interface that displays the data.

Now that you have a high level overview of the architecture, let's see how the different components interact together.

Interactions between the different components

Let's go through the http calls made between each of the above-mentioned elements when operating a Forest Admin project. Namely calls made:

between the end user’s browser and the Forest Admin servers (both UI and API servers),
between the end user’s browser and the admin backend,
between the admin backend and the Forest Admin API servers.

Calls made from the user’s browser

The following lists the calls made by the browser when an end user accesses the admin panel from their browser (at app.forestadmin.com).

To the Forest Admin UI servers

Calls need to go out to the Forest Admin UI server to fetch static assets including:

HTML documents
CSS stylesheets
JS scripts
A map of the assets

To the Forest Admin API servers

Calls need to go out to the Forest Admin API servers to retrieve information regarding:

the end user logged in,
the project they're logged into,
the environment they're logged into,
the configuration of the rendering to be displayed (i.e. the configuration of the UI),
the widgets configuration,
the billings info of the project,
any updates happening on the UI configuration. This is done through websockets.

To the admin backend

Calls need to go out to the admin backend to retrieve/ modify data from the database including:

GET calls to retrieve a list of records, the count of a list or the details of record,
PUT calls to modify a record,
POST calls to create a new record or trigger a custom action,
DELETE calls to delete records.

Calls made from the admin backend

To the database

When calls are made from the browser to the admin backend, the latter translates the call into a database query.

To the Forest Admin API servers

In order to ensure that the UI reflects the structure of the database, the admin backend needs to send calls containing the information from the forestadmin-schema.json to the Forest Admin API servers. This file is sent upon every restart of the admin backend server.

At the startup of the admin backend and periodically afterwards, calls are also made to the Forest Admin API servers to retrieve permissions. This protects the data from being accessed by unauthorized users through curl requests for example.

Additional considerations

Flexibility and extensibility

Because part of the solution's logic resides in the user's systems — the admin backend in Forest Admin's example, the vendor can allow users to customise and extend its solution like they would with any other app, by open sourcing and documenting its on-premise component.

Development workflow, CI/CD and hosting

If the vendor open sources its on-premise component, it also allows the user to manage the code of this component in Git, the containerize the back-end app using Docker or Kubernetes, and to deploy it wherever the user sees fit.

Updates

With this hybrid SaaS architecture, users will benefit from continuous updates to the SaaS part — in Forest Admin's case the UI — by simply refreshing they browser tab.

For the on-premise part, the downside is that updates do require the user to install updates on their side, and potentially setup tests to make sure updates do not introduce regressions on their specific configuration.

Conclusion

From introducing large updates to managing users' authentication to optimising for performance when you don't host part of your solution, building Forest Admin with this hybrid SaaS architecture introduced various technical challenges of their own, that we plan to cover in more detailed posts in the future. Ping us @ForestAdmin to let us know what you'd like us to cover first.

Interest in Forest Admin? Learn more on our website or our doc, or sign up here.