Forem: Sunil Kumar Samanta

Basics of Serving Static Sites from a Server

Sunil Kumar Samanta — Sun, 02 Apr 2023 17:50:57 +0000

As a frontend developer, you may be excited about deploying your projects through various static deployment services like Vercel, GitHub Pages, Netlify, and more. While these services are excellent options for getting your static site online quickly, it's important to understand the basics of serving static sites from a server.

In this article, we'll take a closer look at the basics of serving static sites from a server, including the role of HTTP, different types of servers, and the advantages of serving static sites.

What is a Server?
First things first, let's define what we mean by a server. In the context of web development, a server is a computer or software program that stores and delivers web content. When a user requests a webpage or other online resource, the server retrieves the content and sends it back to the user's browser.

How Static Sites are Served from a Server
When a user requests a static site, the server simply retrieves the site's HTML, CSS, and JavaScript files and sends them back to the user's browser. Since static sites don't require server-side processing, they can be served quickly and efficiently.

The Role of HTTP
HTTP (Hypertext Transfer Protocol) is the protocol used to transfer web content between a server and a user's browser. When a user requests a static site, their browser sends an HTTP request to the server, which responds with an HTTP response containing the site's files. The files are then rendered in the user's browser, creating the final webpage.

Types of Servers
There are many different types of servers that can be used to serve static sites. Web servers like Apache and Nginx are popular choices, as are cloud services like AWS and Google Cloud. In addition, many static site generators like Jekyll and Hugo include built-in servers that can be used for development and testing.

Advantages of Serving Static Sites
Serving static sites from a server offers several advantages for frontend developers. First and foremost, static sites can be served quickly and efficiently, resulting in faster page load times for users. In addition, since static sites don't require server-side processing, server costs are typically lower than with dynamic sites. Finally, serving static sites can also reduce security risks, since there is no server-side code that can be exploited by attackers.

Conclusion
In conclusion, while static deployment services are great for quickly getting your static site online, understanding how static sites are served from a server can help you optimize your site for speed, efficiency, and security. By choosing a server option that works best for your needs, you can provide the best possible experience for your users. So the next time you deploy a static site, remember to take a moment to appreciate the powerful yet simple process that allows your site to be served to users around the world.

CalmAPI - A Production ready REST API generator using NodeJS & MongoDB

Sunil Kumar Samanta — Sun, 09 May 2021 03:43:47 +0000

Based on my previous NodeJS MongoDB starter package, Here is a Production ready Modular REST API Generator using NodeJS & MongoDB.

INSTALLATION

Install by running

npm i -g calmapi

Then run inside your workspace directory

calmapi

And follow the easy steps.

FEATURES

Production ready - Controller, Model & Service oriented architecture
Modules with automated Routing (Nested Route support)
Built-in Authentication Module with JWT & DB Store authentication
Built-in User Module
Build-in CRUD operations for modules with pagination, filters, sorters
Sample Post Module (CRUD Operation Example)
CRUD Module generation command line support.[Alpha]
No Hidden sh*ts in your node_modules. Completely free to customize
Prebuilt CRUD operation classes for Controller & Service
DTO Support( Data transfer Object)
Eslint rules enabled
.env support
And many more

Here is the github repo

sunilksamanta / calmapi

Production ready Modular REST API Generator using NodeJS & MongoDB

Calm API

Production ready Modular REST API generator using NodeJS & MongoDB

INSTALLATION

Install by running

npm i -g calmapi

Then run inside your workspace directory

calmapi

And follow the easy steps.

MODULE GENERATION

Generate CalmAPI CRUD Module just by running the following inside project's root.

calmapi generate module product

Valid Module generation commands.

calmapi generate module product

calmapi generate module products

calmapi generate module productMeta

calmapi generate module ProductMeta

calmapi generate module product-meta

Generate Module name without pluralize

calmapi generate module test-series --force

FEATURES

Production ready - Controller, Model & Service oriented architecture
Modules with automated Routing (Nested Route support)
Built-in Authentication Module with JWT & DB Store authentication
Built-in User Module
Built-in Media Module for file upload [AWS S3 Support]
Build-in CRUD operations for modules with pagination, filters, sorters
Sample Post Module (CRUD Operation Example)
CRUD Module generation command line support.
No Hidden sh*ts in your node_modules. Completely…

View on GitHub

We love your input! We want to make contributing to this project as easy and transparent as possible, whether it's: Reporting a bug, Documentation, Discussing the current state of the code, Submitting a fix or Proposing new features.

Self Hosted Open Source Solutions List

Sunil Kumar Samanta — Fri, 09 Oct 2020 03:26:03 +0000

Here is the list for Self Hosted alternative of some SAAS.

Blogging / CMS:

Chat [With API]

Video Conference [With API]

Document Database

This list will update time to time. Please comment any new category or any self hostel tool. I'll update in this.

Hope this will help some people.

If you don't like Mondays, Its time to change!

Sunil Kumar Samanta — Fri, 09 Oct 2020 01:44:26 +0000

If you don't like the Mondays, then you should probably change your job. Because if Mondays are always been your headache, you won't be able to work longer where you're working currently. Not just that, you'll loose interest in everything. That'll impact your social life, family. So if possible go for a job where you can discover yourself. You can improve yourself.

Your thoughts?

REST API Structure using NodeJS MongoDB (Mongoose)

Sunil Kumar Samanta — Fri, 02 Oct 2020 15:31:38 +0000

[UPDATE 2] New modified more robust structure with Generation Tool. Check out here https://dev.to/sunilksamanta/calmapi-a-production-ready-rest-api-generator-using-nodejs-mongodb-pd9

[UPDATE] There are structure improvements and addon features. Please follow the git repo for updated structure.

For each and every project I usually prefer using different architectures. It not just helps me explore new techniques but helps me make the next project better than before by applying the best of them and leave the worst.

Few months ago I found this article interesting. With writing a very minimum line of code you’ll get an API ready. I followed this structure and created my own with some customization and added basic modules and made it REST ready out of the box. The project features —

Controller, Model & Service oriented architecture
Auth with JWT & Db Store
User Module
Post Module (Sample CRUD)
Media Upload
Centralized Http Response
Error Handler
.env support
Multi Environment config setup
Autobind Methods

If you’re too lazy to read further, here is the github repo for full project.

sunilksamanta / node-mongoose-setup

Nodejs MongoDB REST API Sarter

Installation

Setup is super easy. Clone the repository -

git clone https://github.com/sunilksamanta/node-mongoose-setup
cd node-mongoose-setup
npm install

Create an .env file at the root of your project with the following.

MONGO_URL=YOUR_MONGO_URL
PORT=5000[YOUR_DESIRED_PORT]
NODE_ENV=YOUR_APP_ENVIRONMENT[production/development]
JWT_SECRET=YOUR_JWT_SECRET_STRING

An example file .env.example is included.

Your project is ready. Now start the project.

npm start

Go to http://localhost:5000. You should see a default welcome page.

Your API base path is http://localhost:5000/api.

First create some accounts to get started with the authentication.

Authentication

JWT authentication is added in this project. User model is defined in models/User.js For Register, Login, Logout use these urls —

    [POST] api/auth/register
    [POST] api/auth/login
    [GET] api/auth/logout

Features

Controller, Model & Service oriented architecture
Auth with JWT & Db Store
Async/Await support
User Module
Post Module (Sample CRUD)
Media Upload
Centralized Http Response
Error Handler
.env support
Multi Environment config setup
Autobind Methods
Built…

View on GitHub

Lets dig into the Matrix..

What we’re using?

NodeJS
MongoDB (Mongoose ODM)

Directory Structure of the Project

       ├─ .env
       ├─ .gitignore
       ├─ config
       │  ├─ config.js
       │  ├─ database.js
       │  ├─ routes.js
       │  └─ server.js
       ├─ index.js
       ├─ package.json
       └─ src
          ├─ controllers
          │  ├─ AuthController.js
          │  ├─ Controller.js
          │  ├─ MediaController.js
          │  └─ PostController.js
          ├─ helpers
          │  ├─ HttpError.js
          │  ├─ HttpResponse.js
          │  └─ Utility.js
          ├─ models
          │  ├─ Auth.js
          │  ├─ Media.js
          │  ├─ Post.js
          │  └─ User.js
          ├─ routes
          │  ├─ auth.js
          │  ├─ index.js
          │  ├─ media.js
          │  └─ post.js
          └─ services
             ├─ AuthService.js
             ├─ MediaService.js
             ├─ PostService.js
             ├─ Service.js
             └─ UserService.js

Lets talk about the structure

If you’ve already read the article where I found the struture then you’ve already understood what the structure does. If not please follow this link for better understanding of the basics of this architecture.

We have 2 base classes — One for Controller and another for Service.

Controller.js

This base controller have the basic CRUD operations. To create a new controller just extend this base Controller class.

Service.js

This is the base Service class which includes the database operations. If you want to change the default behaviour of the services you can update this file.

How to Create new CRUD Module?

If you want to create a new Module say Post. Then you’ll have to create 4 basic files. One Controller, one Service, one Model and one route file. And add the new route in routes/index.js with desired url.
There is a “Post” CRUD module included in this project for example.

    controllers/PostController.js
    models/Post.js
    services/PostService.js
    routes/post.js

Overriding Base class method

As an example if you see in the media Controller — the default delete method is overriden by its own class method as we have to delete the file from the file system also. So the overriden method is like bellow —

async delete(req, res, next) {
  const { id } = req.params;
  try {
      const response = await this.service.delete(id);
      // File Unlinking..
      if (response.data.path) {
          console.log("unlink item", response.data.path);
          fs.unlink(response.data.path, function (err) {
              if (err) {
                  console.log("error deleting file");
                  throw err;
              }
              console.log("File deleted!");
          });
      }
      return res.status(response.statusCode).json(response);
  }
  catch (e) {
      next(e);
  }
}

Authentication

JWT authentication is added in this project. User model is defined in models/User.js.
For Register, Login, Logout use these urls —

    [POST] api/auth/register
    [POST] api/auth/login
    [GET] api/auth/logout

Thats all for now.. If you need any help, I’ll love to do so.
Here is once again the git repo..

sunilksamanta / node-mongoose-setup

Nodejs MongoDB REST API Sarter

Installation

Setup is super easy. Clone the repository -

git clone https://github.com/sunilksamanta/node-mongoose-setup
cd node-mongoose-setup
npm install

Create an .env file at the root of your project with the following.

MONGO_URL=YOUR_MONGO_URL
PORT=5000[YOUR_DESIRED_PORT]
NODE_ENV=YOUR_APP_ENVIRONMENT[production/development]
JWT_SECRET=YOUR_JWT_SECRET_STRING

An example file .env.example is included.

Your project is ready. Now start the project.

npm start

Go to http://localhost:5000. You should see a default welcome page.

Your API base path is http://localhost:5000/api.

First create some accounts to get started with the authentication.

Authentication

JWT authentication is added in this project. User model is defined in models/User.js For Register, Login, Logout use these urls —

    [POST] api/auth/register
    [POST] api/auth/login
    [GET] api/auth/logout

Features

Controller, Model & Service oriented architecture
Auth with JWT & Db Store
Async/Await support
User Module
Post Module (Sample CRUD)
Media Upload
Centralized Http Response
Error Handler
.env support
Multi Environment config setup
Autobind Methods
Built…

View on GitHub

Want to contribute?

If you have any suggestion, feedback or you want to make this project more powerful — feel free to report issues or request a feature or suggest some changes. Fork and PR.

Happy Coding!

Originally published in medium -> REST API Structure using NodeJS MongoDB (Mongoose)