Lolo Backend is a REST Framework and provides an automatic asynchronous CRUD (Non-Production) backend test server generator based on your models' definitions and validation rules for Node.js and MongoDB.

It is extremely easy to implement and provides a great variety of tools and possibilities for the implementation of a lightweight and strong RESTful backend server.

The purpose of this framework is to provide a quick and easy test server for frontend developers.

Installation

This is a Node.js module available through the npm registry.

Before installing, download and install Node.js.

If the installation is done using the npm install command:

npm install lolo-backend

Features

Rapid Backend Development.
Security (HTTPS, CORS, JWT).
Uses mongoose data modeling.
Automatic integration of express-validator for validation rules.
Automatic encryption of password type fields with bcrypt.
Provides asynchronous responses.
The find method provides a pager (Resolved pagination functions).
Offers the possibility to set custom routes, out of automatic CRUD routing.
Independent response translation module.

Dependencies [`self-solved`]

Lolo backend uses the following frameworks to provide an automatic CRUD Backend Server:

bcrypt: ^5.0.1 , cors: ^2.8.5 , express: ^4.17.1 , express-validator: ^6.10.0 , fs: ^0.0.1-security , http: ^0.0.1-security , https: ^1.0.0 , js-yaml: ^4.0.0 , jsonwebtoken: ^8.5.1 , moment: ^2.29.1 , mongoose: ^5.12.1 , path: ^0.12.7.

Quick Start

`Lolo Backend in 3 single steps`

Step 1 - Data modeling

`With Mongoose Schemas & Express-Validator`

Lolo Backend allows automatic import of Mongoose Schemas & Models.

During the saving process in the database (MongoDB), these Schemas allow for a previous check against the corresponding Schema. Should the validation of the schema fail, mongoose will abort the save operation.

On the other hand, for validation rules and data normalization, Lolo Backend uses express-validator. express-validator is a set of express.js middlewares that wraps validator.js validator and sanitizer functions that ensure that only the correct data input reaches its destination (MongoDB).

Import mongoose and express-validator frameworks inside models' definitions files:

//Import modules:
const mongoose = require('mongoose');
const { body } = require('express-validator');

Modeling example (Simple user data modeling with mongoose):

//Define Schema:
const Schema = new mongoose.Schema({
    username:       { type: String, required: true },
    email:          { type: String, required: true, match: /.+\@.+\..+/ },
    status:         { type: Boolean, default: false }
},
{ timestamps: true },
{ versionKey: false });

//Define model:
const Model = mongoose.model('users', Schema);

Validation rules and data normalization example (express-validator):

//Define validation rules and data normalization for your models:
const Validator = [
    body('username')
        .trim()
        .isLength(8)
        .withMessage('The username is too short (minimum lenght: 8 characters).')
        .toLowerCase(),

    body('email')
        .trim()
        .isEmail()
        .withMessage('The value entered is not a valid email.')
        .normalizeEmail({ gmail_remove_dots: false })
        .toLowerCase(),

    body('status')
        .trim()
        .isBoolean()
        .withMessage('The status entered is not a boolean (true or false).')
        .toBoolean()
];

Clarification: The elements must be exported in the following way so that they are correctly interpreted by Lolo Backend.
```
//Export Shcema, Model and Validation Rules:
module.exports = { Schema, Model, Validator };
```

Step 2 - Set your backend server parameters

Lolo Backend imports the settings.yaml file from the root of the project (./). In this file all the parameters to suit your backend server must be defined and adjusted.

Example of the contents of the settings.yaml file:

# MongoDB server settings:
db:
  host: 'localhost'
  port: 27017
  user: 'user_database'
  pass: 'pass_database'
  name: 'database_name'

# Web server settings:
webserver:
  host            : 'localhost'
  http_enabled    : true
  http_port       : 3001
  https_enabled   : false
  https_port      : 8443

# SSL settings (Only if https_enabled is true):
ssl_certificates:
  key  : './certificates/my_cert.key'
  cert : './certificates/my_cert.crt'
  ca   : false

# Set CORS and CORS whitelist:
cors_enabled: false
cors_whitelist : ['http://example.com:8080','https://another-example.com:443']

# Determine whether to use verbose mode:
verbose_log_enabled: true

# Set your secret token:
# For your safety change this value please.
secret_token: 'MY_SECRET_TOKEN'

# Establish JWT credentials for service consumers:
jwt_credentials:
  1:
    id: '54a8ce618e91b0b13665e2f9'
    username: 'angular-frontend'
    password: 'clave.segura.1'
    time_exp: '1d'
  2:
    id: '605a3f8282d6f81a5bbbc57a'
    username: 'mobile-app'
    password: 'clave.segura.2'
    time_exp: '2d'

# Set the language of the responses:
language: 'EN'

# Establish your models and their names:
models:
  users: './models/users'

# Determine whether to use custom routes:
custom_routes_enabled: true

# Set your custom routes file (Only if custom_routes_enabled is true):
custom_routes_file: './routes/custom_routes'

Important note jwt_credentials:

time_exp: Expressed in seconds or a string describing a time span zeit/ms.

Example: 60, "2 days", "10h", "7d". A numeric value is interpreted as a seconds count. If you use a string be sure you provide the time units (days, hours, etc), otherwise milliseconds unit is used by default ("120" is equal to "120ms").

Step 3 - Run your backend server

After making the models and configuring the parameters of your backend server, simply import lolo-backend and run it on your application.

//Import Lolo Backend:
const loloBackend = require('lolo-backend');

//Run Lolo Backend Server:
loloBackend.runserver();

How to use your backend server

Once the Lolo Backend is up and running, the following functions will be available for your application (API RESTful).

JSON Web Token (JWT)

Lolo Backend uses JWT to ensure secure access to data.

JWT is an open JSON-based standard for creating access tokens that allow identity and privilege propagation, in this case for your own backend server.

Request Methods

Lolo Backend provides the following list of request methods automatically for each of the defined models.

METHOD	REQUIRES BEARER TOKEN	PATH / URL	DESCRIPTION
POST	No	jwt-login	Generates a token (JWT) using authentication (`settings.yaml > credentials`).
GET	Yes	describe	Returns all the model's keys.
GET	Yes	count	Returns the number of documents that matches a specified filters.
GET	Yes	find	Finds all the records in the collection that match the filters, the projection and the requested sort.
GET	Yes	findById	Finds an element based on an ID (`MongoDB _id`).
GET	Yes	findOne	Finds a single item (first occurrence), in the collection that matches the filters, the projection and the requested sort.
POST	Yes	insert	Creates a new record in the database.
POST	Yes	update	Validates against the model and if positive, updates an existing record in the database according to the ID (`MongoDB _id`), and specified parameters.
POST	Yes	delete	Deletes an item from the database based on an ID (`MongoDB _id`).
POST	Yes	checkPassById	Checks password (`password type field`) according to the ID (`MongoDB _id`).

Supported parameters & forms

jwt-login

admit: x-www-form-urlencoded
- username = username defined in your settings.yaml file in the credentials section. REQUIRED
- password = password defined in your settings.yaml file in the credentials section. REQUIRED

describe
- Does not admit parameters.
count

admit: URL Query Parameters
- filter[field_name] = string, number, boolean.

find

admit: URL Query Parameters
- filter[field_name] = string, number, boolean.
- proj[field_name] = number (1 or 0 - Based on MongoDB Projections).
- sort[field_name] = number (1 or -1 - Based on MongoDB Sort definitions).
- skip = number.
- limit = number.
- pager[page_number] = number.
- pager[page_limit] = number.
  
  Important note pager: "If you use the pager parameters, keep in mind these overwrite the skip and limit parameters".
findById

admit: URL Query Parameters
- id = MongoDB _id. REQUIRED
- proj[field_name] = number (1 or 0 - Based on MongoDB Projections).
findOne

admit: URL Query Parameters
- filter[field_name] = string, number, boolean.
- proj[field_name] = number (1 or 0 - Based on MongoDB Projections).
- sort[field_name] = number (1 or -1 - Based on MongoDB Sort definitions).
insert

admit: x-www-form-urlencoded
- Your models' fields: name_field = value. REQUIRED
update

admit: x-www-form-urlencoded
- id = MongoDB _id. REQUIRED
- Fields to set: name_field = value. REQUIRED
delete

admit: x-www-form-urlencoded
- id = MongoDB _id. REQUIRED
checkPassById

admit: x-www-form-urlencoded
- id = MongoDB _id. REQUIRED
- password_field_name = password_to_check. REQUIRED

Set password case

If your model has a password type field, it must be specified with the isPassword() method of Lolo Backend's middleware crudMiddleware and this field will automatically be encrypted before being saved.

The request method checkPassById is available to validate the saved password field.

Modeling and validation rules definition example (Simple user data modeling with password field):

//Import modules:
const mongoose = require('mongoose');
const { body } = require('express-validator');
const loloBackend = require('lolo-backend');

//Define Pre-Schema (Only if a password field exists):
//For the rest of the cases use Schema directly.
const preSchema = new mongoose.Schema({
    username:       { type: String, required: true },
    password:       { type: String, required: true },
    email:          { type: String, required: true, match: /.+\@.+\..+/ },
    status:         { type: Boolean, default: false }
},
{ timestamps: true },
{ versionKey: false });

//Indicate that the schema has a password (to be encrypted):
Schema = loloBackend.crudMiddleware.isPassword(preSchema, 'password');

//Define model:
const Model = mongoose.model('users', Schema);

//Define validation rules and data normalization for your models:
const Validator = [
    body('username')
        .trim()
        .isLength(8)
        .withMessage('The username is too short (minimum lenght: 8 characters).')
        .toLowerCase(),
    
    body('password')
        .trim()
        .isLength(8)
        .withMessage('The password is too short (minimum lenght: 8 characters).'),

    body('email')
        .trim()
        .isEmail()
        .withMessage('The value entered is not a valid email.')
        .normalizeEmail({ gmail_remove_dots: false })
        .toLowerCase(),

    body('status')
        .trim()
        .isBoolean()
        .withMessage('The status entered is not a boolean (true or false).')
        .toBoolean()
];

//Export Shcema, Model and Validation Rules:
module.exports = { Schema, Model, Validator };

Supported languages

Currently, Lolo Backend supports the following languages for its response messages.

English ( EN )
Spanish ( ES )

Example of a simple project

An example of a simple project is available for download here.

License

Lolo Backend is licensed by MIT License.

lolo-backend

Installation

Features

Dependencies [`self-solved`]

Quick Start

`Lolo Backend in 3 single steps`

Step 1 - Data modeling

`With Mongoose Schemas & Express-Validator`

Step 2 - Set your backend server parameters

Step 3 - Run your backend server

How to use your backend server

JSON Web Token (JWT)

Request Methods

Supported parameters & forms

jwt-login

describe

count

find

findById

findOne

insert

update

delete

checkPassById

Set password case

Supported languages

Example of a simple project

License

Readme

Keywords

Package Sidebar

Install

Weekly Downloads

Version

License

Unpacked Size

Total Files

Last publish

Collaborators

lolo-backend

Installation

Features

Dependencies [self-solved]

Quick Start

Lolo Backend in 3 single steps

Step 1 - Data modeling

With Mongoose Schemas & Express-Validator

Step 2 - Set your backend server parameters

Step 3 - Run your backend server

How to use your backend server

JSON Web Token (JWT)

Request Methods

Supported parameters & forms

jwt-login

describe

count

find

findById

findOne

insert

update

delete

checkPassById

Set password case

Supported languages

Example of a simple project

License

Readme

Keywords

Package Sidebar

Install

DownloadsWeekly Downloads

Version

License

Unpacked Size

Total Files

Last publish

Collaborators

Dependencies [`self-solved`]

`Lolo Backend in 3 single steps`

`With Mongoose Schemas & Express-Validator`

Weekly Downloads